openlane/user_project_wrapper/interactive.tcl - third_party/shuttle/sky130/mpw-007/slot-008 - Git at Google

 #!/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 1
     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
	#!/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 1
	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