siliconcompiler 0.28.9__py3-none-any.whl → 0.29.0__py3-none-any.whl

siliconcompiler/report/report.py

@@ -60,6 +60,8 @@ def get_flowgraph_nodes(chip, step, index):
         if value is not None:
             if key == 'inputnode':
                 value = ", ".join([f'{step}{index}' for step, index in value])
+            if key == 'pythonpackage':
+                value = ", ".join(value)
             nodes[key] = str(value)
     return nodes
 

siliconcompiler/report/summary_table.py

@@ -14,7 +14,7 @@ def _show_summary_table(chip, flow, flowgraph_nodes, show_all_indices):
     # Display data
     column_width = 15
 
-    max_line_width = max(2 * column_width, int(0.95*shutil.get_terminal_size().columns))
+    max_line_width = max(4 * column_width, int(0.95*shutil.get_terminal_size().columns))
 
     nodes, _, metrics, metrics_unit, metrics_to_show, _ = \
         _collect_data(chip, flow, flowgraph_nodes)

siliconcompiler/scheduler/__init__.py

@@ -20,7 +20,7 @@ from datetime import datetime
 from siliconcompiler import sc_open
 from siliconcompiler import utils
 from siliconcompiler import _metadata
-from siliconcompiler.remote import client
+from siliconcompiler.remote import Client
 from siliconcompiler.schema import Schema
 from siliconcompiler.scheduler import slurm
 from siliconcompiler.scheduler import docker_runner
@@ -92,6 +92,7 @@ def run(chip):
     copy_old_run_dir(chip, org_jobname)
     clean_build_dir(chip)
     _reset_flow_nodes(chip, flow, nodes_to_execute(chip, flow))
+    __record_packages(chip)
 
     # Save current environment
     environment = copy.deepcopy(os.environ)
@@ -101,7 +102,8 @@ def run(chip):
         os.environ[envvar] = val
 
     if chip.get('option', 'remote'):
-        client.remote_process(chip)
+        client = Client(chip)
+        client.run()
     else:
         _local_process(chip, flow)
 
@@ -427,7 +429,7 @@ def _check_version(chip, reported_version, tool, step, index):
 
 
 ###########################################################################
-def _runtask(chip, flow, step, index, exec_func, replay=False):
+def _runtask(chip, flow, step, index, exec_func, pipe=None, replay=False):
     '''
     Private per node run method called by run().
 
@@ -477,6 +479,9 @@ def _runtask(chip, flow, step, index, exec_func, replay=False):
     os.chdir(cwd)
     chip.schema._stop_journal()
 
+    if pipe:
+        pipe.send(chip._packages)
+
 
 ###########################################################################
 def _haltstep(chip, flow, step, index, log=True):
@@ -1389,7 +1394,10 @@ def _reset_flow_nodes(chip, flow, nodes_to_execute):
         for metric in chip.getkeys('metric'):
             _clear_metric(chip, step, index, metric)
         for record in chip.getkeys('record'):
-            _clear_record(chip, step, index, record, preserve=['remoteid', 'status'])
+            _clear_record(chip, step, index, record, preserve=[
+                'remoteid',
+                'status',
+                'pythonpackage'])
 
     # Mark all nodes as pending
     for step, index in _get_flowgraph_nodes(chip, flow):
@@ -1464,8 +1472,18 @@ def _prepare_nodes(chip, nodes_to_run, processes, local_processes, flow):
         else:
             local_processes.append((step, index))
 
-        processes[node] = multiprocessing.Process(target=_runtask,
-                                                  args=(chip, flow, step, index, exec_func))
+        process = {
+            "child_pipe": None,
+            "parent_pipe": None,
+            "proc": None
+        }
+        process["parent_pipe"], process["child_pipe"] = multiprocessing.Pipe()
+        process["proc"] = multiprocessing.Process(
+            target=_runtask,
+            args=(chip, flow, step, index, exec_func),
+            kwargs={"pipe": process["child_pipe"]})
+
+        processes[node] = process
 
     for init_func in init_funcs:
         init_func(chip)
@@ -1563,7 +1581,7 @@ def _launch_nodes(chip, nodes_to_run, processes, local_processes):
                     chip.set('record', 'status', NodeStatus.RUNNING, step=node[0], index=node[1])
                     changed = True
 
-                    processes[node].start()
+                    processes[node]["proc"].start()
                     del nodes_to_run[node]
                     running_nodes[node] = requested_threads
 
@@ -1586,7 +1604,7 @@ def _launch_nodes(chip, nodes_to_run, processes, local_processes):
 def _process_completed_nodes(chip, processes, running_nodes):
     changed = False
     for node in list(running_nodes.keys()):
-        if not processes[node].is_alive():
+        if not processes[node]["proc"].is_alive():
             step, index = node
             manifest = os.path.join(chip.getworkdir(step=step, index=index),
                                     'outputs',
@@ -1595,8 +1613,16 @@ def _process_completed_nodes(chip, processes, running_nodes):
             if os.path.exists(manifest):
                 chip.schema.read_journal(manifest)
 
+            if processes[node]["parent_pipe"] and processes[node]["parent_pipe"].poll(1):
+                try:
+                    packages = processes[node]["parent_pipe"].recv()
+                    if isinstance(packages, dict):
+                        chip._packages.update(packages)
+                except:  # noqa E722
+                    pass
+
             del running_nodes[node]
-            if processes[node].exitcode > 0:
+            if processes[node]["proc"].exitcode > 0:
                 status = NodeStatus.ERROR
             else:
                 status = chip.get('record', 'status', step=step, index=index)
@@ -1627,6 +1653,22 @@ def _check_nodes_status(chip, flow):
 #######################################
 def __record_version(chip, step, index):
     chip.set('record', 'scversion', _metadata.version, step=step, index=index)
+    chip.set('record', 'pythonversion', platform.python_version(), step=step, index=index)
+
+
+#######################################
+def __record_packages(chip):
+    try:
+        from pip._internal.operations.freeze import freeze
+    except:  # noqa E722
+        freeze = None
+
+    if freeze:
+        # clear record
+        chip.set('record', 'pythonpackage', [])
+
+        for pkg in freeze():
+            chip.add('record', 'pythonpackage', pkg)
 
 
 #######################################

siliconcompiler/schema/schema_cfg.py

@@ -10,7 +10,7 @@ try:
 except ImportError:
     from siliconcompiler.schema.utils import trim
 
-SCHEMA_VERSION = '0.48.4'
+SCHEMA_VERSION = '0.48.5'
 
 #############################################################################
 # PARAM DEFINITION
@@ -2482,6 +2482,9 @@ def schema_record(cfg, step='default', index='default'):
                'toolargs': ['tool CLI arguments',
                             '-I include/ foo.v',
                             'Arguments passed to tool via CLI.'],
+               'pythonversion': ['Python version',
+                                 '3.12.3',
+                                 """Version of python used to run this task."""],
                'osversion': ['O/S version',
                              '20.04.1-Ubuntu',
                              """Since there is not standard version system for operating
@@ -2515,16 +2518,25 @@ def schema_record(cfg, step='default', index='default'):
             pernode='required',
             schelp='Record tracking the tool exit code per step and index basis.')
 
-    # Unlike most other 'record' fields, job ID is not set per-node.
+    # Non-per-node records.
     scparam(cfg, ['record', 'remoteid'],
             sctype='str',
             shorthelp="Record: remote job ID",
-            switch="-record_remoteid 'step index <str>'",
+            switch="-record_remoteid '<str>'",
             example=[
                 "cli: -record_remoteid '0123456789abcdeffedcba9876543210'",
                 "api: chip.set('record', 'remoteid', '0123456789abcdeffedcba9876543210')"],
             schelp='Record tracking the job ID for a remote run.')
 
+    scparam(cfg, ['record', 'pythonpackage'],
+            sctype='[str]',
+            shorthelp="Record: python packages",
+            switch="-record_pythonpackage '<str>'",
+            example=[
+                "cli: -record_pythonpackage 'siliconcompiler==0.28.0'",
+                "api: chip.set('record', 'pythonpackage', 'siliconcompiler==0.28.0')"],
+            schelp='Record tracking for the python packages installed.')
+
     # flowgraph status
     scparam(cfg, ['record', 'status'],
             sctype='enum',

siliconcompiler/schema/schema_obj.py

@@ -506,6 +506,22 @@ class Schema:
             else:
                 self.set(*key, values, step=step, index=index)
 
+    ###########################################################################
+    def copy_key(self, src, dst):
+        '''
+        Copy a parameters information from the source keypath to the destination
+        keypath.
+
+        Args:
+            src (list): Key to use as source.
+            dst (list): Key to use as destination
+        '''
+
+        data = self.getdict(*src)
+
+        cfg = self.__search(*dst[0:-1], insert_defaults=True)
+        cfg[dst[-1]] = data
+
     ###########################################################################
     def remove(self, *keypath):
         '''

siliconcompiler/sphinx_ext/dynamicgen.py

@@ -9,6 +9,7 @@ from sphinx.util.docutils import SphinxDirective
 from sphinx.domains.std import StandardDomain
 from sphinx.addnodes import pending_xref
 import docutils
+from siliconcompiler import __version__ as sc_version
 
 import importlib
 import pkgutil
@@ -324,7 +325,7 @@ class DynamicGen(SphinxDirective):
 
         if builtin:
             relpath = path[len(SC_ROOT) + 1:]
-            gh_root = 'https://github.com/siliconcompiler/siliconcompiler/blob/main'
+            gh_root = f'https://github.com/siliconcompiler/siliconcompiler/blob/v{sc_version}'
             gh_link = f'{gh_root}/{relpath}'
             filename = os.path.basename(relpath)
             p = para('Setup file: ')
@@ -753,8 +754,8 @@ class ToolGen(DynamicGen):
         path = os.path.abspath(path)
         module_dir = os.path.dirname(path)
         for taskfile in os.listdir(module_dir):
-            if taskfile == "__init__.py":
-                # skip init
+            if taskfile.startswith("_"):
+                # skip private file
                 continue
 
             task_path = os.path.join(module_dir, taskfile)

siliconcompiler/targets/gf180_demo.py

@@ -1,7 +1,7 @@
 import siliconcompiler
 from siliconcompiler.flows import asicflow, asictopflow, signoffflow, synflow
 from siliconcompiler.checklists import oh_tapeout
-from siliconcompiler.tools.openroad import openroad
+from siliconcompiler.tools import openroad
 from siliconcompiler.tools._common import get_tool_tasks
 
 from lambdapdk import gf180
@@ -66,8 +66,8 @@ def setup(chip, syn_np=1, floorplan_np=1, physyn_np=1, place_np=1, cts_np=1, rou
 
     # PSM gets stuck in a loop, must be disabled for now on gf180
     for task in get_tool_tasks(chip, openroad):
-        chip.set('tool', 'openroad', 'task', task, 'var', 'psm_enable', 'false')
-    chip.set('tool', 'openroad', 'task', 'route', 'var', 'ant_check', 'false')
+        chip.set('tool', 'openroad', 'task', task, 'var', 'psm_enable', False)
+    chip.set('tool', 'openroad', 'task', 'route', 'var', 'ant_check', False)
 
 
 #########################

siliconcompiler/templates/replay/requirements.txt

@@ -0,0 +1,6 @@
+# SiliconCompiler Replay Environment
+# From {{ source }}
+# Jobname: {{ jobname }}
+
+{% for pkg in pkgs %}{{ pkg }}
+{% endfor %}

siliconcompiler/templates/replay/run.py.j2

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+# SiliconCompiler Replay
+# From {{ source }}
+# Jobname: {{ jobname }}
+
+from siliconcompiler import Chip
+
+
+if __name__ == "__main__":
+    chip = Chip("{{ design }}")
+
+    # Read manifest{% for cfg in cfgs %}
+    chip.read_manifest("{{ cfg }}"){% endfor %}
+
+    # Set tool versions{% for node, tool, version in tool_versions %}
+    chip.set("tool", "{{ tool }}", "version", "=={{ version }}", step="{{ node[0] }}", index="{{ node[1] }}"){% endfor %}
+
+    # Run
+    chip.run()
+
+    # Report summary
+    chip.summary()

siliconcompiler/templates/replay/setup.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# SiliconCompiler Replay Setup
+# From {{ source }}
+# Jobname: {{ jobname }}
+
+if [ "$(python3 -V)" != "Python {{ pythonversion }}" ]; then
+    echo "Python version mismatch: $(python3 -V) != {{ pythonversion }}"
+fi
+
+python3 -m venv {{ design }}_venv --clear
+echo "*" > gcd_venv/.gitignore
+
+. {{ design }}_venv/bin/activate
+pip3 install -r requirements.txt
+
+echo "To enable run environment: . {{ design }}_venv/bin/activate"
+echo "To replay: ./run.py"

siliconcompiler/tools/_common/__init__.py

@@ -411,11 +411,16 @@ def get_tool_task(chip, step, index, flow=None):
 
 def get_tool_tasks(chip, tool):
     tool_dir = os.path.dirname(tool.__file__)
-    tool_base_module = tool.__name__.split('.')[0:-1]
     tool_name = tool.__name__.split('.')[-1]
+    tool_base_module = tool.__name__.split('.')
+    if not tool.__file__.endswith('__init__.py'):
+        tool_base_module = tool_base_module[0:-1]
 
     task_candidates = []
     for task_mod in pkgutil.iter_modules([tool_dir]):
+        if task_mod.name.startswith('_'):
+            continue
+
         if task_mod.name == tool_name:
             continue
         task_candidates.append(task_mod.name)
@@ -468,3 +473,12 @@ def record_metric(chip, step, index, metric, value, source, source_unit=None):
         tool, task = get_tool_task(chip, step, index, flow=flow)
 
         chip.add('tool', tool, 'task', task, 'report', metric, source, step=step, index=index)
+
+
+def has_pre_post_script(chip):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    return chip.get('tool', tool, 'task', task, 'prescript', step=step, index=index) or \
+        chip.get('tool', tool, 'task', task, 'postscript', step=step, index=index)

siliconcompiler/tools/_common/asic.py

@@ -102,11 +102,18 @@ def set_tool_task_var(chip,
                      ','.join(check_keys[-1]),
                      step=step, index=index)
 
+    def check_value(val):
+        if isinstance(val, (list, tuple)):
+            return len(val) > 0
+        return val is not None
+
     require_key, value = _common.pick_key(chip, reversed(check_keys), step=step, index=index)
-    if not value:
+    if not check_value(value):
         value = default_value
 
-    if value:
+    has_value = check_value(value)
+
+    if has_value:
         chip.set('tool', tool, 'task', task, 'var', param_key, value,
                  step=step, index=index, clobber=False)
 
@@ -115,7 +122,7 @@ def set_tool_task_var(chip,
                      ','.join(require_key),
                      step=step, index=index)
 
-    if value or 'key' in require:
+    if has_value or 'key' in require:
         chip.add('tool', tool, 'task', task, 'require',
                  ','.join(['tool', tool, 'task', task, 'var', param_key]),
                  step=step, index=index)

siliconcompiler/tools/builtin/concatenate.py

@@ -15,7 +15,7 @@ def make_docs(chip):
     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', 'step', 'import.combine')
     chip.set('arg', 'index', '0')
     setup(chip)
 

siliconcompiler/tools/openroad/__init__.py

@@ -0,0 +1,103 @@
+'''
+OpenROAD is an automated physical design platform for
+integrated circuit design with a complete set of features
+needed to translate a synthesized netlist to a tapeout ready
+GDSII.
+
+Documentation: https://openroad.readthedocs.io/
+
+Sources: https://github.com/The-OpenROAD-Project/OpenROAD
+
+Installation: https://github.com/The-OpenROAD-Project/OpenROAD
+'''
+from siliconcompiler.tools._common import get_tool_task
+from siliconcompiler.targets import asap7_demo
+
+
+####################################################################
+# Make Docs
+####################################################################
+def make_docs(chip):
+    chip.use(asap7_demo)
+
+
+################################
+# Setup Tool (pre executable)
+################################
+def setup(chip, exit=True, clobber=False):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    chip.set('tool', tool, 'exe', 'openroad')
+    chip.set('tool', tool, 'vswitch', '-version')
+    chip.set('tool', tool, 'version', '>=v2.0-17598', clobber=clobber)
+    chip.set('tool', tool, 'format', 'tcl', clobber=clobber)
+
+    option = [
+        "-no_init",
+        "-metrics", "reports/metrics.json"
+    ]
+
+    # exit automatically in batch mode and not breakpoint
+    if exit and \
+       not chip.get('option', 'breakpoint', step=step, index=index):
+        option.append("-exit")
+
+    chip.set('tool', tool, 'task', task, 'option', option,
+             step=step, index=index, clobber=clobber)
+
+    chip.set('tool', tool, 'task', task, 'refdir',
+             'tools/openroad/scripts',
+             step=step, index=index, package='siliconcompiler')
+
+    # basic warning and error grep check on logfile
+    chip.set('tool', tool, 'task', task, 'regex', 'warnings',
+             r'^\[WARNING|Warning',
+             step=step, index=index, clobber=clobber)
+    chip.set('tool', tool, 'task', task, 'regex', 'errors',
+             r'^\[ERROR',
+             step=step, index=index, clobber=clobber)
+
+    chip.set('tool', tool, 'task', task, 'var', 'debug_level',
+             'list of "tool key level" to enable debugging of OpenROAD',
+             field='help')
+
+    if chip.get('option', 'nodisplay'):
+        # Tells QT to use the offscreen platform if nodisplay is used
+        chip.set('tool', tool, 'task', task, 'env',
+                 'QT_QPA_PLATFORM', 'offscreen',
+                 step=step, index=index)
+
+
+################################
+# Version Check
+################################
+def parse_version(stdout):
+    # stdout will be in one of the following forms:
+    # - 1 08de3b46c71e329a10aa4e753dcfeba2ddf54ddd
+    # - 1 v2.0-880-gd1c7001ad
+    # - v2.0-1862-g0d785bd84
+
+    # strip off the "1" prefix if it's there
+    version = stdout.split()[-1]
+
+    pieces = version.split('-')
+    if len(pieces) > 1:
+        # strip off the hash in the new version style
+        return '-'.join(pieces[:-1])
+    else:
+        return pieces[0]
+
+
+def normalize_version(version):
+    if '.' in version:
+        return version.lstrip('v')
+    else:
+        return '0'
+
+
+##################################################
+if __name__ == "__main__":
+    chip = make_docs()
+    chip.write_manifest("openroad.json")