( ESNUG 364 Item 12 ) -------------------------------------------- [02/01/01]
From: [ A Synopsys AC in Dallas ]
Subject: A Tcl Script That Tricks PhysOpt Into Cleaning Up Net Congestion
Hello John,
I wanted to share with your readers a Tcl script a fellow AC here in Dallas
developed to help deal w/ a severely congested design in Physical Compiler.
Here is a little background. We were using Physical Compiler v1.1 to
synthesize a datapath module which was a performance AND routing headache.
The routing headache resulted from the output pin placements on the
module. All of the outputs were packed very tightly in the lower right
hand corner of the module, producing a significant congestion "hot spot" in
that area. Physical Compiler provided several different ways to attack
congestion in the design and all of these had a positive effect. The issue
we faced was that these approaches work globally on the design. We wanted
a way to focus the congestion relief algorithms to work specifically in
this one area. Hence, the creation of the Tcl script.
The Tcl script is a procedure called routing_obs. This procedure provides
a way to define a region on the die and reduce the routing resources
available within that area. The user can reduce the routing resources in
the vertical and/or horizontal directions. This is accomplished by creating
"stripes" of routing obstructions in the region, with the user determining
the width of the stripes as well as their spacing. The result is that as
Physical Compiler optimizes the design for congestion, this region will be
seen as having less routing resources than the overall design, and the
congestion algorithm will thus work harder.
Example:
___________________________________________
| |
| |
| |
| ______ {5000 10000} |
| | | |
| | | |
| | | |
| {1000 4000} |______| |
|__________________________________________|
Assume that you had the situation above and the region where you wish to
focus the congestion relief is the smaller box above. The coordinates of
the lower left hand corner are {1000 4000} and the coordinates of the upper
right hand corner are {5000 10000}. You have decided to reduce routing in
the horizontal direction only and want to create a routing obstruction
placed every 300 microns. The routing_obs routine would be called as:
routing_obs 1000 4000 5000 10000 horizontal 300 horiz_obs
Note that the width of the routing obstruction would be determined by the
definition of the site variable in the routine. For this example, each
obstruction would be 13.6 microns wide. The name of each obstruction will
be the horiz_obsXX where XX would be a counter value.
To use the procedure, add the section below to your .synopsys_dc.setup file
or create a file with the section and source it as part of your Physical
Compiler setup.
proc routing_obs {bound_llx bound_lly bound_urx bound_ury method step
prefix} {
#
# Notes:
# 1) The procedure allows the user to build three types of routing
# congestion grids based on the "method" used when calling the
# procedure
# horizontal - builds a grid of obstructions on the horizontal
# metal layer
# vertical - builds a grid of obstructions on the vertical
# metal layer
# checker - builds a grid of obstructions on both the vertical
# and horizontal metal layer
# 2) The procedure assumes the coordinates used in the procedure
# call are in 1 micron units. This is the value expected by the
# create_obstruction command.
# 3) The site variable below is the Y-dimension of your placement
# site defined in the lef file. The site height is used to set
# the width of the routing obstruction. For this case it seemed
# that a good target was to make a routing obstruction that would
# cover the width of a placement row. The user can set this to
# whatever they wish but this gives a good starting point.
#
# ------> The 13.60 um site value in the script should be adjusted
# based on the user's library.
#
# 4) The layers used for the routing obstructions are hard-coded below.
# Make sure this corresponds to what is defined for your routing
# layers. In this example, the technology had 5 layers of metal
# organized in an HVHVH fashion. For this example below, I use
# MET3 for horizontal and MET4 for vertical.
#
# ------> The user may also have different layer names: M4, MET4,
# or METAL4, and will need to modify the script accordingly.
#
# setup default variables
#
set site 13.60
set location_x $bound_llx
set location_y $bound_lly
set counter 0
if {($method == "horizontal") || ($method == "checker")} {
#
# set obstructions above start point
# -- obstruction are set to be shorter than the cell height
while {$location_y < $bound_ury} {
set temp [expr $location_y + $site]
set x1 $bound_llx
set y1 $location_y
set x2 $bound_urx
set y2 $temp
#
set temp_list [concat $x1 $y1 $x2 $y2]
puts "coordinates = $temp_list"
create_obstruction -name "$prefix$counter" -layer MET3 -coordinate $temp_list
set counter [expr $counter + 1]
set location_y [expr $location_y + $step]
}
};# end of the horizontal method
#
if {($method == "vertical") || ($method == "checker")} {
# set obstructions right of start point
while {$location_x < $bound_urx} {
set temp [expr $location_x + $site]
set x1 $location_x
set y1 $bound_lly
set x2 $temp
set y2 $bound_ury
#
set temp_list [concat $x1 $y1 $x2 $y2]
puts "coordinates = $temp_list"
create_obstruction -name "$prefix$counter" -layer MET4 -coordinate $temp_list
set counter [expr $counter + 1]
set location_x [expr $location_x + $step]
}
};# end of the vertical method
echo "The total number of obstructions created = $counter"
};# end of the procedure
Using this script, we were able to focus the congestion algorithms and
eliminate the problem.
Two caveats to your readers.
1) Use this procedure judiciously. The congestion relief algorithms in
Physical Compiler can solve most of your congestion issues, however,
if you have a design with significant congestion problems in a
localized are, this Tcl procedure might help!
2) Whenever you are dealing with congestion issues, you may find that
displaying the congestion in a GUI allows you to quickly see the
problem. I would encourage your readers to use the Physical Compiler
GUI to visually look at the congestion and observe the effect of using
this procedure.
Thanks,
- [ A Synopsys AC in Dallas ]
|
|
