siliconcompiler 0.32.0__py3-none-any.whl → 0.32.2__py3-none-any.whl

siliconcompiler/scheduler/__init__.py

@@ -2,6 +2,7 @@ import contextlib
 import distro
 import getpass
 import multiprocessing
+import logging
 import os
 import platform
 import psutil
@@ -17,6 +18,7 @@ import packaging.specifiers
 from io import StringIO
 import traceback
 from datetime import datetime
+from logging.handlers import QueueHandler, QueueListener
 from siliconcompiler import sc_open
 from siliconcompiler import utils
 from siliconcompiler import _metadata
@@ -275,7 +277,12 @@ def _local_process(chip, flow):
     nodes_to_run = {}
     processes = {}
     local_processes = []
-    _prepare_nodes(chip, nodes_to_run, processes, local_processes, flow)
+    log_queue = _prepare_nodes(chip, nodes_to_run, processes, local_processes, flow)
+
+    # Handle logs across threads
+    log_listener = QueueListener(log_queue, chip.logger._console)
+    chip.logger._console.setFormatter(logging.Formatter("%(message)s"))
+    log_listener.start()
 
     # Update dashboard before run begins
     if chip._dash:
@@ -285,6 +292,7 @@ def _local_process(chip, flow):
         _launch_nodes(chip, nodes_to_run, processes, local_processes)
     except KeyboardInterrupt:
         # exit immediately
+        log_listener.stop()
         sys.exit(0)
 
     if _get_callback('post_run'):
@@ -292,6 +300,10 @@ def _local_process(chip, flow):
 
     _check_nodes_status(chip, flow)
 
+    # Cleanup logger
+    log_listener.stop()
+    chip._init_logger_formats()
+
 
 def __is_posix():
     return sys.platform != 'win32'
@@ -421,7 +433,7 @@ def _check_version(chip, reported_version, tool, step, index):
 
 
 ###########################################################################
-def _runtask(chip, flow, step, index, exec_func, pipe=None, replay=False):
+def _runtask(chip, flow, step, index, exec_func, pipe=None, queue=None, replay=False):
     '''
     Private per node run method called by run().
 
@@ -437,6 +449,11 @@ def _runtask(chip, flow, step, index, exec_func, pipe=None, replay=False):
     chip._init_codecs()
 
     chip._init_logger(step, index, in_run=True)
+    if queue:
+        chip.logger.removeHandler(chip.logger._console)
+        chip.logger._console = QueueHandler(queue)
+        chip.logger.addHandler(chip.logger._console)
+        chip._init_logger_formats()
 
     chip.set('arg', 'step', step, clobber=True)
     chip.set('arg', 'index', index, clobber=True)
@@ -541,13 +558,12 @@ def _select_inputs(chip, step, index, trial=False):
                             '_select_inputs',
                             None)
     if select_inputs:
-        log_handlers = None
+        log_level = chip.logger.level
         if trial:
-            log_handlers = chip.logger.handlers.copy()
-            chip.logger.handlers.clear()
+            chip.logger.setLevel(logging.CRITICAL)
         sel_inputs = select_inputs(chip, step, index)
-        if log_handlers:
-            chip.logger.handlers = log_handlers
+        if trial:
+            chip.logger.setLevel(log_level)
     else:
         sel_inputs = _get_pruned_node_inputs(chip, flow, (step, index))
 
@@ -862,9 +878,16 @@ def _run_executable_or_builtin(chip, step, index, version, toolpath, workdir, ru
                     stderr_writer.close()
                     stderr_writer = sys.stdout
 
+                # Handle logger stdout suppression if quiet
+                stdout_handler_level = chip.logger._console.level
+                if chip.get('option', 'quiet', step=step, index=index):
+                    chip.logger._console.setLevel(logging.CRITICAL)
+
                 with contextlib.redirect_stderr(stderr_writer), \
                         contextlib.redirect_stdout(stdout_writer):
                     retcode = run_func(chip)
+
+                chip.logger._console.setLevel(stdout_handler_level)
         except Exception as e:
             chip.logger.error(f'Failed in run() for {tool}/{task}: {e}')
             retcode = 1  # default to non-zero
@@ -1491,6 +1514,9 @@ def _prepare_nodes(chip, nodes_to_run, processes, local_processes, flow):
     # Call this in case this was invoked without __main__
     multiprocessing.freeze_support()
 
+    # Log queue for logging messages
+    log_queue = multiprocessing.Queue(-1)
+
     init_funcs = set()
     for (step, index) in nodes_to_execute(chip, flow):
         node = (step, index)
@@ -1525,13 +1551,16 @@ def _prepare_nodes(chip, nodes_to_run, processes, local_processes, flow):
         process["proc"] = multiprocessing.Process(
             target=_runtask,
             args=(chip, flow, step, index, exec_func),
-            kwargs={"pipe": process["child_pipe"]})
+            kwargs={"pipe": process["child_pipe"],
+                    "queue": log_queue})
 
         processes[node] = process
 
     for init_func in init_funcs:
         init_func(chip)
 
+    return log_queue
+
 
 def _check_node_dependencies(chip, node, deps, deps_was_successful):
     had_deps = len(deps) > 0

siliconcompiler/scheduler/docker_runner.py

@@ -115,7 +115,8 @@ def run(chip, step, index, replay):
     start_cwd = os.getcwd()
 
     # Remove handlers from logger
-    chip.logger.handlers.clear()
+    for handler in chip.logger.handlers.copy():
+        chip.logger.removeHandler(handler)
 
     # Reinit logger
     chip._init_logger(step=step, index=index, in_run=True)

siliconcompiler/schema/schema_obj.py

@@ -39,7 +39,7 @@ except ImportError:
     _has_yaml = False
 
 from .schema_cfg import schema_cfg
-from .utils import escape_val_tcl, PACKAGE_ROOT, translate_loglevel, PerNode, Scope
+from .utils import escape_val_tcl, translate_loglevel, PerNode, Scope
 
 
 class Schema:
@@ -1122,7 +1122,8 @@ class Schema:
 
         if template:
             fout.write(template.render(manifest_dict='\n'.join(tcl_set_cmds),
-                                       scroot=os.path.abspath(PACKAGE_ROOT),
+                                       scroot=os.path.abspath(
+                                           os.path.join(os.path.dirname(__file__), '..')),
                                        record_access=self._do_record_access(),
                                        record_access_id=Schema._RECORD_ACCESS_IDENTIFIER))
         else:

siliconcompiler/schema/utils.py

@@ -4,13 +4,10 @@
 # SC dependencies outside of its directory, since it may be used by tool drivers
 # that have isolated Python environments.
 
-import os
 import re
 import sys
 from enum import Enum
 
-PACKAGE_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
-
 
 #############################################################################
 # ENUM DEFINITIONs

siliconcompiler/sphinx_ext/dynamicgen.py

@@ -325,7 +325,7 @@ class DynamicGen(SphinxDirective):
 
         return True
 
-    def _document_free_params(self, cfg, type, key_path, reference_prefix, s):
+    def _document_free_params(self, cfg, type, key_path, reference_prefix, s, show_type=False):
         if type in cfg:
             cfg = cfg[type]
         else:
@@ -337,8 +337,12 @@ class DynamicGen(SphinxDirective):
             type_heading = "Files"
         elif type == "dir":
             type_heading = "Directories"
+        else:
+            raise ValueError(type)
 
         table = [[strong('Parameters'), strong('Help')]]
+        if show_type:
+            table[0].insert(1, strong('Type'))
         for key, params in cfg.items():
             if key == "default":
                 continue
@@ -346,7 +350,10 @@ class DynamicGen(SphinxDirective):
             key_node = nodes.paragraph()
             key_node += keypath(key_path + [key], self.env.docname,
                                 key_text=["...", f"'{type}'", f"'{key}'"])
-            table.append([key_node, para(params["help"])])
+            entry = [key_node, para(params["help"])]
+            if show_type:
+                entry.insert(1, code(params["type"]))
+            table.append(entry)
 
         if len(table) > 1:
             s += build_section(type_heading, self.get_ref(*reference_prefix, type))
@@ -710,14 +717,6 @@ class ToolGen(DynamicGen):
         self.__tool = None
         self.__task = None
 
-        # Annotate the target used for default values
-        if chip.valid('option', 'target') and chip.get('option', 'target'):
-            p = docutils.nodes.inline('')
-            target = chip.get('option', 'target').split('.')[-1]
-            targetid = get_ref_id(DynamicGen.get_ref_key(TargetGen.REF_PREFIX, target))
-            self.parse_rst(f"Built using target: :ref:`{target}<{targetid}>`", p)
-            s += p
-
         try:
             task_setup(chip)
 
@@ -780,7 +779,8 @@ class ToolGen(DynamicGen):
 
     def document_free_params(self, cfg, reference_prefix, s):
         key_path = ['tool', '<tool>', 'task', '<task>']
-        self._document_free_params(cfg, 'var', key_path + ['var'], reference_prefix, s)
+        self._document_free_params(cfg, 'var', key_path + ['var'], reference_prefix, s,
+                                   show_type=True)
         self._document_free_params(cfg, 'file', key_path + ['file'], reference_prefix, s)
         self._document_free_params(cfg, 'dir', key_path + ['dir'], reference_prefix, s)
 

siliconcompiler/targets/fpgaflow_demo.py

@@ -1,7 +1,6 @@
 import siliconcompiler
 from siliconcompiler import SiliconCompilerError
 from siliconcompiler.fpgas import lattice_ice40
-from siliconcompiler.fpgas import vpr_example
 
 from siliconcompiler.flows import fpgaflow
 
@@ -30,7 +29,6 @@ def setup(chip, partname=None):
 
     # 2.  Load all available FPGAs
     chip.use(lattice_ice40)
-    chip.use(vpr_example)
 
     # 3. Load flow
     chip.use(fpgaflow, partname=partname)

siliconcompiler/templates/tcl/manifest.tcl.j2

@@ -11,129 +11,13 @@
 # Helper functions
 #############################################
 
-# Shortcut to get values from configuration
-proc sc_cfg_get { args } {
-    # Refer to global sc_cfg dictionary
-    global sc_cfg
-
-    {% if record_access %}puts "{{ record_access_id }} [join $args ,]"{% endif %}
-
-    if { ![sc_cfg_exists {*}$args] } {
-        throw {FLOW KEYERROR} "key \"$args\" is not in the siliconcompiler configuration"
-    }
-
-    return [dict get $sc_cfg {*}$args]
-}
-
-proc sc_cfg_exists { args } {
-    # Refer to global sc_cfg dictionary
-    global sc_cfg
-
-    return [dict exists $sc_cfg {*}$args]
-}
-
-proc sc_top {} {
-    set sc_entrypoint [sc_cfg_get option entrypoint]
-    if {$sc_entrypoint == {{ '{}' }}} {
-        return [sc_cfg_get design]
-    }
-    return $sc_entrypoint
-}
-
 proc sc_root {} {
     return "{{ scroot }}"
 }
 
-# Shortcut to get tool vars
-proc sc_cfg_tool_task_get { args } {
-    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   [sc_cfg_get flowgraph $sc_flow $sc_step $sc_index tool]
-
-    return [sc_cfg_get tool $sc_tool task $sc_task {*}$args]
-}
+{% include 'tools/_common/tcl/sc_schema_access.tcl' %}
 
-proc sc_cfg_tool_task_exists { args } {
-    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   [sc_cfg_get flowgraph $sc_flow $sc_step $sc_index tool]
-
-    return [sc_cfg_exists tool $sc_tool task $sc_task {*}$args]
-}
-
-# Check if an item is present in a list
-proc sc_cfg_tool_task_check_in_list { item args } {
-    set result [sc_cfg_tool_task_get {*}$args]
-
-    if { [lsearch -exact $result $item] != -1 } {
-        return 1
-    } else {
-        return 0
-    }
-}
-
-proc sc_section_banner { text { method puts } } {
-    $method "============================================================"
-    $method "| $text"
-    $method "============================================================"
-}
-
-# Get list of soft libraries
-proc sc_get_libraries { {library {}} {libraries {}} } {
-    set key []
-    if { [llength $library] != 0 } {
-        lappend key library $library
-    }
-    lappend key option library
-
-    set libs []
-    foreach lib [sc_cfg_get {*}$key] {
-        if { [lsearch -exact $libs $lib] != -1 || [lsearch -exact $libraries $lib] != -1 } {
-            continue
-        }
-
-        lappend libs $lib
-
-        foreach sublib [sc_get_libraries $lib $libs] {
-            lappend libs $sublib
-        }
-    }
-
-    return [lsort -unique $libs]
-}
-
-# Get list of asic libraries
-proc sc_get_asic_libraries { type } {
-    set libs []
-
-    foreach lib [sc_cfg_get asic ${type}lib] {
-        if { [lsearch -exact $libs $lib] != -1 } {
-            continue
-        }
-        lappend libs $lib
-    }
-
-    foreach lib [sc_get_libraries] {
-        if { ![sc_cfg_exists library $lib asic ${type}lib] } {
-            continue
-        }
-
-        foreach sublib [sc_cfg_get library $lib asic ${type}lib] {
-            if { [lsearch -exact $libs $sublib] != -1 } {
-                continue
-            }
-
-            lappend libs $sublib
-        }
-    }
-
-    return $libs
+# Redefine
+proc _sc_cfg_get_debug { args } {
+    {% if record_access %}puts "{{ record_access_id }} [join $args ,]"{% endif %}
 }

siliconcompiler/tools/_common/tcl/sc_schema_access.tcl

@@ -0,0 +1,126 @@
+proc _sc_cfg_get_debug { args } {
+
+}
+
+# Shortcut to get values from configuration
+proc sc_cfg_get { args } {
+    _sc_cfg_get_debug $args
+
+    # Refer to global sc_cfg dictionary
+    global sc_cfg
+
+    if { ![sc_cfg_exists {*}$args] } {
+        throw {FLOW KEYERROR} "key \"$args\" is not in the siliconcompiler configuration"
+    }
+
+    return [dict get $sc_cfg {*}$args]
+}
+
+proc sc_cfg_exists { args } {
+    # Refer to global sc_cfg dictionary
+    global sc_cfg
+
+    return [dict exists $sc_cfg {*}$args]
+}
+
+proc sc_top { } {
+    set sc_entrypoint [sc_cfg_get option entrypoint]
+    if { $sc_entrypoint == {{ '{}' }} } {
+        return [sc_cfg_get design]
+    }
+    return $sc_entrypoint
+}
+
+# Shortcut to get tool vars
+proc sc_cfg_tool_task_get { args } {
+    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 [sc_cfg_get flowgraph $sc_flow $sc_step $sc_index tool]
+
+    return [sc_cfg_get tool $sc_tool task $sc_task {*}$args]
+}
+
+proc sc_cfg_tool_task_exists { args } {
+    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 [sc_cfg_get flowgraph $sc_flow $sc_step $sc_index tool]
+
+    return [sc_cfg_exists tool $sc_tool task $sc_task {*}$args]
+}
+
+# Check if an item is present in a list
+proc sc_cfg_tool_task_check_in_list { item args } {
+    set result [sc_cfg_tool_task_get {*}$args]
+
+    if { [lsearch -exact $result $item] != -1 } {
+        return 1
+    } else {
+        return 0
+    }
+}
+
+proc sc_section_banner { text { method puts } } {
+    $method "============================================================"
+    $method "| $text"
+    $method "============================================================"
+}
+
+# Get list of soft libraries
+proc sc_get_libraries { { library {} } { libraries {} } } {
+    set key []
+    if { [llength $library] != 0 } {
+        lappend key library $library
+    }
+    lappend key option library
+
+    set libs []
+    foreach lib [sc_cfg_get {*}$key] {
+        if { [lsearch -exact $libs $lib] != -1 || [lsearch -exact $libraries $lib] != -1 } {
+            continue
+        }
+
+        lappend libs $lib
+
+        foreach sublib [sc_get_libraries $lib $libs] {
+            lappend libs $sublib
+        }
+    }
+
+    return [lsort -unique $libs]
+}
+
+# Get list of asic libraries
+proc sc_get_asic_libraries { type } {
+    set libs []
+
+    foreach lib [sc_cfg_get asic ${type}lib] {
+        if { [lsearch -exact $libs $lib] != -1 } {
+            continue
+        }
+        lappend libs $lib
+    }
+
+    foreach lib [sc_get_libraries] {
+        if { ![sc_cfg_exists library $lib asic ${type}lib] } {
+            continue
+        }
+
+        foreach sublib [sc_cfg_get library $lib asic ${type}lib] {
+            if { [lsearch -exact $libs $sublib] != -1 } {
+                continue
+            }
+
+            lappend libs $sublib
+        }
+    }
+
+    return $libs
+}

siliconcompiler/tools/openroad/_apr.py

@@ -555,6 +555,9 @@ def define_pad_params(chip):
 
 
 def define_rsz_params(chip):
+    set_tool_task_var(chip, param_key='rsz_skip_drv_repair',
+                      default_value=False,
+                      schelp='skip design rule violation repair')
     set_tool_task_var(chip, param_key='rsz_skip_setup_repair',
                       default_value=False,
                       schelp='skip setup timing repair')

siliconcompiler/tools/openroad/scripts/apr/sc_repair_timing.tcl

@@ -15,6 +15,11 @@ source -echo "$sc_refdir/apr/preamble.tcl"
 # Timing Repair
 ###############################
 
+set parasitics_stage -placement
+if { false } {
+    set parasitics_stage -global_routing
+}
+
 set rsz_setup_slack_margin [lindex [sc_cfg_tool_task_get {var} rsz_setup_slack_margin] 0]
 set rsz_hold_slack_margin [lindex [sc_cfg_tool_task_get {var} rsz_hold_slack_margin] 0]
 set rsz_slew_margin [lindex [sc_cfg_tool_task_get {var} rsz_slew_margin] 0]
@@ -30,6 +35,42 @@ if { [lindex [sc_cfg_tool_task_get {var} rsz_skip_gate_cloning] 0] == "true" } {
     lappend repair_timing_args "-skip_gate_cloning"
 }
 
+set repair_design_args []
+set rsz_cap_margin [lindex [sc_cfg_tool_task_get {var} rsz_cap_margin] 0]
+if { $rsz_cap_margin != "false" } {
+    lappend repair_design_args "-cap_margin" $rsz_cap_margin
+}
+set rsz_slew_margin [lindex [sc_cfg_tool_task_get {var} rsz_slew_margin] 0]
+if { $rsz_slew_margin != "false" } {
+    lappend repair_design_args "-slew_margin" $rsz_slew_margin
+}
+
+set total_insts [llength [[ord::get_db_block] getInsts]]
+# Remove filler cells before attempting to repair timing
+remove_fillers
+set removed_fillers [expr { $total_insts - [llength [[ord::get_db_block] getInsts]] }]
+
+if { [lindex [sc_cfg_tool_task_get var rsz_skip_drv_repair] 0] != "true" } {
+    ###############################
+    # DRV Repair
+    ###############################
+
+    # Enable ffs for resizing
+    sc_set_dont_use -scanchain -multibit -report dont_use.repair_timing.drv
+
+    estimate_parasitics $parasitics_stage
+
+    sc_report_args -command repair_design -args $repair_design_args
+    repair_design \
+        -verbose \
+        {*}$repair_design_args
+
+    sc_detailed_placement -congestion_report reports/congestion.drv.rpt
+
+    # Restore dont use
+    sc_set_dont_use
+}
+
 if { [lindex [sc_cfg_tool_task_get var rsz_skip_setup_repair] 0] != "true" } {
     ###############################
     # Setup Repair
@@ -38,7 +79,7 @@ if { [lindex [sc_cfg_tool_task_get var rsz_skip_setup_repair] 0] != "true" } {
     # Enable ffs for resizing
     sc_set_dont_use -scanchain -multibit -report dont_use.repair_timing.setup
 
-    estimate_parasitics -placement
+    estimate_parasitics $parasitics_stage
 
     sc_report_args -command repair_timing -args $repair_timing_args
     repair_timing \
@@ -49,7 +90,7 @@ if { [lindex [sc_cfg_tool_task_get var rsz_skip_setup_repair] 0] != "true" } {
         -repair_tns $rsz_repair_tns \
         {*}$repair_timing_args
 
-    sc_detailed_placement
+    sc_detailed_placement -congestion_report reports/congestion.setup_repair.rpt
 
     # Restore dont use
     sc_set_dont_use
@@ -60,7 +101,7 @@ if { [lindex [sc_cfg_tool_task_get var rsz_skip_hold_repair] 0] != "true" } {
     # Hold Repair
     ###############################
 
-    estimate_parasitics -placement
+    estimate_parasitics $parasitics_stage
 
     # Enable hold cells
     sc_set_dont_use -hold -scanchain -multibit -report dont_use.repair_timing.hold
@@ -74,7 +115,7 @@ if { [lindex [sc_cfg_tool_task_get var rsz_skip_hold_repair] 0] != "true" } {
         -repair_tns $rsz_repair_tns \
         {*}$repair_timing_args
 
-    sc_detailed_placement
+    sc_detailed_placement -congestion_report reports/congestion.hold_repair.rpt
 
     # Restore dont use
     sc_set_dont_use
@@ -85,7 +126,7 @@ if { [lindex [sc_cfg_tool_task_get var rsz_skip_recover_power] 0] != "true" } {
     # Recover power
     ###############################
 
-    estimate_parasitics -placement
+    estimate_parasitics $parasitics_stage
 
     # Enable cells
     sc_set_dont_use -hold -scanchain -multibit -report dont_use.repair_timing.power
@@ -98,16 +139,21 @@ if { [lindex [sc_cfg_tool_task_get var rsz_skip_recover_power] 0] != "true" } {
         -hold_margin $rsz_hold_slack_margin \
         {*}$repair_timing_args
 
-    sc_detailed_placement
+    sc_detailed_placement -congestion_report reports/congestion.power_recovery.rpt
 
     # Restore dont use
     sc_set_dont_use
 }
 
+if { $removed_fillers > 0 } {
+    # Add filler cells back
+    sc_insert_fillers
+}
+
 global_connect
 
 # estimate for metrics
-estimate_parasitics -placement
+estimate_parasitics $parasitics_stage
 
 ###############################
 # Task Postamble

siliconcompiler/tools/openroad/scripts/common/procs.tcl

@@ -97,7 +97,12 @@ proc sc_global_placement { args } {
 # Detailed Placement
 ###########################
 
-proc sc_detailed_placement { } {
+proc sc_detailed_placement { args } {
+    sta::parse_key_args "sc_detailed_placement" args \
+        keys {-congestion_report} \
+        flags {}
+    sta::check_argc_eq0 "sc_detailed_placement" $args
+
     set dpl_padding [lindex [sc_cfg_tool_task_get var pad_detail_place] 0]
     set dpl_disallow_one_site [lindex [sc_cfg_tool_task_get var dpl_disallow_one_site] 0]
     set dpl_max_displacement [lindex [sc_cfg_tool_task_get var dpl_max_displacement] 0]
@@ -111,10 +116,23 @@ proc sc_detailed_placement { } {
         lappend dpl_args "-disallow_one_site_gaps"
     }
 
+    set incremental_route false
+
+    if { $incremental_route } {
+        global_route -start_incremental
+    }
+
     sc_report_args -command detailed_placement -args $dpl_args
+
     detailed_placement \
         -max_displacement $dpl_max_displacement \
         {*}$dpl_args
+
+    if { $incremental_route } {
+        global_route -end_incremental \
+            -congestion_report_file $keys(-congestion_report)
+    }
+
     check_placement -verbose
 }