| # %CopyrightNotice |
| |
| namespace eval ff_procs:: { |
| |
| ############################################################################### |
| # Procedure to seed certain flow variables to a known default value as well |
| # as data variables required to seed the generic configuration file |
| ############################################################################### |
| |
| proc load_path_groups {file} { |
| |
| read_dc_script $file |
| |
| } |
| |
| proc source_plug {plugin {abort 1}} { |
| |
| global vars |
| global plugin_error |
| global errorInfo |
| global return_code |
| |
| |
| if {[info exists vars($plugin)]} { |
| Puts "<FF> LOADING '$plugin' PLUG-IN FILE(s) " |
| foreach plugin $vars($plugin) { |
| if {[file exists $plugin]} { |
| Puts "<FF> -> $plugin" |
| if { [ catch { uplevel source $plugin } plugin_error ] } { |
| Puts "<FF> ============= PLUG-IN ERROR ==================" |
| Puts "<FF> $errorInfo" |
| Puts "<FF> $plugin_error" |
| Puts "<FF> ==============================================" |
| set return_code 99 |
| if {[info exists vars(mail,to)]} { |
| set msg "From: [exec whoami] " |
| append msg \n "To: " [join $vars(mail,to) ,] |
| append msg \n "Cc: " [join "" ,] |
| append msg \n "Subject: " "FF: $vars(design), $vars(step) failed ([pwd])" |
| append msg \n\n $errorInfo |
| exec /usr/lib/sendmail -oi -t << $msg |
| } |
| |
| if {$abort} { |
| exit $return_code |
| } |
| } |
| } else { |
| if {[file exists $vars(plug_dir)/$plugin]} { |
| Puts "<FF> -> $vars(plug_dir)/$plugin" |
| if { [ catch { uplevel source $vars(plug_dir)/$plugin } plugin_error ] } { |
| if {[info exists vars(mail,to)]} { |
| set msg "From: [exec whoami] " |
| append msg \n "To: " [join $vars(mail,to) ,] |
| append msg \n "Cc: " [join "" ,] |
| append msg \n "Subject: " "FF: $vars(design), $vars(step) failed ([pwd])" |
| append msg \n\n $errorInfo |
| exec /usr/lib/sendmail -oi -t << $msg |
| } |
| set return_code 99 |
| if {$abort} { |
| exit $return_code |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| proc report_time {} { |
| global vars |
| |
| set run_time [expr [clock seconds] - $vars($vars(step),start_time)] |
| |
| if {$run_time > 86400} { |
| set days [expr $run_time / 86400] |
| } else { |
| set days 0 |
| } |
| set run_time [clock format $run_time -format %H:%M:%S -gmt true] |
| Puts "<FF> ==============================================" |
| Puts "<FF> COMPLETED STEP : $vars(step)" |
| Puts "<FF> ELAPSED RUNTIME : $days days, $run_time" |
| Puts "<FF> ==============================================" |
| } |
| |
| proc modify_power_domains {} { |
| |
| global vars |
| |
| #################################################################################### |
| ### modify power domain |
| #################################################################################### |
| |
| set vars(power_domains) [ff_procs::get_power_domains] |
| |
| foreach domain $vars(power_domains) { |
| if {[info exists vars($domain,bbox)] || \ |
| [info exists vars($domain,rs_exts)] || \ |
| [info exists vars($domain,min_gaps)]} { |
| Puts "<FF> Modifying power domain $domain ..." |
| set command "modifyPowerDomainAttr $domain " |
| if {[info exists vars($domain,bbox)]} { |
| append command "-box $vars($domain,bbox) " |
| } |
| if {[info exists vars($domain,rs_exts)]} { |
| append command "-rsExts $vars($domain,rs_exts) " |
| } |
| if {[info exists vars($domain,min_gaps)]} { |
| append command "-minGaps $vars($domain,min_gaps) " |
| } |
| eval $command |
| } |
| } |
| } |
| proc add_power_switches {{domains ""}} { |
| |
| global vars |
| global map |
| |
| #################################################################################### |
| ### add power switch |
| #################################################################################### |
| |
| source $vars(script_root)/ETC/EDI/map_options.tcl |
| |
| if {$domains == ""} { |
| set domains [ff_procs::get_power_domains] |
| } |
| |
| foreach domain $domains { |
| if {[info exists vars($domain,switchable)] && $vars($domain,switchable)} { |
| |
| deletePowerSwitch -$vars($domain,switch_type) -powerDomain $domain |
| |
| set command "addPowerSwitch -powerDomain $domain -$vars($domain,switch_type) " |
| |
| if {[info exists vars($domain,distribute)] && $vars($domain,distribute)} { |
| append command "-distribute " |
| } |
| if {[info exists vars($domain,checker_board)] && $vars($domain,checker_board)} { |
| append command "-checkerBoard " |
| } |
| if {[info exists vars($domain,back_to_back_chain)] && $vars($domain,back_to_back_chain)} { |
| append command "-backToBackChain " |
| } |
| if {[info exists vars($domain,loop_back_at_end)] && $vars($domain,loop_back_at_end)} { |
| append command "-loopbackAtEnd " |
| } |
| if {[info exists vars($domain,check_height)] && !$vars($domain,check_height)} { |
| append command "-noDoubleHeightCheck " |
| } |
| if {[info exists vars($domain,verify_rows)] && !$vars($domain,verify_rows)} { |
| append command "-noRowVerify " |
| } |
| if {[info exists vars($domain,enable_chain)] && !$vars($domain,enable_chain)} { |
| append command "-noEnableChain " |
| } |
| |
| foreach option [array names map] { |
| if {[info exists vars($domain,$option)]} { |
| append command "-$map($option) $vars($domain,$option) " |
| } |
| } |
| |
| eval $command |
| } |
| } |
| } |
| |
| proc get_power_domains {} { |
| set power_domains [list] |
| dbForEachPowerDomain [dbgHead] pd { |
| if {[dbGroupHInstList [dbPowerDomainName $pd]] != "0x0"} { |
| lappend power_domains [dbPowerDomainName $pd] |
| } |
| } |
| return $power_domains |
| } |
| |
| proc route_secondary_pg_nets {} { |
| |
| Puts "<FF> ROUTING SECONDARY POWER NETS ..." |
| |
| global vars |
| |
| # Enable global pin pairs (if defined) |
| if {[info exists vars(secondary_pg,cell_pin_pairs)]} { |
| setPGPinUseSignalRoute $vars(secondary_pg,cell_pin_pairs) |
| |
| # Build commands for individual nets (if defined) |
| if {[info exists vars(secondary_pg,nets)]} { |
| foreach net $vars(secondary_pg,nets) { |
| # Set options to globals if they exist |
| if {[info exists vars($net,pattern)]} { |
| set pattern $vars($net,pattern) |
| } elseif {[info exists vars(secondary_pg,pattern)]} { |
| set pattern $vars(secondary_pg,pattern) |
| } |
| if {[info exists vars($net,max_fanout)]} { |
| set max_fanout $vars($net,max_fanout) |
| } elseif {[info exists vars(secondary_pg,max_fanout)]} { |
| set max_fanout $vars(secondary_pg,max_fanout) |
| } |
| if {[info exists vars($net,non_default_rule)]} { |
| set non_default_rule $vars($net,non_default_rule) |
| } elseif {[info exists vars(secondary_pg,non_default_rule)]} { |
| set non_default_rule $vars(secondary_pg,non_default_rule) |
| } |
| if {[info exists vars($net,cell_pin_pairs)]} { |
| setPGPinUseSignalRoute $vars($net,cell_pin_pairs) |
| } |
| set vars($net,command) "routePGPinUseSignalRoute -nets $net" |
| if {[info exists pattern]} { |
| set vars($net,command) [format "%s -pattern %s" $vars($net,command) $pattern] |
| } |
| if {[info exists max_fanout]} { |
| set vars($net,command) [format "%s -maxFanout %s" $vars($net,command) $max_fanout] |
| } |
| if {[info exists non_default_rule]} { |
| set vars($net,command) [format "%s -nonDefaultRule %s" $vars($net,command) $non_default_rule] |
| } |
| } |
| foreach net $vars(secondary_pg,nets) { |
| eval $vars($net,command) |
| } |
| } else { |
| set command "routePGPinUseSignalRoute" |
| # Set options to globals if they exist |
| if {[info exists vars(secondary_pg,pattern)]} { |
| set command [format "%s -pattern $vars(secondary_pg,pattern)" $command] |
| } |
| if {[info exists vars(secondary_pg,max_fanout)]} { |
| set command [format "%s -maxFanout $vars(secondary_pg,max_fanout)" $command] |
| } |
| if {[info exists vars(secondary_pg,non_default_rule)]} { |
| set command [format "%s -nonDefaultRule $vars(secondary_pg,non_default_rule)" $command] |
| } |
| eval $command |
| } |
| } else { |
| Puts "<FF> =====================================================================" |
| Puts "<FF> ERROR: No cell/pin pairs defined ... please define cell/pin pairs" |
| Puts "<FF> in your setup.tcl using vars(secondary_pg,cell_pin_pairs)" |
| Puts "<FF> =====================================================================" |
| } |
| } |
| |
| proc insert_welltaps_endcaps {} { |
| |
| global vars |
| |
| ############################################################################### |
| # Insert welltaps and pre/post endcaps |
| ############################################################################### |
| if {[info exists vars(cpf_file)] && ([info exists vars(power_domains)] && ([llength $vars(power_domains)] > 0))} { |
| set vars(power_domains) [::ff_procs::get_power_domains] |
| foreach domain $vars(power_domains) { |
| if {[info exists vars($domain,pre_endcap)] && |
| [info exists vars($domain,post_endcap)]} { |
| addEndCap -prefix $domain \ |
| -preCap $vars($domain,pre_endcap) \ |
| -postCap $vars($domain,post_endcap) \ |
| -powerDomain $domain |
| } elseif {[info exists vars(pre_endcap)] && |
| [info exists vars(post_endcap)]} { |
| addEndCap -prefix $domain \ |
| -preCap $vars(pre_endcap) \ |
| -postCap $vars(post_endcap) \ |
| -powerDomain $domain |
| } |
| if {[info exists vars($domain,welltaps)] || [info exists vars(welltaps)]} { |
| if {[info exists vars($domain,welltaps)]} { |
| set command "addWellTap -prefix $domain -cell $vars($domain,welltaps) -powerDomain $domain" |
| set vcommand "verifyWellTap -cells $vars($domain,welltaps) -powerDomain $domain -report $vars(rpt_dir)/welltap.rpt" |
| } elseif {[info exists vars(welltaps)]} { |
| set command "addWellTap -prefix $domain -cell $vars(welltaps) -powerDomain $domain" |
| set vcommand "verifyWellTap -cells $vars(welltaps) -powerDomain $domain -report $vars(rpt_dir)/welltap.rpt" |
| } |
| if {[info exists vars($domain,welltaps,max_gap)] || [info exists vars($domain,welltaps,cell_interval)]} { |
| if {[info exists vars($domain,welltaps,max_gap)]} { |
| append command " -maxGap $vars($domain,welltaps,max_gap)" |
| } else { |
| append command " -cellInterval $vars($domain,welltaps,cell_interval)" |
| } |
| } elseif {[info exists vars(welltaps,max_gap)] || [info exists vars(welltaps,cell_interval)]} { |
| if {[info exists vars(welltaps,max_gap)]} { |
| append command " -maxGap $vars(welltaps,max_gap)" |
| } else { |
| append command " -cellInterval $vars(welltaps,cell_interval)" |
| } |
| } |
| if {[info exists vars($domain,welltaps,row_offset)]} { |
| if {$vars($domain,welltaps,row_offset)} { |
| append command " -inRowOffset $vars($domain,welltaps,row_offset)" |
| } |
| } elseif {[info exists vars(welltaps,row_offset)]} { |
| if {$vars(welltaps,row_offset)} { |
| append command " -inRowOffset $vars(welltaps,row_offset)" |
| } |
| } |
| if {[info exists vars($domain,welltaps,checkerboard)]} { |
| if {$vars($domain,welltaps,checkerboard)} { |
| append command " -checkerboard" |
| } |
| } elseif {[info exists vars(welltaps,checkerboard)]} { |
| if {$vars(welltaps,checkerboard)} { |
| append command " -checkerboard" |
| } |
| } |
| eval $command |
| if {[info exists vars(welltaps,verify_rule)]} { |
| append vcommand " -rule $vars(welltaps,verify_rule)" |
| eval $vcommand |
| } else { |
| puts "<FF> Cannot run verifyWellTap because vars(welltaps,verify_rule) is not defined" |
| } |
| } |
| } |
| } else { |
| if {[info exists vars(pre_endcap)] && |
| [info exists vars(post_endcap)]} { |
| addEndCap -prefix ENDCAP \ |
| -preCap $vars(pre_endcap) \ |
| -postCap $vars(post_endcap) |
| } |
| if {[info exists vars(welltaps)]} { |
| set command "addWellTap -prefix WELLTAP -cell $vars(welltaps) " |
| set vcommand "verifyWellTap -cells $vars(welltaps) -report $vars(rpt_dir)/welltap.rpt" |
| if {[info exists vars(welltaps,max_gap)] || [info exists vars(welltaps,cell_interval)]} { |
| if {[info exists vars(welltaps,max_gap)]} { |
| append command " -maxGap $vars(welltaps,max_gap)" |
| } else { |
| append command " -cellInterval $vars(welltaps,cell_interval)" |
| } |
| } |
| if {[info exists vars(welltaps,row_offset)]} { |
| append command " -inRowOffset $vars(welltaps,row_offset)" |
| } |
| if {[info exists vars(welltaps,checkerboard)]} { |
| if {$vars(welltaps,checkerboard)} { |
| append command " -checkerboard" |
| } |
| } |
| eval $command |
| if {[info exists vars(welltaps,verify_rule)]} { |
| append vcommand " -rule $vars(welltaps,verify_rule)" |
| eval $vcommand |
| } else { |
| puts "<FF> CANNOT RUN verifyWellTap BECAUSE vars(welltaps,verify_rule) IS NOT DEFINED" |
| } |
| } |
| } |
| } |
| |
| proc buffer_always_on_nets {} { |
| |
| global vars |
| global errors |
| global bts_nets |
| |
| |
| if {![info exists vars(power_domains)]} { |
| set vars(power_domains) [::ff_procs::get_power_domains] |
| } |
| set pd_buffer_list [list] |
| foreach domain $vars(power_domains) { |
| if {[info exists vars($domain,always_on_buffers)]} { |
| set val [concat $domain $vars($domain,always_on_buffers)] |
| lappend pd_buffer_list $val |
| } else { |
| if {[info exists vars(always_on_buffers)]} { |
| set val [concat $domain $vars(always_on_buffers)] |
| lappend pd_buffer_list $val |
| } |
| } |
| } |
| if {$pd_buffer_list == ""} { |
| Puts "<FF> ERROR: No always-on buffers defined" |
| return |
| } |
| |
| if {[info exists vars(always_on_nets)]} { |
| set bts_nets [list] |
| foreach net $vars(always_on_nets) { |
| set temp [join [dbFindNetsByName $net]] |
| lappend bts_nets $temp |
| } |
| |
| # set temp [list] |
| # if {[info exists vars(always_on_nets,max_fanout)]} { |
| # set max_fanout $vars(always_on_nets,max_fanout) |
| # foreach net [join $bts_nets] { |
| # if {[expr [llength [dbFindInstsOnNet $net]] - 1] > $max_fanout} { |
| # lappend temp $net |
| # } |
| # } |
| # set bts_nets [join $temp] |
| # } |
| # |
| set bts_nets [join $bts_nets] |
| |
| Puts "<FF> =========================================================" |
| Puts "<FF> Buffering always-on nets" |
| Puts "<FF> =========================================================" |
| Puts "<FF> Nets ..." |
| foreach net $bts_nets { |
| Puts "<FF> $net" |
| } |
| |
| set command "bufferTreeSynthesis -prefix BTS" |
| append command " -nets \[list $bts_nets\]" |
| append command " -powerDomainBufList \[list $pd_buffer_list\]" |
| |
| if {![catch {set arg $vars(always_on_nets,max_tran)}]} { |
| append command " -maxTran $arg" |
| Puts "<FF> Max Tran -> $arg" |
| } |
| if {![catch {set arg $vars(always_on_nets,max_fanout)}]} { |
| append command " -maxFanout $arg" |
| Puts "<FF> Max Fanout -> $arg" |
| } |
| if {![catch {set arg $vars(always_on_nets,max_skew)}]} { |
| append command " -maxSkew $arg" |
| Puts "<FF> Max Skew -> $arg" |
| } |
| if {![catch {set arg $vars(always_on_nets,max_delay)}]} { |
| append command " -maxDelay $arg" |
| Puts "<FF> Max Delay -> $arg" |
| } |
| |
| Puts "<FF> =========================================================" |
| |
| eval $command |
| |
| } else { |
| |
| Puts "<FF> No always on nets specified" |
| Puts "<FF> Please set vars(always_on_nets) in your setup.tcl" |
| } |
| } |
| |
| proc get_icg_pins {} { |
| |
| global vars |
| Puts "<FF> INFO: Executing get_icg_pins" |
| foreach_in_collection pin [get_lib_pins $vars(icg,base_name)*/*] { |
| if {[get_property $pin direction]=="in"&&[get_property $pin is_clock_gating_enable]=="true"} { |
| set name [file tail [get_property $pin name]] |
| if {[info exists enable]==1&&$name!=$enable} { |
| Puts "<FF> ERROR: While searching all icgs, enable pin for [get_property $pin name] does not match existing $enable" |
| #exit 99 |
| } else { |
| set enable $name |
| } |
| } elseif {([get_property $pin direction] == "out")} { |
| set name [file tail [get_property $pin name]] |
| if {[info exists clkout]==1&&$name!=$clkout} { |
| Puts "<FF> ERROR: While searching all icgs, clkout pin for [get_property $pin name] does not match existing $clkout" |
| #exit 99 |
| } else { |
| set clkout $name |
| } |
| } elseif {([get_property $pin direction] == "in") && ([get_property $pin is_clock] == "true")} { |
| set name [file tail [get_property $pin name]] |
| if {[info exists clkin]==1&&$name!=$clkin} { |
| Puts "<FF> ERROR: While searching all icgs, clkin pin for [get_property $pin name] does not match existing $clkin" |
| #exit 99 |
| } else { |
| set clkin $name |
| } |
| } |
| } |
| if {[info exists clkout]==0} { |
| Puts "<FF> ERROR: output pin of icg $vars(icg,base_name) was not found, exiting" |
| #exit 99 |
| } |
| if {[info exists clkin]==0} { |
| Puts "<FF> ERROR: clk pin of icg $vars(icg,base_name) was not found, exiting" |
| #exit 99 |
| } |
| if {[info exists enable]==0} { |
| Puts "<FF> ERROR: enable pin of icg $vars(icg,base_name) was not found, exiting" |
| #exit 99 |
| } |
| set vars(icg,output_pin) $clkout |
| set vars(icg,input_pin) $enable |
| set vars(icg,clock_pin) $clkin |
| Puts "<FF> INFO: Finished executing get_icg_pins" |
| |
| } |
| |
| proc get_buf_pins {} { |
| |
| global vars |
| Puts "<FF> INFO: Executing get_buf_pins" |
| foreach_in_collection pin [get_lib_pins $vars(anchor_buffer)/*] { |
| if {[get_property $pin direction]=="in"} { |
| set in [file tail [get_property $pin name]] |
| } elseif {[get_property $pin direction] == "out"} { |
| set out [file tail [get_property $pin name]] |
| } |
| } |
| if {[info exists out]==0} { |
| Puts "<FF> ERROR: output pin of anchor buffer $vars(anchor_buffer) was not found, exiting" |
| #exit 99 |
| } |
| if {[info exists in]==0} { |
| Puts "<FF> ERROR: input pin of anchor buffer $vars(anchor_buffer) was not found, exiting" |
| #exit 99 |
| } |
| set vars(anchor_buffer,output_pin) $out |
| set vars(anchor_buffer,input_pin) $in |
| set vars(buf,output_pin) $out |
| set vars(buf,input_pin) $in |
| |
| Puts "<FF> INFO: Finished executing get_buf_pins" |
| |
| } |
| |
| proc get_reg_pins {} { |
| |
| global vars |
| Puts "<FF> INFO: Executing get_reg_pins" |
| set got_pin false |
| foreach_in_collection reg [all_registers] { |
| if {$got_pin} { |
| return |
| } |
| foreach_in_collection pin [get_pins [get_property $reg hierarchical_name]/*] { |
| if [get_property $pin is_clock] { |
| set vars(reg,clock_pin) [file tail [get_property $pin hierarchical_name]] |
| set got_pin true |
| } |
| } |
| } |
| Puts "<FF> INFO: Finished executing get_reg_pins" |
| } |
| |
| proc get_tech_pin_info {} { |
| |
| global vars |
| |
| get_icg_pins |
| get_buf_pins |
| get_reg_pins |
| |
| set op [open .ff.pins.tcl w] |
| foreach type {icg buf reg} { |
| foreach pin {clock enable input output} { |
| if {[info exists vars($type,${pin}_pin)]} { |
| puts $op "set vars($type,${pin}_pin) $vars($type,${pin}_pin)" |
| Puts "<FF> INFO: Found $type $pin -> $vars($type,${pin}_pin)" |
| } |
| } |
| } |
| close $op |
| } |
| |
| proc get_all_usable_bufinvs {} { |
| |
| # Puts "INFO: Executing get_all_usable_bufinvs" |
| set buf_list "" |
| set inv_list "" |
| set cell_types [dbGet head.allCells.name *] |
| foreach cell $cell_types { |
| set cell_id [ dbGetCellByName $cell] |
| if { [dbIsCellDontUse $cell_id] } { continue } |
| if { [dbIsCellDontTouch $cell_id] } { continue } |
| if { [dbIsCellSequential $cell_id] } { continue } |
| if { [::CPF::isAlwaysOnCell $cell] } { continue } |
| if { [ dbIsCellBuffer $cell_id] } { |
| lappend buf_list $cell |
| } elseif { [ dbIsCellInverter $cell_id ] } { |
| lappend inv_list $cell |
| } |
| } |
| # Puts "INFO: Found [llength $buf_list] buffers and [llength $inv_list] inverters" |
| # Puts "INFO: Finished executing get_all_usable_bufinvs" |
| return [list $buf_list $inv_list] |
| |
| } |
| proc assign_cts_cells {} { |
| |
| # Puts "INFO: Executing assign_cts_cells" |
| |
| global vars |
| if {![info exists vars(cts_cells)]} { |
| set rc [::ff_procs::get_all_usable_bufinvs] |
| set vars(cts_cells) [concat $rc] |
| } else { |
| set got_one 0 |
| foreach cell $vars(cts_cells) { |
| if {[dbGetCellByName $cell]!="0x0"} { |
| set got_one 1 |
| } |
| } |
| if {$got_one==0} { |
| Puts "<FF> WARNING: there is no valid cell in vars(cts_cells), will auto set to all usable buffers/inverters" |
| set rc [::ff_procs::get_all_usable_bufinvs] |
| set vars(cts_cells) [concat $rc] |
| } |
| } |
| set vars(cts_inverter_cells) [list] |
| set vars(cts_buffer_cells) [list] |
| foreach cell {$vars(cts_cells)} { |
| if { [dbIsCellBuffer $cell_id] } { |
| lappend vars(cts_buffer_cells) $cell |
| } elseif { [dbIsCellInverter $cell_id] } { |
| lappend vars(cts_inverter_cells) $cell |
| } |
| } |
| # Puts "INFO: Finished executing assign_cts_cells" |
| } |
| |
| proc enable_mmmc {} { |
| |
| Puts "<FF> INFO: Executing enable_mmmc" |
| global vars |
| # confirm default view defined |
| if {[info exists vars(default_setup_view)]==0} { |
| Puts "ERROR: default view vars(default_setup_view) not defined, exiting" |
| #exit 99 |
| } |
| set view $vars(default_setup_view) |
| if {[info exists vars($view,delay_corner)]==0} { |
| Puts "<FF> ERROR: default delay_corner vars($view,delay_corner) not defined, exiting" |
| #exit 99 |
| } |
| set dc $vars($view,delay_corner) |
| if {[info exists vars($dc,library_set)]==0} { |
| Puts "<FF> ERROR: default library_set vars($dc,library_set) not defined, exiting" |
| #exit 99 |
| } |
| set libset $vars($dc,library_set) |
| if {[info exists vars($dc,rc_corner)]==0} { |
| Puts "<FF> ERROR: default rc_corner vars($dc,rc_corner) not defined, exiting" |
| #exit 99 |
| } |
| set rc $vars($dc,rc_corner) |
| if {[info exists vars($view,constraint_mode)]==0} { |
| Puts "<FF> ERROR: default constraint_mode vars($view,constraint_mode) not defined, exiting" |
| #exit 99 |
| } |
| set mode $vars($view,constraint_mode) |
| if {[info exists vars($mode,pre_cts_sdc)]==0} { |
| Puts "<FF> ERROR: pre_cts_sdc for constraint_mode $mode in vars($mode,pre_cts_sdc), exiting" |
| #exit 99 |
| } |
| |
| if {[info exists vars($libset,timing)]==0} { |
| Puts "<FF> ERROR: library_set $libset libraries not defined in vars($libset,timing), exiting" |
| #exit 99 |
| } |
| create_library_set -name $libset -timing $vars($libset,timing) |
| |
| if {[info exists vars($rc,cap_table)]==0} { |
| Puts "<FF> ERROR: cap_table for rc_corner $rc not defined, exiting" |
| #exit 99 |
| } |
| if {[info exists vars($rc,pre_route_res_factor)]==0} { |
| Puts "<FF> WARNING: pre_route_res_factor for rc_corner $rc not defined, setting to 1.0" |
| set vars($rc,pre_route_res_factor) 1.0 |
| } |
| if {[info exists vars($rc,pre_route_cap_factor)]==0} { |
| Puts "<FF> WARNING: pre_route_cap_factor for rc_corner $rc not defined, setting to 1.0" |
| set vars($rc,pre_route_cap_factor) 1.0 |
| } |
| if {[info exists vars($rc,T)]==0} { |
| Puts "<FF> WARNING: temperature for rc_corner $rc not defined, setting to 25" |
| set vars($rc,pre_route_cap_factor) 25 |
| } |
| create_rc_corner -name $rc \ |
| -cap_table $vars($rc,cap_table) \ |
| -preRoute_res $vars($rc,pre_route_res_factor) \ |
| -preRoute_cap $vars($rc,pre_route_cap_factor) \ |
| -T $vars($rc,T) |
| |
| create_delay_corner -name $dc -library_set $libset -rc_corner $rc |
| if {[file isfile [lindex vars($mode,pre_cts_sdc) 0]]} { |
| if {[lsearch [all_constraint_modes] $mode] == -1} { |
| create_constraint_mode -name $mode -sdc_files $vars($mode,pre_cts_sdc) |
| } else { |
| update_constraint_mode -name $mode -sdc_files $vars($mode,pre_cts_sdc) |
| } |
| } |
| |
| create_analysis_view -name $view -constraint_mode $mode -delay_corner $dc |
| set_analysis_view -setup [list $view] -hold [list $view] |
| foreach object "cell net" { |
| foreach mode "early late" { |
| foreach type "data clock" { |
| if {[info exists vars($dc,${type}_${object}_${mode})]} { |
| set generated 1 |
| set_timing_derate -delay_corner $dc -$type -${object}_delay -$mode $vars($dc,${type}_${object}_${mode}) |
| } |
| if {[info exists vars($dc,${object}_${type}_${mode})]} { |
| set_timing_derate -delay_corner $dc -$type -${object}_delay -$mode $vars($dc,${object}_${type}_${mode}) |
| } |
| } |
| if {[info exists vars($dc,cell_check_${mode})]} { |
| set_timing_derate -delay_corner $dc -cell_check -$mode $vars($dc,cell_check_${mode}) |
| } |
| if {[info exists vars($dc,check_cell_${mode})]} { |
| set_timing_derate -delay_corner $dc -cell_check -$mode $vars($dc,check_cell_${mode}) |
| } |
| } |
| } |
| if {[info exists vars(derate_tcl)]&&[file isfile $vars(derate_tcl)]} { |
| source $vars(derate_tcl) |
| } |
| if {[info exists vars($dc,derate_tcl)]&&[file isfile $vars($dc,derate_tcl)]} { |
| source $vars($dc,derate_tcl) |
| } |
| Puts "<FF> INFO: Finished executing enable_mmmc" |
| |
| } |
| |
| proc build_guides {} { |
| |
| Puts "<FF> INFO: Creating floorplan guides ..." |
| global vars |
| unlogCommand addInstToInstGroup |
| unlogCommand createInstGroup |
| unlogCommand deleteInstGroup |
| unlogCommand setObjFPlanBoxList |
| suppressMessage ENCSYC-1962 |
| suppressMessage ENCSYC-791 |
| if {[info exists vars(guides)]==1&&[llength $vars(guides)]>0} { |
| foreach guide $vars(guides) { |
| # Check to make sure guide has a bound and some includes |
| if {[info exists vars(guide,$guide,bounds)]==0||[llength $vars(guide,$guide,bounds)]<4} { |
| Puts "<FF> WARNING: Guide $guide does not have a properly specified bound, guide not created" |
| } elseif {[info exists vars(guide,$guide,include)]==0||[llength $vars(guide,$guide,include)]<1} { |
| Puts "<FF> WARNING: Guide $guide does not have any includes, guide not created" |
| } else { |
| catch {deleteInstGroup $guide} |
| catch {unset insts} |
| if {[info exists vars(guide,$guide,exclude)]==0} { |
| set vars(guide,$guide,exclude) "" |
| } else { |
| regsub -all "\\\*" $vars(guide,$guide,exclude) "\.\*" excludes |
| } |
| foreach include $vars(guide,$guide,include) { |
| foreach i [dbFindInstsByName ${include}*] { |
| if {[info exists vars(guide,$guide,exclude)]==1&&[llength $vars(guide,$guide,exclude)]>0&&[regexp [join $excludes |] $i]<1} { |
| set insts($i) 1 |
| } elseif {[llength $vars(guide,$guide,exclude)]<1} { |
| set insts($i) 1 |
| } |
| } |
| } |
| if {[info exists insts]==1&&[llength [array names insts]]>0} { |
| set x1 [lindex $vars(guide,$guide,bounds) 0] |
| set y1 [lindex $vars(guide,$guide,bounds) 1] |
| set x2 [lindex $vars(guide,$guide,bounds) 2] |
| set y2 [lindex $vars(guide,$guide,bounds) 3] |
| createInstGroup $guide -guide $x1 $y1 $x2 $y2 |
| set c 0 |
| foreach i [array names insts] { |
| addInstToInstGroup $guide $i |
| incr c |
| } |
| set cmd "setObjFPlanBoxList Group $guide" |
| foreach i $vars(guide,$guide,bounds) { |
| set cmd "${cmd} $i" |
| } |
| catch {eval $cmd} |
| Puts "<FF> INFO: Added $c instances to guide $guide" |
| } else { |
| Puts "<FF> WARNING: Specified guide $guide has no instances, not creating" |
| } |
| } |
| } |
| } else { |
| Puts "<FF> INFO: No guides specified ... exiting" |
| } |
| logCommand addInstToInstGroup |
| logCommand createInstGroup |
| logCommand deleteInstGroup |
| logCommand setObjFPlanBoxList |
| Puts "<FF> INFO: Finished executing build_guides" |
| |
| } |
| |
| proc add_blockages {} { |
| |
| Puts "<FF>INFO: Creating blockages ..." |
| |
| global vars |
| |
| if {![info exists vars(blockages)]} { |
| puts "<FF>INFO: No blockages info defined ... existing" |
| return |
| } |
| set commands "" |
| foreach blockage $vars(blockages) { |
| switch $vars(blockage,$blockage,type) { |
| hard { |
| append commands "createObstruct $vars(blockage,$blockage,bounds) -name $blockage\n" |
| } |
| soft { |
| append commands "createObstruct $vars(blockage,$blockage,bounds) -name $blockage -type soft\n" |
| } |
| partial { |
| append commands "createObstruct $vars(blockage,$blockage,bounds) -name $blockage -type soft\n" |
| } |
| } |
| } |
| |
| eval $commands |
| |
| Puts "<FF>INFO: Finished executing add_blockages ..." |
| } |
| |
| proc save_results {{step ""}} { |
| |
| global vars |
| global errors |
| global env |
| |
| if {$step != ""} { |
| set vars(step) $step |
| } else { |
| Puts "<FF> Argument 'step' required ..." |
| return |
| } |
| |
| set commands "" |
| |
| set args "" |
| if {[info exists vars(save_rc)] && $vars(save_rc)} { |
| if {[regexp "route" $vars(step)]} { |
| append args " -rc" |
| } |
| } |
| if {[info exists vars(save_constraints)] && $vars(save_constraints)} { |
| append args " -tcon" |
| } |
| |
| # BCL: Added subst around vars(dbs_dir) to resolve vars(rundir) |
| set dir [subst $vars(dbs_dir)] |
| set design $vars(design) |
| if {[string compare -nocase $vars(dbs_format) "oa"]==0} { |
| if {[lindex [split $vars(version) "."] 0] > 10} { |
| if {$hier} { |
| set command "saveDesign $args -cellview {$vars(oa_partition_lib) $vars(design) $vars(step)}\n" |
| } else { |
| set command "saveDesign $args -cellview {$vars(oa_design_lib) $vars(design) $vars(step)}\n" |
| } |
| } else { |
| set command "saveOaDesign $vars(oa_design_lib) $design $vars(step)\n" |
| } |
| } else { |
| if {[info exists vars(relative_path)] && $vars(relative_path)} { |
| append args " -relativePath" |
| } |
| if {[info exists vars(absolute_lib_path)] && $vars(absolute_lib_path)} { |
| append args " -absoluteLibPath" |
| } |
| set command "saveDesign $args $dir/$vars(step).enc -compress\n" |
| } |
| |
| append commands $command |
| |
| if {![info exists env(VPATH)]} { |
| set env(VPATH) "make" |
| } |
| |
| if {$vars(makefile)} { |
| append commands "exec /bin/touch $env(VPATH)/$step\n" |
| } |
| |
| set header "#---------------------------------------------------------------------\n" |
| append header "# <FF> GENERATING REPORTS\n" |
| append header "#---------------------------------------------------------------------\n" |
| |
| if {$vars(report_power)} { |
| set command "report_power -outfile $vars(rpt_dir)/$vars(step).power.rpt\n" |
| append commands $command |
| } |
| |
| if {[info exists vars(cpf_file)] && ([info exists vars(power_domains)] && ([llength $vars(power_domains)] > 0))} { |
| append commands $header |
| set header "" |
| |
| ###################################################################### |
| # Verify power domain |
| ###################################################################### |
| |
| set command "verifyPowerDomain -bind -gconn" |
| append command " -isoNetPD $vars(rpt_dir)/$vars(step).isonets.rpt" |
| append command " -xNetPD $vars(rpt_dir)/$vars(step).xnets.rpt\n" |
| |
| append commands $command |
| |
| ###################################################################### |
| # Run CLP |
| ###################################################################### |
| |
| if {$vars(run_clp) && ([auto_execok lec] != "")} { |
| set command "runCLP " |
| if {[info exists vars(clp_options)]} { |
| append command $vars(clp_options) |
| } |
| append command "\n" |
| append commands $command |
| } else { |
| if {![info exists vars(clp_warning)]} { |
| puts "<FF> WARNING: UNABLE TO RUN CLP ... PLEASE MAKE SURE IT IS IN YOUR PATH" |
| set vars(clp_warning) true |
| } |
| } |
| } |
| |
| # append commands "#\n" |
| # append commands "# HOUSEKEEPING\n" |
| # append commands "#\n" |
| |
| if {[info exists vars(mail,to)]} { |
| if {![info exists vars(mail,steps)] || \ |
| ([info exists vars(mail,steps)] && ([lsearch $vars(mail,steps) $vars(step)] != -1))} { |
| append commands "Puts \"<FF> MAILING RESULTS TO $vars(mail,to)\"\n" |
| append commands "if {\[file exists $vars(rpt_dir)/$vars(step).summary\]} {\n" |
| append commands " exec /bin/mail -s \"FF: $vars(design), $vars(step) completed (\[pwd\])\" < $vars(rpt_dir)/$vars(step).summary $vars(mail,to)\n" |
| append commands "} else {\n" |
| append commands " exec /bin/mail -s \"FF: $vars(design), $vars(step) completed (\[pwd\])\" < /dev/null $vars(mail,to)\n" |
| append commands "}\n" |
| } |
| } |
| |
| # append commands "exec /bin/touch \$env(VPATH)/$vars(step)\n" |
| |
| append commands [::FF::source_plug final_always_source_tcl] |
| |
| if {$vars(makefile)} { |
| append commands "if {\[info exists env(VPATH)\]} {\n" |
| append commands "exec /bin/touch \$env(VPATH)/$vars(step)\n" |
| append commands "}\n" |
| } |
| |
| uplevel #0 eval $commands |
| } |
| |
| proc load_applet {args} { |
| |
| set defAppletNS "::applet" |
| set defSeverity "error" |
| set defaultLocalInstall $::ns(applet)::localInstall |
| set defaultLocalServer $::ns(applet)::localServer |
| set reqAppletVersion "" |
| |
| switch -- [parse_options [calling_proc] {} $args \ |
| "-version sos required version of applet (equal or greater)" reqAppletVersion \ |
| "-severity sos severity (error|warning|info)" severity \ |
| "-namespace sos namespace to search for applet" appletNS \ |
| "srs name of applet" appletName] { |
| -2 { return } |
| 0 { return -code error } |
| } |
| |
| if {$appletNS eq ""} { |
| set appletNS $defAppletNS |
| } |
| |
| if {$severity eq ""} { |
| set severity $defSeverity |
| } |
| |
| # Check to see if the applet happened to already be loaded. If so, check |
| # whether there is a minimum version requirement met. If yes, skip the rest of the applet |
| # If the applet already does not meet the minimum version requirement, unload it (using package forget) |
| if {![catch {set providedVersion [package present ${appletNS}::$appletName]} errorMessage]} { |
| if {$reqAppletVersion ne ""} { |
| if {[package vcompare $providedVersion $reqAppletVersion] == -1} { |
| puts "load_applet INFO: applet $appletName was already loaded, but it's version ($providedVersion) did not meet the minimum required version ($reqAppletVersion)" |
| puts "load_applet INFO: This version of the $appletName applet will be removed and the load_applet will search for a newer version of $appletName..." |
| package forget ${appletNS}::$appletName |
| } else { |
| puts "load_applet INFO: Found $appletName already loaded and it's version ($providedVersion) already meets the minimum required version ($reqAppletVersion). Skipping load..." |
| return |
| } |
| } else { |
| puts "load_applet INFO: Found $appletName already loaded with version ($providedVersion). Skipping applet load..." |
| return |
| } |
| } |
| |
| # There is no previously loaded applet. Continue with this proc... |
| set FoundMinVersionPath 0 |
| set finalSearchPath "" |
| set failedPaths "" |
| # Because Innovus has it's own get_attribute command now, we need to set this depending on what tool we are in |
| if {[get_tool] eq "rc"} { |
| set searchPathList [get_attribute applet_search_path /] |
| } else { |
| set searchPathList [$::ns(compat)::get_attribute applet_search_path /] |
| } |
| set appletSearchPathCount [llength $searchPathList] |
| |
| set origappletSearchPathCount $appletSearchPathCount |
| set origSearchPath "" |
| # First pass: determine which applet installations meet min required version, if any |
| # This for loop does not load the applets, it only determines a final search path to use |
| # If none of the search paths contain the minimum version, and severity code is error, this proc |
| # will return inside this foreach loop with code error |
| if {$appletSearchPathCount > 1} { |
| puts "load_applet INFO: Checking all applet search paths for versions of $appletName" |
| } |
| foreach pathComponent $searchPathList { |
| incr appletSearchPathCount -1 |
| if {$origappletSearchPathCount > 1} { |
| puts -nonewline " $pathComponent ..." |
| } else { |
| puts -nonewline "load_applet INFO: Checking applet_search_path: $pathComponent ..." |
| } |
| # If the path component is <default> replace with the applet designated search path value using "UpdateSeachPath" |
| if {[string match "<default>" $pathComponent]} { |
| set pathComponent [$::ns(applet)::UpdateSearchPath $pathComponent] |
| } |
| lappend origSearchPath $pathComponent |
| if {[file isdirectory $pathComponent]} { |
| if {[file isfile $pathComponent/.servInfo]} { |
| if {[get_tool] eq "rc"} { |
| set sourceCommand tcl_source |
| } else { |
| set sourceCommand source |
| } |
| set errorMsg "" |
| if {[catch {$sourceCommand $pathComponent/.servInfo} errorMsg] || ![info exists appInfo(${appletNS}::${appletName},version)]} { |
| if {$errorMsg ne ""} { |
| puts " $errorMsg" |
| } else { |
| puts " BAD APPLET SERVER (corrupted .servInfo file)" |
| } |
| } else { |
| if {$reqAppletVersion eq "" } { |
| lappend minVersionSearchPath $pathComponent |
| set FoundMinVersionPath 1 |
| } elseif {[package vcompare $appInfo(${appletNS}::${appletName},version) $reqAppletVersion] != -1} { |
| lappend minVersionSearchPath $pathComponent |
| set FoundMinVersionPath 1 |
| } else { |
| lappend failedPaths $pathComponent |
| set failedPathver($pathComponent) $appInfo(${appletNS}::${appletName},version) |
| } |
| puts " Found $appInfo(${appletNS}::${appletName},version)" |
| } |
| } else { |
| puts " BAD APPLET INSTALL" |
| } |
| } else { |
| puts " NONEXISTENT APPLET SERVER" |
| } |
| };# end first foreach loop (distilling final minimum version applet_search_path |
| |
| # Second pass: attempt to load applet in each valid search_path until a successful applet load occurs |
| # This for loop must lead to a successful outcome (loaded applet) or an error will be issued |
| if {$FoundMinVersionPath} { |
| foreach searchPath $minVersionSearchPath { |
| set_attribute -quiet applet_search_path $searchPath / |
| if {[catch {applet load $appletName} errorMsg]} { |
| puts "load_applet INFO: Version check passed on applet install $appletName but applet load failed." |
| if {$appletSearchPathCount > 0} { |
| puts "load_applet: Trying next applet_search_path..." |
| } else { |
| puts "load_applet: ERROR: Failed to load applet $appletName. Please check your applet_search_path and applet installation(s)." |
| set_attribute -quiet applet_search_path $origSearchPath / |
| return -code error |
| } |
| } else { |
| if {[catch {set providedVersion [package present ${appletNS}::$appletName]} errorMessage]} { |
| puts "load_applet: ERROR: applet $appletName loaded correctly, but the applet did not correctly provide a package version. Trying next search path..." |
| } else { |
| puts "load_applet: INFO: Applet $appletName $providedVersion successfully loaded from applet installation at $pathComponent, meeting min version requirement ($reqAppletVersion)" |
| set_attribute -quiet applet_search_path $origSearchPath / |
| return |
| } |
| } |
| } |
| } else { |
| # Didn't find any searchy paths with minimum applet installed. |
| switch -exact -- $severity { |
| error { |
| puts "load_applet ERROR: Minimum applet version for applet $appletName is $reqAppletVersion, but no applet was found meeting this requirement." |
| } |
| warning { |
| puts "load_applet WARNING: Minimum applet version for applet $appletName is $reqAppletVersion, but no applet was found meeting this requirement." |
| } |
| info { |
| puts "load_applet INFO: Minimum applet version for applet $appletName is $reqAppletVersion, but no applet was found meeting this requirement." |
| } |
| } |
| puts "load_applet INFO: Search results:" |
| foreach searchPath $failedPaths { |
| puts " applet_search_path: $searchPath, $appletName version found: $failedPathver($searchPath)" |
| } |
| puts "load_applet INFO: Note applet search path that was set:" |
| puts " $origSearchPath" |
| switch -exact -- $severity { |
| error { |
| set_attribute -quiet applet_search_path $origSearchPath / |
| return -code 99 |
| } |
| } |
| } |
| set_attribute -quiet applet_search_path $origSearchPath / |
| } |
| |
| } |
