blob: ccfa7299ff6cf266a8e77a9685c53aff132dbade [file] [log] [blame]
#!/usr/bin/tclsh
# SPDX-FileCopyrightText: 2020 Efabless Corporation
# Copyright 2020 Efabless Corporation
# Copyright 2020 Sylvain Munaut
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# SPDX-License-Identifier: Apache-2.0
package require openlane;
proc run_placement_step {args} {
if { ! [ info exists ::env(PLACEMENT_CURRENT_DEF) ] } {
set ::env(PLACEMENT_CURRENT_DEF) $::env(CURRENT_DEF)
} else {
set ::env(CURRENT_DEF) $::env(PLACEMENT_CURRENT_DEF)
}
run_placement
}
proc run_cts_step {args} {
if { ! [ info exists ::env(CTS_CURRENT_DEF) ] } {
set ::env(CTS_CURRENT_DEF) $::env(CURRENT_DEF)
} else {
set ::env(CURRENT_DEF) $::env(CTS_CURRENT_DEF)
}
run_cts
run_resizer_timing
}
proc run_routing_step {args} {
if { ! [ info exists ::env(ROUTING_CURRENT_DEF) ] } {
set ::env(ROUTING_CURRENT_DEF) $::env(CURRENT_DEF)
} else {
set ::env(CURRENT_DEF) $::env(ROUTING_CURRENT_DEF)
}
run_routing
}
proc run_diode_insertion_2_5_step {args} {
if { ! [ info exists ::env(DIODE_INSERTION_CURRENT_DEF) ] } {
set ::env(DIODE_INSERTION_CURRENT_DEF) $::env(CURRENT_DEF)
} else {
set ::env(CURRENT_DEF) $::env(DIODE_INSERTION_CURRENT_DEF)
}
if { ($::env(DIODE_INSERTION_STRATEGY) == 2) || ($::env(DIODE_INSERTION_STRATEGY) == 5) } {
run_antenna_check
heal_antenna_violators; # modifies the routed DEF
}
}
proc run_lvs_step {{ lvs_enabled 1 }} {
if { ! [ info exists ::env(LVS_CURRENT_DEF) ] } {
set ::env(LVS_CURRENT_DEF) $::env(CURRENT_DEF)
} else {
set ::env(CURRENT_DEF) $::env(LVS_CURRENT_DEF)
}
if { $lvs_enabled } {
run_magic_spice_export
run_lvs; # requires run_magic_spice_export
}
}
proc run_drc_step {{ drc_enabled 1 }} {
if { ! [ info exists ::env(DRC_CURRENT_DEF) ] } {
set ::env(DRC_CURRENT_DEF) $::env(CURRENT_DEF)
} else {
set ::env(CURRENT_DEF) $::env(DRC_CURRENT_DEF)
}
if { $drc_enabled } {
run_magic_drc
run_klayout_drc
}
}
proc run_antenna_check_step {{ antenna_check_enabled 1 }} {
if { ! [ info exists ::env(ANTENNA_CHECK_CURRENT_DEF) ] } {
set ::env(ANTENNA_CHECK_CURRENT_DEF) $::env(CURRENT_DEF)
} else {
set ::env(CURRENT_DEF) $::env(ANTENNA_CHECK_CURRENT_DEF)
}
if { $antenna_check_enabled } {
run_antenna_check
}
}
proc run_eco_step {args} {
if { $::env(ECO_ENABLE) == 1 } {
run_eco
}
}
proc save_final_views {args} {
set options {
{-save_path optional}
}
set flags {}
parse_key_args "save_final_views" args arg_values $options flags_map $flags
set arg_list [list]
# If they don't exist, save_views will simply not copy them
lappend arg_list -lef_path $::env(finishing_results)/$::env(DESIGN_NAME).lef
lappend arg_list -gds_path $::env(finishing_results)/$::env(DESIGN_NAME).gds
lappend arg_list -mag_path $::env(finishing_results)/$::env(DESIGN_NAME).mag
lappend arg_list -maglef_path $::env(finishing_results)/$::env(DESIGN_NAME).lef.mag
lappend arg_list -spice_path $::env(finishing_results)/$::env(DESIGN_NAME).spice
# Guaranteed to have default values
lappend arg_list -def_path $::env(CURRENT_DEF)
lappend arg_list -verilog_path $::env(CURRENT_NETLIST)
# Not guaranteed to have default values
if { [info exists ::env(SPEF_TYPICAL)] } {
lappend arg_list -spef_path $::env(SPEF_TYPICAL)
}
if { [info exists ::env(CURRENT_SDF)] } {
lappend arg_list -sdf_path $::env(CURRENT_SDF)
}
if { [info exists ::env(CURRENT_SDC)] } {
lappend arg_list -sdc_path $::env(CURRENT_SDC)
}
# Add the path if it exists...
if { [info exists arg_values(-save_path) ] } {
lappend arg_list -save_path $arg_values(-save_path)
}
# Aaand fire!
save_views {*}$arg_list
}
proc run_post_run_hooks {} {
if { [file exists $::env(DESIGN_DIR)/hooks/post_run.py]} {
puts_info "Running post run hook"
set result [exec $::env(OPENROAD_BIN) -python $::env(DESIGN_DIR)/hooks/post_run.py]
puts_info "$result"
} else {
puts_info "hooks/post_run.py not found, skipping"
}
}
proc gen_pdn {args} {
puts_info "Generating PDN..."
TIMER::timer_start
set ::env(SAVE_DEF) [index_file $::env(floorplan_tmpfiles).def]
set ::env(PGA_RPT_FILE) [index_file $::env(floorplan_tmpfiles).pga.rpt]
run_openroad_script $::env(SCRIPTS_DIR)/openroad/pdn.tcl \
|& -indexed_log [index_file $::env(floorplan_logs)/pdn.log]
TIMER::timer_stop
exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "pdn generation - openroad"
quit_on_unconnected_pdn_nodes
set_def $::env(SAVE_DEF)
}
proc run_power_grid_generation {args} {
if {[info exists ::env(FP_PDN_POWER_STRAPS)]} {
set power_domains [split $::env(FP_PDN_POWER_STRAPS) ","]
}
# internal macros power connections
if {[info exists ::env(FP_PDN_MACRO_HOOKS)]} {
set macro_hooks [dict create]
set pdn_hooks [split $::env(FP_PDN_MACRO_HOOKS) ","]
foreach pdn_hook $pdn_hooks {
set instance_name [lindex $pdn_hook 0]
set power_net [lindex $pdn_hook 1]
set ground_net [lindex $pdn_hook 2]
dict append macro_hooks $instance_name [subst {$power_net $ground_net}]
}
set power_net_indx [lsearch $::env(VDD_NETS) $power_net]
set ground_net_indx [lsearch $::env(GND_NETS) $ground_net]
# make sure that the specified power domains exist.
if { $power_net_indx == -1 || $ground_net_indx == -1 || $power_net_indx != $ground_net_indx } {
puts_err "Can't find $power_net and $ground_net domain. \
Make sure that both exist in $::env(VDD_NETS) and $::env(GND_NETS)."
}
}
# generate multiple power grids per pair of (VDD,GND)
# offseted by WIDTH + SPACING
foreach domain $power_domains {
set ::env(VDD_NET) [lindex $domain 0]
set ::env(GND_NET) [lindex $domain 1]
set ::env(_WITH_STRAPS) [lindex $domain 2]
puts_info "Connecting Power: $::env(VDD_NET) & $::env(GND_NET) to All internal macros."
# internal macros power connections
set ::env(FP_PDN_MACROS) ""
if { $::env(FP_PDN_ENABLE_MACROS_GRID) == 1 } {
# if macros connections to power are explicitly set
# default behavoir macro pins will be connected to the first power domain
if { [info exists ::env(FP_PDN_MACRO_HOOKS)] } {
set ::env(FP_PDN_ENABLE_MACROS_GRID) 0
foreach {instance_name hooks} $macro_hooks {
set power [lindex $hooks 0]
set ground [lindex $hooks 1]
if { $power == $::env(VDD_NET) && $ground == $::env(GND_NET) } {
set ::env(FP_PDN_ENABLE_MACROS_GRID) 1
set ::env(FP_PDN_IRDROP) "0"
puts_info "Connecting $instance_name to $power and $ground nets."
lappend ::env(FP_PDN_MACROS) $instance_name
}
}
}
} else {
puts_warn "All internal macros will not be connected to power $::env(VDD_NET) & $::env(GND_NET)."
}
gen_pdn
set ::env(FP_PDN_ENABLE_RAILS) 0
set ::env(FP_PDN_ENABLE_MACROS_GRID) 0
set ::env(FP_PDN_IRDROP) "0"
# allow failure until open_pdks is up to date...
catch {set ::env(FP_PDN_VOFFSET) [expr $::env(FP_PDN_VOFFSET)+$::env(FP_PDN_VWIDTH)+$::env(FP_PDN_VSPACING)]}
catch {set ::env(FP_PDN_HOFFSET) [expr $::env(FP_PDN_HOFFSET)+$::env(FP_PDN_HWIDTH)+$::env(FP_PDN_HSPACING)]}
catch {set ::env(FP_PDN_CORE_RING_VOFFSET) \
[expr $::env(FP_PDN_CORE_RING_VOFFSET)\
+2*($::env(FP_PDN_CORE_RING_VWIDTH)\
+max($::env(FP_PDN_CORE_RING_VSPACING), $::env(FP_PDN_CORE_RING_HSPACING)))]}
catch {set ::env(FP_PDN_CORE_RING_HOFFSET) [expr $::env(FP_PDN_CORE_RING_HOFFSET)\
+2*($::env(FP_PDN_CORE_RING_HWIDTH)+\
max($::env(FP_PDN_CORE_RING_VSPACING), $::env(FP_PDN_CORE_RING_HSPACING)))]}
puts "FP_PDN_VOFFSET: $::env(FP_PDN_VOFFSET)"
puts "FP_PDN_HOFFSET: $::env(FP_PDN_HOFFSET)"
puts "FP_PDN_CORE_RING_VOFFSET: $::env(FP_PDN_CORE_RING_VOFFSET)"
puts "FP_PDN_CORE_RING_HOFFSET: $::env(FP_PDN_CORE_RING_HOFFSET)"
}
set ::env(FP_PDN_ENABLE_RAILS) 1
}
proc run_floorplan {args} {
puts_info "Running Floorplanning..."
# |----------------------------------------------------|
# |---------------- 2. FLOORPLAN ------------------|
# |----------------------------------------------------|
#
# intial fp
init_floorplan
# check for deprecated io variables
if { [info exists ::env(FP_IO_HMETAL)]} {
set ::env(FP_IO_HLAYER) [lindex $::env(TECH_METAL_LAYERS) [expr {$::env(FP_IO_HMETAL) - 1}]]
puts_warn "You're using FP_IO_HMETAL in your configuration, which is a deprecated variable that will be removed in the future."
puts_warn "We recommend you update your configuration as follows:"
puts_warn "\tset ::env(FP_IO_HLAYER) {$::env(FP_IO_HLAYER)}"
}
if { [info exists ::env(FP_IO_VMETAL)]} {
set ::env(FP_IO_VLAYER) [lindex $::env(TECH_METAL_LAYERS) [expr {$::env(FP_IO_VMETAL) - 1}]]
puts_warn "You're using FP_IO_VMETAL in your configuration, which is a deprecated variable that will be removed in the future."
puts_warn "We recommend you update your configuration as follows:"
puts_warn "\tset ::env(FP_IO_VLAYER) {$::env(FP_IO_VLAYER)}"
}
# place io
if { [info exists ::env(FP_PIN_ORDER_CFG)] } {
place_io_ol
} else {
if { [info exists ::env(FP_CONTEXT_DEF)] && [info exists ::env(FP_CONTEXT_LEF)] } {
place_io
global_placement_or
place_contextualized_io \
-lef $::env(FP_CONTEXT_LEF) \
-def $::env(FP_CONTEXT_DEF)
} else {
place_io
}
}
apply_def_template
if { [info exist ::env(EXTRA_LEFS)] } {
if { [info exist ::env(MACRO_PLACEMENT_CFG)] } {
file copy -force $::env(MACRO_PLACEMENT_CFG) $::env(placement_tmpfiles)/macro_placement.cfg
manual_macro_placement f
} else {
global_placement_or
basic_macro_placement
}
}
tap_decap_or
scrot_klayout -layout $::env(CURRENT_DEF) $::env(floorplan_logs)/screenshot.log
run_power_grid_generation
}
proc run_flow {args} {
set options {
{-design required}
{-from optional}
{-to optional}
{-save_path optional}
{-override_env optional}
}
set flags {-save -run_hooks -no_lvs -no_drc -no_antennacheck }
parse_key_args "run_non_interactive_mode" args arg_values $options flags_map $flags -no_consume
prep {*}$args
# signal trap SIGINT save_state;
if { [info exists arg_values(-override_env)] } {
set env_overrides [split $arg_values(-override_env) ',']
foreach override $env_overrides {
set kva [split $override '=']
set key [lindex $kva 0]
set value [lindex $kva 1]
set ::env(${key}) $value
}
}
set LVS_ENABLED 1
set DRC_ENABLED 0
set ANTENNACHECK_ENABLED 1
set steps [dict create \
"synthesis" {run_synthesis "" } \
"floorplan" {run_floorplan ""} \
"placement" {run_placement_step ""} \
"cts" {run_cts_step ""} \
"routing" {run_routing_step ""}\
"eco" {run_eco_step ""} \
"diode_insertion" {run_diode_insertion_2_5_step ""} \
"gds_magic" {run_magic ""} \
"gds_drc_klayout" {run_klayout ""} \
"gds_xor_klayout" {run_klayout_gds_xor ""} \
"lvs" "run_lvs_step $LVS_ENABLED" \
"drc" "run_drc_step $DRC_ENABLED" \
"antenna_check" "run_antenna_check_step $ANTENNACHECK_ENABLED" \
"cvc" {run_lef_cvc}
]
set_if_unset arg_values(-to) "cvc";
if { [info exists ::env(CURRENT_STEP) ] } {
puts "\[INFO\]:Picking up where last execution left off"
puts [format "\[INFO\]:Current stage is %s " $::env(CURRENT_STEP)]
} else {
set ::env(CURRENT_STEP) "synthesis";
}
set_if_unset arg_values(-from) $::env(CURRENT_STEP);
set exe 0;
dict for {step_name step_exe} $steps {
if { [ string equal $arg_values(-from) $step_name ] } {
set exe 1;
}
if { $exe } {
# For when it fails
set ::env(CURRENT_STEP) $step_name
[lindex $step_exe 0] [lindex $step_exe 1] ;
}
if { [ string equal $arg_values(-to) $step_name ] } {
set exe 0:
break;
}
}
# for when it resumes
set steps_as_list [dict keys $steps]
set next_idx [expr [lsearch $steps_as_list $::env(CURRENT_STEP)] + 1]
set ::env(CURRENT_STEP) [lindex $steps_as_list $next_idx]
# Saves to <RUN_DIR>/results/final
if { $::env(SAVE_FINAL_VIEWS) == "1" } {
save_final_views
}
# Saves to design directory or custom
if { [info exists flags_map(-save) ] } {
if { ! [info exists arg_values(-save_path)] } {
set arg_values(-save_path) $::env(DESIGN_DIR)
}
save_final_views\
-save_path $arg_values(-save_path)\
-tag $::env(RUN_TAG)
}
calc_total_runtime
save_state
generate_final_summary_report
check_timing_violations
if { [info exists arg_values(-save_path)]\
&& $arg_values(-save_path) != "" } {
set ::env(HOOK_OUTPUT_PATH) "[file normalize $arg_values(-save_path)]"
} else {
set ::env(HOOK_OUTPUT_PATH) $::env(RESULTS_DIR)/final
}
if {[info exists flags_map(-run_hooks)]} {
run_post_run_hooks
}
puts_success "Flow complete."
show_warnings "Note that the following warnings have been generated:"
}
run_flow {*}$argv