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

siliconcompiler/_metadata.py

@@ -1,5 +1,5 @@
 # Version number following semver standard.
-version = '0.32.1'
+version = '0.32.2'
 
 # Default server address for remote runs, if unspecified.
 default_server = 'https://server.siliconcompiler.com'

siliconcompiler/apps/sc_install.py

@@ -139,8 +139,8 @@ def _get_tools_list():
 
 def _recommended_tool_groups(tools):
     groups = {
-        "asic": {"surelog", "sv2v", "yosys", "openroad", "klayout"},
-        "fpga": {"surelog", "sv2v", "yosys", "vpr"},
+        "asic": {"sv2v", "yosys", "openroad", "klayout"},
+        "fpga": {"sv2v", "yosys", "vpr"},
         "digital-simulation": {"verilator", "icarus", "gtkwave"},
         "analog-simulation": {"xyce"}
     }
@@ -162,7 +162,13 @@ class HelpFormatter(argparse.ArgumentDefaultsHelpFormatter, argparse.RawDescript
 
 def main():
     progname = "sc-install"
-    description = """
+
+    tools = _get_tools_list()
+    group_desc = "\n".join(
+        [f"    {grp}: {', '.join(grp_tools)}"
+         for grp, grp_tools in _recommended_tool_groups(tools).items()])
+
+    description = f"""
 -----------------------------------------------------------
 SC app install supported tools.
 
@@ -187,14 +193,16 @@ To show the install script:
 To system debugging information (this should only be used to debug):
     sc-install -debug_machine
 -----------------------------------------------------------
+Tool groups:
+{group_desc}
+-----------------------------------------------------------
 """
+
     parser = argparse.ArgumentParser(
         prog=progname,
         description=description,
         formatter_class=HelpFormatter)
 
-    tools = _get_tools_list()
-
     if _get_os_name() is None:
         print("Unsupported operating system", file=sys.stderr)
         print_machine_info()

siliconcompiler/apps/sc_remote.py

@@ -97,8 +97,9 @@ To delete a job, use:
         chip.logger.error(f'Error: {", ".join(["-"+e for e in exclusive])} are mutually exclusive')
         return 1
     chip_cfg = chip.get('option', 'cfg')
-    if chip_cfg and not any([args[arg] for arg in cfg_only]):
+    if not chip_cfg and any([args[arg] for arg in cfg_only]):
         chip.logger.error(f'Error: -cfg is required for {", ".join(["-"+e for e in cfg_only])}')
+        return 2
     if any([args[arg] for arg in cfg_only]) and args['server']:
         chip.logger.error('Error: -server cannot be specified with '
                           f'{", ".join(["-"+e for e in cfg_only])}')

siliconcompiler/core.py

@@ -203,13 +203,11 @@ class Chip:
 
     def _add_file_logger(self, filename):
         # Add a file handler for logging
-        logformat = self.logger.handlers[0].formatter
-
         file_handler = logging.FileHandler(filename)
-        file_handler.setFormatter(logformat)
-
         self.logger.addHandler(file_handler)
 
+        self._init_logger_formats()
+
         return file_handler
 
     ###########################################################################
@@ -227,13 +225,35 @@ class Chip:
         else:
             in_run = False
 
+        # Save in run flag
+        self.logger._in_run = in_run
+        self.logger._in_step = step
+        self.logger._in_index = index
+
+        self.logger.setLevel(schema_utils.translate_loglevel(loglevel))
+
+        if not self.logger.hasHandlers():
+            stream_handler = logging.StreamHandler(stream=sys.stdout)
+            # Save console handler
+            self.logger._console = stream_handler
+            self.logger.addHandler(stream_handler)
+
+            self.logger._support_color = ColorStreamFormatter.supports_color(stream_handler)
+
+        self._init_logger_formats(loglevel=loglevel)
+
+    def _init_logger_formats(self, loglevel=None):
+        if not loglevel:
+            self.schema.get('option', 'loglevel',
+                            step=self.logger._in_step, index=self.logger._in_index)
+
         level_format = '%(levelname)-7s'
         log_format = [level_format]
         if loglevel == 'debug':
             log_format.append('%(funcName)-10s')
             log_format.append('%(lineno)-4s')
 
-        if in_run:
+        if self.logger._in_run:
             max_column_width = 20
             # Figure out how wide to make step and index fields
             max_step_len = 1
@@ -249,6 +269,9 @@ class Chip:
 
             jobname = self.get('option', 'jobname')
 
+            step = self.logger._in_step
+            index = self.logger._in_index
+
             if step is None:
                 step = '-' * max(max_step_len // 4, 1)
             if index is None:
@@ -266,19 +289,13 @@ class Chip:
         log_format.append('%(message)s')
         stream_logformat = log_formatprefix + ' | '.join(log_format[1:])
 
-        if not self.logger.hasHandlers():
-            stream_handler = logging.StreamHandler(stream=sys.stdout)
-            self.logger.addHandler(stream_handler)
-
-        for handler in self.logger.handlers:
-            if ColorStreamFormatter.supports_color(handler):
+        for handler in self.logger.handlers.copy():
+            if handler == self.logger._console and self.logger._support_color:
                 formatter = ColorStreamFormatter(log_formatprefix, level_format, stream_logformat)
             else:
                 formatter = LoggerFormatter(log_formatprefix, level_format, stream_logformat)
             handler.setFormatter(formatter)
 
-        self.logger.setLevel(schema_utils.translate_loglevel(loglevel))
-
     ###########################################################################
     def _init_codecs(self):
         # Custom error handlers used to provide warnings when invalid characters

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/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/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')