siliconcompiler 0.27.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

siliconcompiler/schema/schema_obj.py

@@ -608,7 +608,7 @@ class Schema:
 
         See :meth:`~siliconcompiler.core.Chip.getkeys` for detailed documentation.
         """
-        cfg = self.__search(*keypath, job=job)
+        cfg = self.__search(*keypath, job=job, use_default=False)
         keys = list(cfg.keys())
 
         if 'default' in keys:
@@ -946,7 +946,7 @@ class Schema:
 
         return None
 
-    def __search(self, *keypath, insert_defaults=False, job=None):
+    def __search(self, *keypath, insert_defaults=False, use_default=True, job=None):
         if job is not None:
             cfg = self.cfg['history'][job]
         else:
@@ -965,8 +965,10 @@ class Schema:
                 if insert_defaults:
                     cfg[key] = copy.deepcopy(cfg['default'])
                     cfg = cfg[key]
-                else:
+                elif use_default:
                     cfg = cfg['default']
+                else:
+                    raise ValueError(f'Invalid keypath {keypath}: unexpected key: {key}')
             else:
                 raise ValueError(f'Invalid keypath {keypath}: unexpected key: {key}')
 

siliconcompiler/sphinx_ext/dynamicgen.py

@@ -197,7 +197,7 @@ class DynamicGen(SphinxDirective):
             chips = self.configure_chip_for_docs(module)
         except Exception as e:
             print("Failed:", e)
-            return None
+            # raise e
 
         if not chips:
             return None
@@ -274,7 +274,7 @@ class DynamicGen(SphinxDirective):
         directory.'''
         modules = []
         for importer, modname, _ in pkgutil.iter_modules([module_dir]):
-            module = importer.find_module(modname).load_module(modname)
+            module = importer.find_spec(modname).loader.load_module(modname)
             modules.append((module, modname))
 
         return modules
@@ -399,7 +399,7 @@ class DynamicGen(SphinxDirective):
         if docs_chip and docs_configured:
             return docs_chip
 
-        return self._handle_setup(module)
+        return self._handle_setup(chip, module)
 
     def get_ref_prefix(self):
         return self.REF_PREFIX
@@ -635,7 +635,7 @@ class ToolGen(DynamicGen):
         if toolmodule:
             return chip
         else:
-            return self._handle_setup(module)
+            return self._handle_setup(chip, module)
 
     def display_config(self, chip, modname):
         '''Display config under `eda, <modname>` in a single table.'''
@@ -726,7 +726,7 @@ class ToolGen(DynamicGen):
             s += p
 
         try:
-            task_setup()
+            task_setup(chip)
 
             config = build_section("Configuration", self.get_configuration_ref_key(toolname,
                                                                                    taskname))
@@ -738,8 +738,7 @@ class ToolGen(DynamicGen):
                                       [toolname, taskname, 'params'],
                                       s)
         except Exception as e:
-            print('Failed to document task, Chip object probably not configured correctly.')
-            print(e)
+            print(f'Failed to document task, Chip object probably not configured correctly: {e}')
             return None
 
         return s
@@ -791,6 +790,15 @@ class ToolGen(DynamicGen):
         self._document_free_params(cfg, 'var', key_path + ['var'], reference_prefix, s)
         self._document_free_params(cfg, 'file', key_path + ['file'], reference_prefix, s)
 
+    def _handle_setup(self, chip, module):
+        setup = self.get_setup_method(module)
+        if not setup:
+            return None
+
+        setup(chip)
+
+        return chip
+
 
 class TargetGen(DynamicGen):
     PATH = 'targets'
@@ -816,20 +824,23 @@ class TargetGen(DynamicGen):
     def display_config(self, chip, modname):
         sections = []
 
-        flow_section = self.build_module_list(chip, 'Flows', 'flows', modname, FlowGen.REF_PREFIX)
-        if flow_section is not None:
-            sections.append(flow_section)
-
-        pdk_section = self.build_module_list(chip, 'PDK', 'pdks', modname, PDKGen.REF_PREFIX)
+        pdk_section = self.build_module_list(
+            chip, 'Included PDK', 'pdks', modname, PDKGen.REF_PREFIX)
         if pdk_section is not None:
             sections.append(pdk_section)
 
-        libs_section = self.build_module_list(chip, 'Libraries', 'libs', modname, LibGen.REF_PREFIX)
+        libs_section = self.build_module_list(
+            chip, 'Included libraries', 'libs', modname, LibGen.REF_PREFIX)
         if libs_section is not None:
             sections.append(libs_section)
 
-        checklist_section = self.build_module_list(chip, 'Checklists', 'checklists', modname,
-                                                   ChecklistGen.REF_PREFIX)
+        flow_section = self.build_module_list(
+            chip, 'Included flows', 'flows', modname, FlowGen.REF_PREFIX)
+        if flow_section is not None:
+            sections.append(flow_section)
+
+        checklist_section = self.build_module_list(
+            chip, 'Included checklists', 'checklists', modname, ChecklistGen.REF_PREFIX)
         if checklist_section is not None:
             sections.append(checklist_section)
 
@@ -847,6 +858,15 @@ class TargetGen(DynamicGen):
 
         return sections
 
+    def _handle_setup(self, chip, module):
+        setup = self.get_setup_method(module)
+        if not setup:
+            return None
+
+        setup(chip)
+
+        return chip
+
 
 class AppGen(DynamicGen):
     PATH = 'apps'

siliconcompiler/sphinx_ext/schemagen.py

@@ -77,7 +77,9 @@ class SchemaGen(SphinxDirective):
                 if key == 'default':
                     for n in self.process_schema(schema['default'], parents=parents):
                         sections.append(n)
-                elif key not in ('history', 'library'):
+                else:
+                    if not parents and key in ('history', 'library'):
+                        continue
                     section_key = 'param-' + '-'.join(parents + [key])
                     section = build_section_with_target(key, section_key, self.state.document)
                     for n in self.process_schema(schema[key], parents=parents + [key]):
@@ -165,6 +167,7 @@ class CategoryGroupTable(SphinxDirective):
             "record": "Compilation history tracking",
             "package": "Packaging manifest",
             "datasheet": "Design interface specifications",
+            "schematic": "Schematic specifications",
 
             # Nothing to document
             "library": "",

siliconcompiler/tools/_common/tcl/sc_pin_constraints.tcl

@@ -3,12 +3,11 @@ proc sc_collect_pin_constraints { \
     ordered_pins_arg \
     sc_side_layer_func \
     { print_func puts } } {
-
     upvar 1 $placement_pins_arg placement_pins
     upvar 1 $ordered_pins_arg ordered_pins
 
     set pin_order [dict create]
-    set placement_pins [list ]
+    set placement_pins [list]
 
     dict for {name params} [sc_cfg_get constraint pin] {
         set order [dict get $params order]

siliconcompiler/tools/builtin/concatenate.py

@@ -4,6 +4,22 @@ from siliconcompiler import sc_open, SiliconCompilerError
 from siliconcompiler import utils
 from siliconcompiler.tools._common import input_provides, input_file_node_name, get_tool_task
 from siliconcompiler import flowgraph
+from siliconcompiler import scheduler
+
+
+def make_docs(chip):
+    from siliconcompiler.flows._common import _make_docs
+    _make_docs(chip)
+    chip.set('option', 'flow', 'asicflow')
+
+    for step, index in flowgraph._get_flowgraph_entry_nodes(chip, 'asicflow'):
+        scheduler._setup_node(chip, step, index)
+
+    chip.set('arg', 'step', 'combine')
+    chip.set('arg', 'index', '0')
+    setup(chip)
+
+    return chip
 
 
 def setup(chip):

siliconcompiler/tools/klayout/klayout.py

@@ -82,6 +82,7 @@ def setup(chip, mode="batch"):
 
     chip.set('tool', tool, 'task', task, 'refdir', refdir, step=step, index=index,
              package='siliconcompiler', clobber=clobber)
+    chip.set('tool', tool, 'task', task, 'threads', 1, step=step, index=index, clobber=clobber)
 
     if chip.get('option', 'nodisplay'):
         # Tells QT to use the offscreen platform if nodisplay is used

siliconcompiler/tools/magic/sc_drc.tcl

@@ -15,13 +15,13 @@
 
 source ./sc_manifest.tcl
 
-set sc_step    [sc_cfg_get arg step]
-set sc_index   [sc_cfg_get arg index]
-set sc_task    $sc_step
+set sc_step [sc_cfg_get arg step]
+set sc_index [sc_cfg_get arg index]
+set sc_task $sc_step
 
-set sc_design    [sc_top]
+set sc_design [sc_top]
 set sc_macrolibs [sc_get_asic_libraries macro]
-set sc_stackup   [sc_cfg_get option stackup]
+set sc_stackup [sc_cfg_get option stackup]
 
 if { [sc_cfg_tool_task_exists var exclude] } {
     set sc_exclude [sc_cfg_tool_task_get var exclude]

siliconcompiler/tools/magic/sc_extspice.tcl

@@ -1,8 +1,8 @@
 source ./sc_manifest.tcl
 
-set sc_step    [sc_cfg_get arg step]
-set sc_index   [sc_cfg_get arg index]
-set sc_task    $sc_step
+set sc_step [sc_cfg_get arg step]
+set sc_index [sc_cfg_get arg index]
+set sc_task $sc_step
 
 set sc_design [sc_top]
 set sc_logiclibs [sc_get_asic_libraries logic]

siliconcompiler/tools/magic/sc_magic.tcl

@@ -36,8 +36,8 @@ if { $sc_pdk == "skywater130" } {
     cif istyle sky130(vendor)
 }
 
-set mydir      [file dirname [file normalize [info script]]]
-set sc_step    [sc_cfg_get arg step]
+set mydir [file dirname [file normalize [info script]]]
+set sc_step [sc_cfg_get arg step]
 
 if { [catch { source "$mydir/sc_${sc_step}.tcl" } err] } {
     puts $err

siliconcompiler/tools/netgen/sc_lvs.tcl

@@ -1,8 +1,8 @@
 source ./sc_manifest.tcl
 
-set sc_step    [sc_cfg_get arg step]
-set sc_index   [sc_cfg_get arg index]
-set sc_task    $sc_step
+set sc_step [sc_cfg_get arg step]
+set sc_index [sc_cfg_get arg index]
+set sc_task $sc_step
 
 set sc_design [sc_top]
 set sc_macrolibs [sc_get_asic_libraries macro]

siliconcompiler/tools/openroad/scripts/sc_apr.tcl

@@ -19,7 +19,7 @@ proc sc_get_layer_name { name } {
   if { [string length $name] == 0 } {
     return ""
   }
-  if { [ string is integer $name ] } {
+  if { [string is integer $name] } {
     set layer [[ord::get_db_tech] findRoutingLayer $name]
     if { $layer == "NULL" } {
       utl::error FLW 1 "$name is not a valid routing layer."
@@ -35,8 +35,10 @@ proc has_tie_cell { type } {
   upvar sc_tool sc_tool
 
   set library_vars [sc_cfg_get library $sc_mainlib option {var}]
-  return [expr { [dict exists $library_vars openroad_tie${type}_cell] && \
-                 [dict exists $library_vars openroad_tie${type}_port] }]
+  return [expr {
+    [dict exists $library_vars openroad_tie${type}_cell] &&
+    [dict exists $library_vars openroad_tie${type}_port]
+  }]
 }
 
 proc get_tie_cell { type } {
@@ -54,46 +56,46 @@ proc get_tie_cell { type } {
 # Schema Adapter
 ###############################
 
-set sc_tool   openroad
-set sc_step   [sc_cfg_get arg step]
-set sc_index  [sc_cfg_get arg index]
-set sc_flow   [sc_cfg_get option flow]
-set sc_task   [sc_cfg_get flowgraph $sc_flow $sc_step $sc_index task]
+set sc_tool openroad
+set sc_step [sc_cfg_get arg step]
+set sc_index [sc_cfg_get arg index]
+set sc_flow [sc_cfg_get option flow]
+set sc_task [sc_cfg_get flowgraph $sc_flow $sc_step $sc_index task]
 
-set sc_refdir [sc_cfg_tool_task_get refdir ]
+set sc_refdir [sc_cfg_tool_task_get refdir]
 
 # Design
-set sc_design     [sc_top]
-set sc_optmode    [sc_cfg_get option optmode]
-set sc_pdk        [sc_cfg_get option pdk]
-set sc_stackup    [sc_cfg_get option stackup]
+set sc_design [sc_top]
+set sc_optmode [sc_cfg_get option optmode]
+set sc_pdk [sc_cfg_get option pdk]
+set sc_stackup [sc_cfg_get option stackup]
 
 # APR Parameters
-set sc_targetlibs  [sc_get_asic_libraries logic]
-set sc_mainlib     [lindex $sc_targetlibs 0]
-set sc_delaymodel  [sc_cfg_get asic delaymodel]
-set sc_pdk_vars    [sc_cfg_get pdk $sc_pdk {var} $sc_tool]
-set sc_hpinmetal   [dict get $sc_pdk_vars pin_layer_horizontal $sc_stackup]
-set sc_vpinmetal   [dict get $sc_pdk_vars pin_layer_vertical $sc_stackup]
-set sc_rc_signal   [lindex [dict get $sc_pdk_vars rclayer_signal $sc_stackup] 0]
-set sc_rc_clk      [lindex [dict get $sc_pdk_vars rclayer_clock $sc_stackup] 0]
-set sc_minmetal    [sc_cfg_get pdk $sc_pdk minlayer $sc_stackup]
-set sc_maxmetal    [sc_cfg_get pdk $sc_pdk maxlayer $sc_stackup]
+set sc_targetlibs [sc_get_asic_libraries logic]
+set sc_mainlib [lindex $sc_targetlibs 0]
+set sc_delaymodel [sc_cfg_get asic delaymodel]
+set sc_pdk_vars [sc_cfg_get pdk $sc_pdk {var} $sc_tool]
+set sc_hpinmetal [dict get $sc_pdk_vars pin_layer_horizontal $sc_stackup]
+set sc_vpinmetal [dict get $sc_pdk_vars pin_layer_vertical $sc_stackup]
+set sc_rc_signal [lindex [dict get $sc_pdk_vars rclayer_signal $sc_stackup] 0]
+set sc_rc_clk [lindex [dict get $sc_pdk_vars rclayer_clock $sc_stackup] 0]
+set sc_minmetal [sc_cfg_get pdk $sc_pdk minlayer $sc_stackup]
+set sc_maxmetal [sc_cfg_get pdk $sc_pdk maxlayer $sc_stackup]
 set sc_aspectratio [sc_cfg_get constraint aspectratio]
-set sc_density     [sc_cfg_get constraint density]
-set sc_scenarios   [dict keys [sc_cfg_get constraint timing]]
+set sc_density [sc_cfg_get constraint density]
+set sc_scenarios [dict keys [sc_cfg_get constraint timing]]
 
 # Library
 set sc_libtype [sc_cfg_get library $sc_mainlib asic libarch]
 # TODO: handle multiple sites properly
-set sc_site         [lindex [sc_cfg_get library $sc_mainlib asic site $sc_libtype] 0]
-set sc_filler       [sc_cfg_get library $sc_mainlib asic cells filler]
-set sc_dontuse      [sc_cfg_get library $sc_mainlib asic cells dontuse]
-set sc_clkbuf       [lindex [sc_cfg_tool_task_get {var} cts_clock_buffer] 0]
-set sc_filler       [sc_cfg_get library $sc_mainlib asic cells filler]
-set sc_tap          [sc_cfg_get library $sc_mainlib asic cells tap]
-set sc_endcap       [sc_cfg_get library $sc_mainlib asic cells endcap]
-set sc_pex_corners  [sc_cfg_tool_task_get {var} pex_corners]
+set sc_site [lindex [sc_cfg_get library $sc_mainlib asic site $sc_libtype] 0]
+set sc_filler [sc_cfg_get library $sc_mainlib asic cells filler]
+set sc_dontuse [sc_cfg_get library $sc_mainlib asic cells dontuse]
+set sc_clkbuf [lindex [sc_cfg_tool_task_get {var} cts_clock_buffer] 0]
+set sc_filler [sc_cfg_get library $sc_mainlib asic cells filler]
+set sc_tap [sc_cfg_get library $sc_mainlib asic cells tap]
+set sc_endcap [sc_cfg_get library $sc_mainlib asic cells endcap]
+set sc_pex_corners [sc_cfg_tool_task_get {var} pex_corners]
 set sc_power_corner [lindex [sc_cfg_tool_task_get {var} power_corner] 0]
 
 # PDK Design Rules
@@ -394,7 +396,7 @@ if { $sc_task != "floorplan" } {
 
   # Adjust routing track density
   foreach layer [[ord::get_db_tech] getLayers] {
-    if { [ $layer getRoutingLevel ] == 0 } {
+    if { [$layer getRoutingLevel] == 0 } {
       continue
     }
 

siliconcompiler/tools/openroad/scripts/sc_cts.tcl

@@ -4,7 +4,6 @@
 #######################################
 
 if { [llength [all_clocks]] > 0 } {
-
   # Clone clock tree inverters next to register loads
   # so cts does not try to buffer the inverted clocks.
   repair_clock_inverters

siliconcompiler/tools/openroad/scripts/sc_dfm.tcl

@@ -9,8 +9,10 @@ foreach obstruction [[ord::get_db_block] getObstructions] {
 }
 utl::info FLW 1 "Deleted $removed_obs routing obstructions"
 
-if { $openroad_fin_add_fill == "true" && \
-     [sc_cfg_exists pdk $sc_pdk aprtech openroad $sc_stackup $sc_libtype fill] } {
+if {
+  $openroad_fin_add_fill == "true" &&
+  [sc_cfg_exists pdk $sc_pdk aprtech openroad $sc_stackup $sc_libtype fill]
+} {
   set sc_fillrules \
     [lindex [sc_cfg_get pdk $sc_pdk aprtech openroad $sc_stackup $sc_libtype fill] 0]
   density_fill -rules $sc_fillrules

siliconcompiler/tools/openroad/scripts/sc_export.tcl

@@ -3,8 +3,10 @@
 ###########################
 
 set lef_args []
-if { [lindex [sc_cfg_tool_task_get {var} ord_abstract_lef_bloat_layers] 0] \
-      == "true" } {
+if {
+  [lindex [sc_cfg_tool_task_get {var} ord_abstract_lef_bloat_layers] 0]
+  == "true"
+} {
   lappend lef_args "-bloat_occupied_layers"
 } else {
   lappend lef_args \

siliconcompiler/tools/openroad/scripts/sc_floorplan.tcl

@@ -23,12 +23,14 @@ if { [sc_cfg_exists input asic floorplan] } {
   read_def -floorplan_initialize $def
 } else {
   #NOTE: assuming a two tuple value as lower left, upper right
-  set sc_diearea   [sc_cfg_get constraint outline]
-  set sc_corearea  [sc_cfg_get constraint corearea]
-  if { $sc_diearea != "" && \
-       $sc_corearea != "" } {
+  set sc_diearea [sc_cfg_get constraint outline]
+  set sc_corearea [sc_cfg_get constraint corearea]
+  if {
+    $sc_diearea != "" &&
+    $sc_corearea != ""
+  } {
     # Use die and core sizes
-    set sc_diesize  "[lindex $sc_diearea 0] [lindex $sc_diearea 1]"
+    set sc_diesize "[lindex $sc_diearea 0] [lindex $sc_diearea 1]"
     set sc_coresize "[lindex $sc_corearea 0] [lindex $sc_corearea 1]"
 
     initialize_floorplan -die_area $sc_diesize \
@@ -61,8 +63,10 @@ if { [sc_cfg_exists library $sc_mainlib option file openroad_tracks] } {
 }
 
 set do_automatic_pins 1
-if { [sc_cfg_tool_task_exists file padring] && \
-     [llength [sc_cfg_tool_task_get file padring]] > 0 } {
+if {
+  [sc_cfg_tool_task_exists file padring] &&
+  [llength [sc_cfg_tool_task_get file padring]] > 0
+} {
   set do_automatic_pins 0
 
   ###########################
@@ -208,7 +212,7 @@ if { [sc_cfg_exists constraint component] } {
       }
 
       set site_height [$site getHeight]
-      set site_width  [$site getWidth]
+      set site_width [$site getWidth]
       if { $y_grid == 0 } {
         set y_grid $site_height
       } elseif { $y_grid > $site_height } {
@@ -237,11 +241,11 @@ if { [sc_cfg_exists constraint component] } {
   dict for {name params} [sc_cfg_get constraint component] {
     set location [dict get $params placement]
     set rotation [dict get $params rotation]
-    if { [llength $rotation] == 0 } {
-      set rotation 0
+    if { [string match "*MZ*" $rotation] } {
+      utl::error FLW 1 "Z mirroring is not supported in OpenROAD"
     }
-    set rotation [expr { int($rotation) }]
-    set flip     [dict get $params flip]
+    set rotation [string map {"_" ""} $rotation]
+
     if { [dict exists $params partname] } {
       set cell [dict get $params partname]
     } else {
@@ -251,14 +255,7 @@ if { [sc_cfg_exists constraint component] } {
       utl::warn FLW 1 "Halo is not supported in OpenROAD"
     }
 
-    set transform_r [odb::dbTransform]
-    $transform_r setOrient "R${rotation}"
-    set transform_f [odb::dbTransform]
-    if { $flip == "true" } {
-      $transform_f setOrient [odb::dbTransform "MY"]
-    }
-    set transform_final [odb::dbTransform]
-    odb::dbTransform_concat $transform_r $transform_f $transform_final
+    set transform [odb::dbTransform $rotation]
 
     set inst [[ord::get_db_block] findInst $name]
     if { $inst == "NULL" } {
@@ -275,16 +272,11 @@ if { [sc_cfg_exists constraint component] } {
       }
     }
     set master [$inst getMaster]
-    set height [ord::dbu_to_microns [$master getHeight]]
-    set width [ord::dbu_to_microns [$master getWidth]]
-
-    set x_loc [expr { [lindex $location 0] - $width / 2 }]
-    set y_loc [expr { [lindex $location 1] - $height / 2 }]
 
-    set x_loc [expr { round($x_loc / $x_grid) * $x_grid }]
-    set y_loc [expr { round($y_loc / $y_grid) * $y_grid }]
+    set x_loc [expr { round([lindex $location 0] / $x_grid) * $x_grid }]
+    set y_loc [expr { round([lindex $location 1] / $y_grid) * $y_grid }]
 
-    $inst setOrient [$transform_final getOrient]
+    $inst setOrient [$rotation getOrient]
     $inst setLocation [ord::microns_to_dbu $x_loc] [ord::microns_to_dbu $y_loc]
     $inst setPlacementStatus FIRM
   }
@@ -302,8 +294,10 @@ if { $do_automatic_pins } {
 # since we get an error otherwise.
 if { [sc_design_has_unplaced_macros] } {
   if { $openroad_rtlmp_enable == "true" } {
-    set halo_max [expr { max([lindex $openroad_mpl_macro_place_halo 0], \
-                             [lindex $openroad_mpl_macro_place_halo 1]) }]
+    set halo_max [expr {
+      max([lindex $openroad_mpl_macro_place_halo 0],
+        [lindex $openroad_mpl_macro_place_halo 1])
+    }]
 
     set rtlmp_args []
     if { $openroad_rtlmp_min_instances != "" } {
@@ -370,9 +364,11 @@ if { [sc_cfg_tool_task_exists {file} ifp_tapcell] } {
 # Power Network
 ###########################
 
-if { $openroad_pdn_enable == "true" && \
-     [sc_cfg_tool_task_exists {file} pdn_config] && \
-     [llength [sc_cfg_tool_task_get {file} pdn_config]] > 0 } {
+if {
+  $openroad_pdn_enable == "true" &&
+  [sc_cfg_tool_task_exists {file} pdn_config] &&
+  [llength [sc_cfg_tool_task_get {file} pdn_config]] > 0
+} {
   set pdn_files []
   foreach pdnconfig [sc_cfg_tool_task_get {file} pdn_config] {
     if { [lsearch -exact $pdn_files $pdnconfig] != -1 } {

siliconcompiler/tools/openroad/scripts/sc_metrics.tcl

@@ -59,8 +59,10 @@ if { [sc_cfg_tool_task_check_in_list unconstrained var reports] } {
     > reports/timing/unconstrained.topN.rpt
 }
 
-if { [sc_cfg_tool_task_check_in_list clock_skew var reports] && \
-     [llength [all_clocks]] > 0 } {
+if {
+  [sc_cfg_tool_task_check_in_list clock_skew var reports] &&
+  [llength [all_clocks]] > 0
+} {
   puts "$PREFIX clock_skew"
   report_clock_skew -setup -digits 4 > reports/timing/skew.setup.rpt
   sc_display_report reports/timing/skew.setup.rpt

siliconcompiler/tools/openroad/scripts/sc_physyn.tcl

@@ -1,4 +1,3 @@
-
 # while (not good enough):
 #   global placement
 #   estimate parasitics