Documente Academic
Documente Profesional
Documente Cultură
Zroute Training Lab
Version 1.0
Introduction:
These labs are designed to provide an introduction to Zroute concepts and flow. This guide provides
instructions for running the labs. You might find it useful to refer to the general lab problem description
and then review the prepared solution scripts.
This lab uses the existing Customer Education Services (CES) IC Compiler training lab. This provides a
good example for the Zroute flow, even if it doesn’t cover the nuances of more advanced technologies.
For more details, see the Zroute training and the IC Compiler Zroute User Guide.
Supported Versions:
This lab supports IC Compiler versions C‐2009.06 and C‐2009.06‐SP1. For earlier versions of IC Compiler,
please see previous versions of the lab.
Available Labs:
• Lab 1: Translating the classic router environment to Zroute
• Lab 2: Multi‐threading with Zroute
• Lab 3: Running Zroute with route_opt
• Lab 4: Running Zroute with route_zrt_auto
• Lab 5: Running Zroute with basic commands
• Lab 6: Integrated clock global routing (ICGR) and clock routing with Zroute
• Lab 7: Including design‐for‐manufacturing (DFM) with Zroute
• Lab 8: Shielding with Zroute
If you do not have enough time to complete all the labs, you should run highlighted labs first. Labs 4 and
5 are similar to Lab 3, but show slightly different methods and options.
General Instructions for All Labs
After untarring and unzipping the labs, the first directory contains the reference data information in the
ref directory, a README file, and these instructions. All labs run in the zroute_lab directory. The lab
directory contains a Makefile that can run the scripts directly and an icc_scripts directory with scripts in
it. The lab instructions in the following section provide step‐by‐step instructions at the beginning,
followed by more general discussions for later labs. You can use the solutions in the scripts directory to
help with labs that are more generally worded or to attempt the labs without detailed instructions.
The Makefile assumes that icc_shell is in your path or is linked from the working directory. You can also
add the icc_shell path to the Makefile.
LAB 1
Translating the Classic Router Environment to Zroute
zroute_translate.tcl
The purpose of this lab is to introduce some concepts related to setting up Zroute based on an existing
classic router script and environment. A parameter translation program is provided that can help you
accomplish this, but the translation program is not designed to become an integral part of running
Zroute. You should take the time to set up Zroute‐specific scripts based on the results of investigating
your current classic router setup. To get optimal Zroute results, you might find some concepts and
parameters from the classic router are no longer applicable, and that the sequential classic router scripts
can be optimized by running those steps concurrently with Zroute. Antenna fixing, wire and via
optimization, and off‐grid pin solutions are three examples of sequential scripting that can be eliminated
with Zroute.
The easiest way to check what needs to be translated is to run the translator on the existing classic
router script just before you would execute the classic router command. You might need to do this
more than once. The translator translates the parameters or outputs different types of message for
different types of parameters. For example,
1. Start IC Compiler and source the icc_setup.tcl file.
% icc_shell –f icc_setup.tcl | tee –i zroute_translate.log
The icc_setup.tcl file defines the timing library, Milkyway library, TLUPlus settings, and other
setup values, including variables used in the script.
2. Open the library, copy the starting cell, and open it.
open_mw_lib orca_lib.mw
copy_mw_cel –from clock_opt_route_icc –to zroute_translate
open_mw_cel zroute_translate
3. Run the classic router script up to the point of running a routing command. This example shows
the translation after setting the routing options, after setting the signal integrity (SI) options,
and after setting the antenna options.
source icc_scripts/set_operating_conditions.tcl
set_route_options \
-same_net_notch check_and_fix \
-wire_contact_eol_rule check_and_fix
4. Translate the classic router parameters into Zroute options.
translate_zrt_parameters
5. Analyze the translation.
Zroute fixes notch and gap by default, so the default of ‐ignore_drc {} has the same effect as the
syntax shown above.
######
######Parameters not translated
######=========================
######Information: droute parameter wrongWayNoVia is obsolete in
Zroute. (ZRT-410)
You can ignore obsolete parameters. In the classic router, this parameter was set by the
set_route_options -wire_contact_eol_rule command.
6. For the most part, the classic router is controlled by parameters, even if those parameters are
set by using other functions. To demonstrate this point, set the signal integrity options before
the second translation:
set_si_options \
-route_xtalk_prevention true \
-route_xtalk_prevention_threshold 0.25 \
-delta_delay true
7. Translate the parameters again.
translate_zrt_parameters
8. Analyze the translation again. Note that only new messages are shown below.
The avoidXtalk parameter is set by the set_si_options -route_xtalk_prevention
true command. When you run the set_si_options command, it sets the appropriate Zroute
global route options (set_route_zrt_global_options), so there is no need to translate this
option.
######Translated trackAssign parameter noiseThreshold value 0.25
to set_route_zrt_common_options -threshold_noise_ratio 0.25
The noiseThreshold parameter is set by the set_si_options
-route_xtalk_prevention_threshold 0.25 command. When you run the
set_si_options command, it sets the appropriate Zroute common route options
(set_route_zrt_common_options), so there is no need to translate this option.
When you run the set_si_options command, it sets the appropriate Zroute track assignment
options (set_route_zrt_track_options), so there is no need to translate this option.
9. During a classic router flow, parameters are often added sequentially during the flow. For
example, antenna fixing might be done after initial routing. When investigating parameter
translation, you might want to check at subsequent steps in the flow. To illustrate this point,
let’s look at loading the antenna rules. Load the antenna settings before running the third
translation by running the following commands:
echo $ANTENNA_RULES_FILE_CLASSIC
source $ANTENNA_RULES_FILE_CLASSIC
10. Translate the parameters again.
translate_zrt_parameters
11. Analyze the translation.
Antenna fixing is on‐by‐default in Zroute. After you load the rules into the Milkyway library, the
rules are checked and fixed unless you turn them off. Note that the rules are stored in the
Milkyway library, but the Zroute options are stored in the CEL view, so if rules are loaded in the
library from a previous run, subsequent runs will check and fix the antenna rules.
12. At this point you would analyze the various translations and use that information to create a
script that runs Zroute explicitly. For example, the translation information in this lab was used
to create the script in lab 3. Using parameter translation directly in the script is not
recommended as a long term solution. For example, each translation can overwrite the Zroute
options that you have set, because the parameters are static and get retranslated.
quit
LAB 2
Multi‐Threading With Zroute
zroute_multithreading.tcl
The purpose of this lab is to introduce multi‐threading inside Zroute. Multi‐threading means that the
software was engineered to run in parallel on the same computer using shared memory. Multi‐
threading is different from distributed routing, which typically partitions a job and sends each partition
to a different CPU, each of which uses different memory. Zroute can be multi‐threaded up to the
number of available CPU cores. If you have a single CPU, dual core machine, you can use two threads. A
single CPU, quad core machine or a two CPU, dual core machine can use four threads. IT departments
seem to account for CPUs and cores inconsistently, especially when referring to resources on LSF or GRD
systems. Sometimes a single CPU, dual core machine is listed as two CPUs. So don’t think it is two CPUs
with two cores each if you notice it is a dual core machine. You should make sure the number of threads
does not exceed the real number of cores.
1. Start IC Compiler and source the icc_setup.tcl file.
% icc_shell –f icc_setup.tcl | tee –i zroute_multithreading.log
The icc_setup.tcl file defines the timing library, Milkyway design library, TLUPlus settings, and
other setup values, including variables used in the script.
2. Open the library, copy the starting cell, and open it.
open_mw_lib orca_lib.mw
copy_mw_cel –from clock_opt_route_icc –to zroute_multithreading
open_mw_cel zroute_multithreading
3. Determine the number of CPU cores.
a. Try the cpuinfo command first.
sh grep MHz /proc/cpuinfo
Here is an example report from a two CPU, dual core machine. Note that each core is
reported once.
##cpu MHz : 2394.245
##cpu MHz : 2394.245
##cpu MHz : 2394.245
##cpu MHz : 2394.245
b. Try to use the message of the day (MOTD). Some IT departments set this up to give CPU
information.
sh cat /etc/motd
## Linux 2.6.9-55.ELsmp x86_64
## OS: RedHat Enterprise Linux 4.0 U4
## Hostname: azz284
## CPU: 4 x 2394 MHz, AMDOpteron(tm)Processor280 (2
socket, dual core)
## Memory: 16 GB RAM, 33 GB Swap
## QSC: QSC-A
4. Determine the number of threads.
For the best results with multi‐threading, use one thread per CPU per core. For example, if you
have two dual core CPUS, you can have 2 x 2 = 4 threads.
5. Specify Zroute as the router for embedded route commands.
6. Enable multi‐threading by using the set_host_options command.
In the following command, change the “2” to the number of threads you determined for your
machine:
set_host_options –max_cores 2
Note that in version C‐2009.06, you also set the max_number_of_threads common Zroute
option to ensure that the desired number of cores are used. In version C‐2009.06‐SP1 or later,
this is no longer necessary.
set_route_zrt_common_options -max_number_of_threads 2
7. Turn off antenna fixing. Because we loaded the antenna rules into the design library in first lab,
Zroute checks and fixes antenna violations.
8. Route the design.
route_zrt_auto
9. Review the log. Search for the following text:
10. Query the design to see if it is routed by Zroute.
is_zrt_routed_design
Note that the is_zrt_routed_design command returns true or false, so you can use the
return value to make decisions.
if {[is_zrt_routed_design]} {
echo "Zroute is great"
} else {
echo "Classic router is not too bad either"
}
11. Exit the lab.
quit
LAB 3
Using Zroute With route_opt
zroute_route_opt.tcl
The purpose of this lab is to show a typical flow using Zroute as the router that runs inside the
route_opt command. This is enabled by setting the route mode to Zroute. Once this is set, all
embedded routing is based on Zroute.
1. Start IC Compiler and source the icc_setup.tcl file.
% icc_shell –f icc_setup.tcl | tee –i zroute_route_opt.log
The icc_setup.tcl file defines the timing library, Milkyway design library, TLUPlus settings, and other
setup values, including variables used in the script.
2. Open the library, copy the starting cell, and open it.
open_mw_lib orca_lib.mw
copy_mw_cel –from clock_opt_route_icc –to zroute_route_opt
open_mw_cel zroute_route_opt
3. Set the operating conditions.
source icc_scripts/set_operating_conditions.tcl
If you want to compare memory usage with the classic router, disable splitting of the routing
process. Unless process splitting is disabled, the classic router always splits the routing process.
Zroute adaptively splits the routing process based on net count and current memory usage. To
disable process splitting in both the classic router and Zroute , enter the following command:
set_app_var physopt_enable_router_process false
Note that the set_app_var command is a special version of the Tcl set command. If the
variable is properly registered as an application variable, the set_app_var command verifies that
the spelling and syntax are correct. If not, it returns an error, but it still sets the variable to the
specified value.
4. Set the signal integrity options.
set_si_options \
-route_xtalk_prevention true \
-route_xtalk_prevention_threshold 0.25 \
-delta_delay true
5. Specify Zroute as the router for embedded route commands.
set_route_mode_options -zroute true
6. (Optional) Enable multi‐threading. (See Lab 2 for more details.)
set_host_options –max_cores 2
7. Read the antenna rules. After the rules are set in the design library, Zroute checks and fixes them by
default .
echo $ANTENNA_RULES_FILE
source $ANTENNA_RULES_FILE
8. Set the Zroute antenna options.
set_route_zrt_detail_options -default_diode_protection 0.5
Reminder: These might be in the antenna file. The Zroute option is stored with the cell, so it will be
set in subsequent versions of the cell. However, if you intend to run another cell in the same library
without antenna fixing, you must turn off Zroute antenna fixing because Zroute picks up the rules
from the library. If you later start fixing antenna violations in such a cell, you must remember to set
any needed Zroute antenna options in the new cell.
9. Route the design using the route_opt flow:
route_opt -initial_route_only
If you review the log you should see the following text:
The purpose of this lab is to show how to explicitly set the signal integrity and timing options and to use
the route_zrt_auto command to mimic the same flow as in the previous lab. This lab also shows how
to set verbose messaging in Zroute.
1. Start IC Compiler and source the icc_setup.tcl file.
% icc_shell –f icc_setup.tcl | tee –i route_zrt_auto.log
The icc_setup.tcl file defines the timing library, Milkyway library, TLUPlus settings, and other
setup values, including variables used in the script.
2. Open the library, copy the starting cell, and open it.
open_mw_lib orca_lib.mw
copy_mw_cel –from clock_opt_route_icc –to zroute_auto
open_mw_cel zroute_auto
3. Set the operating conditions.
source icc_scripts/set_operating_conditions.tcl
4. Enable the signal integrity options. The following commands enable the same signal integrity
options as in Step 5 of Lab 3.
5. Specify Zroute as the router for embedded routing commands.
set_route_mode_options -zroute true
6. Enable timing‐driven routing. The following commands enable the same settings as used by the
route_opt -initial_route_only command.
set_route_zrt_global_options -timing_driven true
set_route_zrt_track_options -timing_driven true
set_route_zrt_detail_options -timing_driven true
7. (Optional) Enable multi‐threading. (See Lab 2 for more details.)
set_host_options –max_cores 2
8. Enable verbose reporting.
set_route_zrt_common_options -verbose_level 1
9. Read the antenna rules. After the antenna rules are set in the design library, Zroute checks and
fixes them by default .
echo $ANTENNA_RULES_FILE
source $ANTENNA_RULES_FILE
10. Set the Zroute antenna options.
set_route_zrt_detail_options -default_diode_protection 0.5
11. Route the design using the same number of iterations as the route_opt default.
route_zrt_auto -max_detail_route_iterations 10
By default, the maximum number of iterations is 40 for Zroute auto route (the
route_zrt_auto command) and the Zroute basic routing commands.
12. Review the log and notice that all the Zroute option settings are printed in the log during the
routing command.
13. The rest of lab is the same as the previous lab; exit the lab when ready.
quit
LAB 5
Using Zroute With Basic Commands
zroute_basic.tcl
The purpose of this lab is to show a flow similar to the previous lab, but using basic commands. This lab
also shows how to disable antenna fixing and how to report Zroute options. Because this lab is so
similar to the previous lab, only the changes are highlighted.
1. Start IC Compiler and source the icc_setup.tcl file.
% icc_shell –f icc_setup.tcl | tee –i zroute_basic.log
The icc_setup.tcl file defines the timing library, Milkyway library, TLUPlus settings, and other
setup values, including variables used in the script.
2. Open the library, copy the starting cell, and open it.
open_mw_lib orca_lib.mw
copy_mw_cel –from clock_opt_route_icc –to zroute_basic
open_mw_cel zroute_basic
3. Use the appropriate steps from the previous lab, but replace verbose reporting with the
following commands:
report_route_zrt_common_options
report_route_zrt_global_options
report_route_zrt_track_options
report_route_zrt_detail_options
4. Disable antenna fixing, in case the antenna rules are already loaded in the design library.
set_route_zrt_detail_options -antenna false
5. Use the following basic commands instead of the route_zrt_auto command:
route_zrt_global
route_zrt_track
route_zrt_detail
6. Verify the routing, but exclude antenna checking.
verify_zrt_route -antenna false
Note that the summary shows that no antenna checking was done.
Total number of antenna violations = not checked
7. Exit lab.
quit
LAB 6
Integrated Clock Global Routing and Clock Routing With Zroute
zroute_clock_routing_with_icgr.tcl
The purpose of this lab is to introduce you to using Zroute for clock routing. Zroute does not do
balanced clock routing directly (like the classic router can), so to get balanced routing, you must use the
integrated clock global routing (ICGR) flow with Zroute. Without the ICGR flow, you should consider
using the classic router to route clock nets so that the routing will be balanced.
1. Start IC Compiler and source the icc_setup.tcl file.
The icc_setup.tcl file defines the timing library, Milkyway library, TLUPlus settings, and other setup
values, including variables used in the script.
2. Open the library, copy the starting cell, and open it.
open_mw_lib orca_lib.mw
copy_mw_cel –from place_opt_icc \
–to zroute_clock_routing_with_icgr
open_mw_cel zroute_clock_routing_with_icgr
3. Set the operating conditions.
source icc_scripts/set_operating_conditions.tcl
4. Enter the clock tree synthesis setup.
set_clock_uncertainty 0.1 [all_clocks]
set_clock_tree_options -target_skew 0.1
set_clock_tree_exceptions \
-stop_pins {I_SDRAM_TOP/I_SDRAM_IF/sd_mux_*/S}
reset_clock_tree_references
set_clock_tree_references -references $ICC_CTS_REF_LIST
remove_routing_rules -all
define_routing_rule double_spacing -default_reference_rule \
-spacings {METAL3 0.6 METAL4 0.8 METAL5 1.2 METAL6 1.4}
6. Run clock tree synthesis with ICGR during clock tree optimization.
set_delay_calculation -clock_arnoldi
clock_opt -only_cts -no_clock_route
7. Save the design.
save_mw_cel -as clock_opt_cts_icc
8. Perform post‐clock‐tree‐synthesis timing optimization.
set_fix_hold [all_clocks]
extract_rc
clock_opt -only_psyn -no_clock_route
9. Reconnect any open nets in the global routing on clock leaf nets, which are caused by optimization
on flip‐flops and legalization around flip‐flops. This is useful if reporting is done after optimization or
if an additional optimization will be done.
route_zrt_group -all_clock_nets \
-reuse_existing_global_route true -stop_after_global_route true
10. (Optional) Enable multi‐threading. (See Lab 2 for more details.)
set_host_options -max_cores 2
11. (Optional) Insert redundant vias on the clock nets during routing.
set_route_zrt_common_options \
-post_detail_route_redundant_via_insertion medium
12. Route the clocks using the result from ICGR.
13. Set more accurate delay calculation with only the clocks routed.
set_delay_calculation -clock_arnoldi
14. Verify the routing.
verify_zrt_route -open_net false -antenna false
15. Check the skew.
report_clock_tree
16. Exit the lab.
quit
LAB 7
Including Design‐for‐Manufacturing With Zroute
zroute_dfm.tcl
The purpose of this lab is to show chip finishing commands in the Zroute flow. This includes items such
as redundant vias, filler cell insertion, metal fill, critical area analysis (CAA) and improving CAA through
wire spreading and wire widening, and inserting diodes. Warning: This lab takes some time to run. You
can use the Makefile to run this lab in batch mode.
1. Start IC Compiler and source the icc_setup.tcl file.
% icc_shell –f icc_setup.tcl | tee –i zroute_dfm.log
The icc_setup.tcl file defines the timing library, Milkyway design library, TLUPlus settings, and
other setup values, including variables used in the script.
2. Open the library, copy the starting cell, and open it.
open_mw_lib orca_lib.mw
copy_mw_cel –from clock_opt_route_icc –to zroute_dfm
open_mw_cel zroute_dfm
3. Set the operating conditions.
source icc_scripts/set_operating_conditions.tcl
4. Set the signal integrity options.
set_si_options \
-route_xtalk_prevention true \
-route_xtalk_prevention_threshold 0.25 \
-delta_delay true
5. Specify Zroute as the router for the embedded routing commands.
set_route_mode_options -zroute true
6. (Optional) Enable multi‐threading. (See Lab 2 for more details.)
set_host_options -max_cores 2
7. Read the antenna rules. After the antenna rules are set in the design library, Zroute checks and
fixes them by default.
echo $ANTENNA_RULES_FILE
source $ANTENNA_RULES_FILE
2. Set the Zroute antenna options.
set_route_zrt_detail_options -default_diode_protection 0.5
8. Check which vias will be used for redundant via insertion. Use the
define_zrt_redundant_vias command to customize.
insert_redundant_vias –list_only
9. Enable redundant via insertion for rest of the flow so that redundant vias are inserted after ECO
routing each time it is run.
set_route_zrt_common_options \
-post_detail_route_redundant_via_insertion medium
10. Route the design.
route_opt -initial_route_only
14. Report the redundant via rate by layer.
report_design_physical -all -verbose
15. Generate the preliminary critical area reports. You would normally use a text editor to view the
./output_heatmap file, but here we will rename the files.
report_critical_area -fault_type short
sh mv output_heatmap caa.short.init.txt
19. Compare one of the critical area reports by using the summary at the top. For example,
Critical Area Critical Area As
layer in sq. micron %% of Chip Area
‐‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐‐‐ ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
m1 11346.025 2.029
m2 6226.064 1.114
m3 7427.338 1.329
m4 1724.600 0.308
m5 2921.103 0.523
m6 1415.833 0.253
If you sum these up, there is 5.538% critical area on the design for the particular check run.
20. Fix the remaining antenna violations, if any, the next time you run routing.
set DIODE_NAMES adiode
set_route_zrt_detail_options \
-diode_libcell_names $DIODE_NAMES \
-insert_diodes_during_routing true
21. Insert filler cells (with and without metal).
22. Perform final timing cleanup.
route_opt -incremental -size_only
23. Verify the routing.
verify_zrt_route
24. Report the design summary.
report_design_physical -all -verbose
25. Exit the lab.
quit
LAB 8
Including Shielding With Zroute
zroute_shielding.tcl
The purpose of this lab is to show the shielding flow. The lab uses clock tree synthesis with ICGR and
shields one of the clock nets. The clock net is shielded after clock routing and before signal routing. This
flow maximizes the shielding rate. Alternatively, you can shield the net after signal routing. In that case,
the shielding rate will be lower, but routing DRC closure will be easier.
1. Start IC Compiler and source the icc_setup.tcl file.
% icc_shell –f icc_setup.tcl |
tee –i zroute_clk_routing_with_shielding.log
The icc_setup.tcl file defines the timing library, Milkyway design library, TLUPlus settings, and
other setup values, including variables used in the script.
2. Open the library, copy the starting cell, and open it.
open_mw_lib orca_lib.mw
copy_mw_cel –from place_opt_icc \
–to zroute_clock_routing_with_shielding
open_mw_cel zroute_clock_routing_with_shielding
3. Set the operating conditions.
source icc_scripts/set_operating_conditions.tcl
4. Enter the clock tree synthesis setup.
set_clock_uncertainty 0.1 [all_clocks]
reset_clock_tree_references
set_clock_tree_references -references $ICC_CTS_REF_LIST
5. Define the routing rules for most clocks.
remove_routing_rules -all
define_routing_rule double_spacing \
-default_reference_rule \
-spacings {METAL3 0.6 METAL4 0.8 METAL5 1.2 METAL6 1.4}
13. Set more accurate delay calculation with only the clocks routed.
set_delay_calculation -clock_arnoldi
14. Perform clock shielding for the SYS_2x_CLK net before signal routing. The shielding rate is
higher, but later DRC convergence might be tougher.
create_zrt_shield
15. Set incremental shielding options.
set_route_zrt_detail_options -reshield_rerouted_nets reshield
16. Verify the routing.
verify_zrt_route -open_net false -antenna false
17. Save the design.
save_mw_cel –as zroute_clock_routing_with_shielding
18. Check the skew.
report_clock_tree
19. Report the design summary.
report_design_physical -all -verbose
20. Exit the lab.
quit