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

siliconcompiler/_metadata.py

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

siliconcompiler/apps/__init__.py

@@ -0,0 +1,26 @@
+from siliconcompiler.apps import sc_dashboard
+from siliconcompiler.apps import sc_install
+from siliconcompiler.apps import sc_issue
+from siliconcompiler.apps import sc_remote
+from siliconcompiler.apps import sc_server
+from siliconcompiler.apps import sc_show
+from siliconcompiler.apps import sc
+from siliconcompiler.apps import smake
+
+
+def get_apps():
+    '''
+    Returns a dict of builtin apps
+    '''
+    return {
+        module.__name__.split(".")[-1]: module for module in (
+            sc_dashboard,
+            sc_install,
+            sc_issue,
+            sc_remote,
+            sc_server,
+            sc_show,
+            sc,
+            smake
+        )
+    }

siliconcompiler/apps/sc_remote.py

@@ -5,9 +5,7 @@ import sys
 
 from siliconcompiler import Chip
 from siliconcompiler import SiliconCompilerError
-from siliconcompiler.remote.client import cancel_job, check_progress, delete_job, \
-    remote_ping, remote_run_loop, _remote_ping
-from siliconcompiler.remote.client import configure_server, configure_whitelist, configure_print
+from siliconcompiler.remote.client import Client, ConfigureClient
 from siliconcompiler.scheduler import _finalize_run
 from siliconcompiler.flowgraph import _get_flowgraph_entry_nodes, _get_flowgraph_node_outputs, \
     nodes_to_execute
@@ -108,29 +106,33 @@ To delete a job, use:
 
     if args['configure']:
         if args['list']:
-            configure_print(chip)
+            client = Client(chip)
+            client.print_configuration()
             return 0
 
         if not args['add'] and not args['remove']:
             try:
-                configure_server(chip, server=args['server'])
+                client = ConfigureClient(chip)
+                client.configure_server(server=args['server'])
             except ValueError as e:
                 chip.logger.error(e)
                 return 1
         else:
             try:
-                configure_whitelist(chip, add=args['add'], remove=args['remove'])
+                client = ConfigureClient(chip)
+                client.configure_whitelist(add=args['add'], remove=args['remove'])
             except ValueError as e:
                 chip.logger.error(e)
                 return 1
 
         return 0
 
+    client = Client(chip)
     # Main logic.
     # If no job-related options are specified, fetch and report basic info.
     # Create temporary Chip object and check on the server.
     try:
-        remote_ping(chip)
+        client.check()
     except SiliconCompilerError as e:
         chip.logger.error(f'{e}')
         return 1
@@ -138,7 +140,7 @@ To delete a job, use:
     # If the -cancel flag is specified, cancel the job.
     if args['cancel']:
         try:
-            cancel_job(chip)
+            client.cancel_job()
         except SiliconCompilerError as e:
             chip.logger.error(f'{e}')
             return 1
@@ -146,7 +148,7 @@ To delete a job, use:
     # If the -delete flag is specified, delete the job.
     elif args['delete']:
         try:
-            delete_job(chip)
+            client.delete_job()
         except SiliconCompilerError as e:
             chip.logger.error(f'{e}')
             return 1
@@ -162,10 +164,8 @@ To delete a job, use:
             outputs = _get_flowgraph_node_outputs(chip, flow, entry_node)
             chip.set('option', 'from', list(map(lambda node: node[0], outputs)))
         # Enter the remote run loop.
-        chip._init_logger(step='remote', index='0', in_run=True)
         try:
-            rsp = _remote_ping(chip)
-            remote_run_loop(chip, rsp['progress_interval'])
+            client._run_loop()
         except SiliconCompilerError as e:
             chip.logger.error(f'{e}')
             return 1
@@ -185,8 +185,9 @@ To delete a job, use:
     # If only a manifest is specified, make a 'check_progress/' request and report results:
     elif chip_cfg:
         try:
-            check_progress(chip, [], {})
-        except SiliconCompilerError as e:
+            info = client.check_job_status()
+            client._report_job_status(info)
+        except Exception as e:
             chip.logger.error(f'{e}')
             return 1
 

siliconcompiler/apps/sc_show.py

@@ -19,10 +19,10 @@ def main():
     Examples:
 
     sc-show
-    (displays build/adder/job0/write_gds/0/outputs/adder.gds)
+    (displays build/adder/job0/write.gds/0/outputs/adder.gds)
 
     sc-show -design adder
-    (displays build/adder/job0/write_gds/0/outputs/adder.gds)
+    (displays build/adder/job0/write.gds/0/outputs/adder.gds)
 
     sc-show -design adder -arg_step floorplan
     (displays build/adder/job0/floorplan/0/outputs/adder.def)
@@ -31,13 +31,13 @@ def main():
     (displays build/adder/job0/place/1/outputs/adder.def)
 
     sc-show -design adder -jobname rtl2gds
-    (displays build/adder/rtl2gds/write_gds/0/outputs/adder.gds)
+    (displays build/adder/rtl2gds/write.gds/0/outputs/adder.gds)
 
     sc-show -cfg build/adder/rtl2gds/adder.pkg.json
-    (displays build/adder/rtl2gds/write_gds/0/outputs/adder.gds)
+    (displays build/adder/rtl2gds/write.gds/0/outputs/adder.gds)
 
     sc-show -design adder -ext odb
-    (displays build/adder/job0/write_data/0/outputs/adder.odb)
+    (displays build/adder/job0/write.views/0/outputs/adder.odb)
 
     sc-show build/adder/job0/route/1/outputs/adder.def
     (displays build/adder/job0/route/1/outputs/adder.def)

siliconcompiler/apps/utils/replay.py

@@ -0,0 +1,194 @@
+# Copyright 2024 Silicon Compiler Authors. All Rights Reserved.
+
+# Standard Modules
+import base64
+import io
+import json
+import gzip
+import os
+import stat
+import sys
+import tarfile
+import tempfile
+import textwrap
+
+from datetime import datetime
+
+import siliconcompiler
+from siliconcompiler.apps._common import UNSET_DESIGN
+from siliconcompiler import SiliconCompilerError
+from siliconcompiler import utils
+
+
+def make_bytes(data):
+    if isinstance(data, bytes):
+        return data
+    return data.encode('utf-8')
+
+
+def compress(data):
+    return gzip.compress(make_bytes(data))
+
+
+def convert_base64(data):
+    return base64.b64encode(make_bytes(data))
+
+
+def wrap_text(data):
+    if isinstance(data, bytes):
+        data = data.decode('utf-8')
+    return textwrap.wrap(data)
+
+
+###########################
+def main():
+    progname = "summarize"
+    description = """
+    ------------------------------------------------------------
+    Utility script to print job record information from a manifest
+    needed to replay that manifest.
+    ------------------------------------------------------------
+    """
+    # Create a base chip class.
+    chip = siliconcompiler.Chip(UNSET_DESIGN)
+
+    # Read command-line inputs and generate Chip objects to run the flow on.
+    try:
+        file_arg = {
+            'metavar': '<file>',
+            'help': 'Path to generate replay file to.',
+            'default': 'replay.sh',
+            'sc_print': True
+        }
+        args = chip.create_cmdline(
+            progname,
+            description=description,
+            switchlist=['-cfg',
+                        '-jobname',
+                        '-loglevel'],
+            additional_args={
+                '-file': file_arg
+            })
+    except SiliconCompilerError:
+        return 1
+    except Exception as e:
+        chip.logger.error(e)
+        return 1
+
+    design = chip.get('design')
+    if design == UNSET_DESIGN:
+        chip.logger.error('Design not loaded')
+        return 1
+
+    # Print Job Summary
+    jobname = chip.get('option', 'jobname')
+    pythonpackages = chip.get('record', 'pythonpackage', job=jobname)
+
+    pythonversion = set()
+    nodes = set()
+    for version, step, index in chip.schema._getvals('history', jobname, 'record', 'pythonversion'):
+        pythonversion.add(version)
+        nodes.add((step, index))
+
+    if len(pythonversion) > 1:
+        chip.logger.warning(f"More than one python version detected: {', '.join(pythonversion)}")
+    pythonversion = list(pythonversion)[0]
+
+    tools = {}
+    tool_versions = []
+    for step, index in nodes:
+        toolpath = chip.get('record', 'toolpath', job=jobname, step=step, index=index)
+        toolversion = chip.get('record', 'toolversion', job=jobname, step=step, index=index)
+
+        if toolpath is None:
+            continue
+
+        tools.setdefault(toolpath, set()).add(toolversion)
+        if toolversion:
+            tool = chip.get('flowgraph', chip.get('option', 'flow'), step, index, 'tool')
+            tool_versions.append(
+                ((step, index), tool, toolversion)
+            )
+
+    print("SUMMARY       :")
+    print(f"design        : {chip.design}")
+    print(f"pythonversion : {pythonversion}")
+
+    print("Python packages requires:")
+    for pkg in sorted(pythonpackages):
+        print(f"  {pkg}")
+
+    print("Tool requirements:")
+    tool_len = max([len(os.path.basename(tool)) for tool, _ in tools.items()])
+    for tool, version in tools.items():
+        print(f"  {os.path.basename(tool):<{tool_len}}: {', '.join(version)}")
+
+    path = os.path.abspath(args['file'])
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+
+    starttimes = set()
+    for starttime, step, index in chip.schema._getvals('history', jobname, 'record', 'starttime'):
+        starttimes.add(datetime.strptime(starttime, '%Y-%m-%d %H:%M:%S'))
+    starttime = min(starttimes).strftime('%Y-%m-%d %H:%M:%S')
+
+    with io.StringIO() as fd:
+        fd.write(utils.get_file_template('replay/requirements.txt').render(
+            design=chip.design,
+            jobname=jobname,
+            date=starttime,
+            pkgs=pythonpackages
+        ))
+        fd.flush()
+        requirements_file = fd.getvalue()
+
+    with tempfile.TemporaryDirectory() as collect:
+        chip.collect(directory=collect, verbose=True, exclude_packages=['siliconcompiler'])
+
+        with io.BytesIO() as fd:
+            with tarfile.open(fileobj=fd, mode='w:gz') as tar:
+                tar.add(collect, arcname='')
+
+            fd.flush()
+            collect_files = convert_base64(fd.getvalue())
+
+    with io.StringIO() as fd:
+        fd.write(utils.get_file_template('replay/replay.py.j2').render(
+            design=chip.design,
+            jobname=jobname,
+            date=starttime,
+            src_file=wrap_text(collect_files),
+            tool_versions=sorted(tool_versions)
+        ))
+        fd.flush()
+        script = convert_base64(compress(fd.getvalue()))
+
+    manifest = convert_base64(compress(json.dumps(chip.schema.cfg, indent=2)))
+
+    tool_info = []
+    for tool, version in tools.items():
+        tool_info.append(f"{os.path.basename(tool):<{tool_len}}: {', '.join(version)}")
+
+    description = f"Replay for {chip.design} / {jobname}\nRun on: {starttime}"
+
+    with open(path, 'w', encoding='utf-8') as wf:
+        wf.write(utils.get_file_template('replay/setup.sh').render(
+            design=chip.design,
+            jobname=jobname,
+            date=starttime,
+            description=description,
+            pythonversion=pythonversion,
+            requirements=requirements_file.splitlines(),
+            script=wrap_text(script),
+            manifest=wrap_text(manifest),
+            tools=tool_info
+        ))
+
+    permissions = stat.S_IMODE(os.lstat(path).st_mode)
+    os.chmod(path, permissions | stat.S_IXUSR)
+
+    return 0
+
+
+#########################
+if __name__ == "__main__":
+    sys.exit(main())

siliconcompiler/checklists/__init__.py

@@ -0,0 +1,12 @@
+from siliconcompiler.checklists import oh_tapeout
+
+
+def get_checklists():
+    '''
+    Returns a dict of builtin checklists
+    '''
+    return {
+        module.__name__.split(".")[-1]: module for module in (
+            oh_tapeout,
+        )
+    }

siliconcompiler/core.py

@@ -255,8 +255,13 @@ class Chip:
             log_format.append(f'{utils.truncate_text(step, max_step_len): <{max_step_len}}')
             log_format.append(f'{utils.truncate_text(index, max_step_len): >{max_index_len}}')
 
+        log_formatprefix = "| "
+        if loglevel == "quiet":
+            log_format = []
+            log_formatprefix = ""
+
         log_format.append('%(message)s')
-        logformat = '| ' + ' | '.join(log_format)
+        logformat = log_formatprefix + ' | '.join(log_format)
 
         if not self.logger.hasHandlers():
             stream_handler = logging.StreamHandler(stream=sys.stdout)
@@ -402,19 +407,24 @@ class Chip:
             if extra_params is not None and "target" in extra_params:
                 if extra_params["target"]:
                     # running target command
-                    # Search order "{name}", and "siliconcompiler.targets.{name}"
+                    # Search order target plugins -> "{name}"
                     modules = []
                     module = extra_params["target"]
-                    for mod_name in [module, f'siliconcompiler.targets.{module}']:
-                        mod = self._load_module(mod_name)
-                        if mod:
-                            modules.append(mod)
+                    for plugin in utils.get_plugins('target'):
+                        plugin_targets = plugin()
+                        if module in plugin_targets:
+                            modules.append(plugin_targets[module])
+
+                    mod = self._load_module(module)
+                    if mod:
+                        modules.append(mod)
 
                     if len(modules) == 0:
                         raise SiliconCompilerError(f'Could not find target {module}', chip=self)
 
-                    self.use(modules[0])
-                    extra_params["target"] = modules[0].__name__
+                    target = modules[0]
+                    self.use(target)
+                    extra_params["target"] = target.__name__
 
             if extra_params is not None and "use" in extra_params:
                 if extra_params["use"]:
@@ -975,7 +985,7 @@ class Chip:
         self.logger.debug(f'Setting {keypath} to {value}')
 
         # Special case to ensure loglevel is updated ASAP
-        if keypath == ['option', 'loglevel'] and field == 'value' and \
+        if tuple(keypath) == ('option', 'loglevel') and field == 'value' and \
            step == self.get('arg', 'step') and index == self.get('arg', 'index'):
             self.logger.setLevel(schema_utils.translate_loglevel(value))
 
@@ -1074,6 +1084,54 @@ class Chip:
         except (ValueError, TypeError) as e:
             self.error(str(e))
 
+    def import_flist(self, filename, package=None):
+        '''
+        Add input files, include directories, and defines from an flist
+
+        Args:
+            filename (path): Path to flist file
+            package (str): name of package
+        '''
+
+        if package:
+            filename = os.path.join(sc_package.path(self, package), filename)
+
+        if not os.path.isfile(filename):
+            raise FileNotFoundError(filename)
+
+        package_name = f'flist-{os.path.basename(filename)}'
+        package_dir = os.path.dirname(os.path.abspath(filename))
+
+        def __make_path(rel, path):
+            path = utils._resolve_env_vars(self, path)
+            if os.path.isabs(path):
+                if path.startswith(rel):
+                    return os.path.relpath(path, rel), package_name
+                else:
+                    return path, None
+            return path, package_name
+
+        self.register_source(
+            package_name,
+            path=package_dir)
+        with utils.sc_open(filename) as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                if line.startswith("//"):
+                    continue
+                if line.startswith("+incdir+"):
+                    line = line[8:]
+                    path, package = __make_path(package_dir, line)
+                    self.add('option', 'idir', path, package=package)
+                elif line.startswith("+define+"):
+                    line = line[8:]
+                    self.add('option', 'define', line)
+                else:
+                    path, package = __make_path(package_dir, line)
+                    self.input(path, package=package)
+
     ###########################################################################
     def input(self, filename, fileset=None, filetype=None, iomap=None,
               step=None, index=None, package=None):
@@ -2058,19 +2116,11 @@ class Chip:
         dot.attr(bgcolor=background)
 
         subgraphs = {
-            "graphs": {
-                "sc-inputs": {
-                    "graphs": {},
-                    "nodes": []
-                }
-            },
+            "graphs": {},
             "nodes": []
         }
         for node, info in nodes.items():
-            if info['is_input']:
-                subgraph_temp = subgraphs["graphs"]["sc-inputs"]
-            else:
-                subgraph_temp = subgraphs
+            subgraph_temp = subgraphs
 
             for key in node.split(".")[0:-1]:
                 if key not in subgraph_temp["graphs"]:
@@ -2079,6 +2129,15 @@ class Chip:
                         "nodes": []
                     }
                 subgraph_temp = subgraph_temp["graphs"][key]
+
+            if info['is_input']:
+                if "sc-inputs" not in subgraph_temp["graphs"]:
+                    subgraph_temp["graphs"]["sc-inputs"] = {
+                        "graphs": {},
+                        "nodes": []
+                    }
+                subgraph_temp = subgraph_temp["graphs"]["sc-inputs"]
+
             subgraph_temp["nodes"].append(node)
 
         with dot.subgraph(name='inputs') as input_graph:
@@ -2131,7 +2190,8 @@ class Chip:
             for subgraph in graph_info["graphs"]:
                 child_prefix = prefix
                 if get_node_count(graph_info["graphs"][subgraph]) > 1:
-                    child_prefix = f"{child_prefix}{subgraph}."
+                    if subgraph != "sc-inputs":
+                        child_prefix = f"{child_prefix}{subgraph}."
                     graph = graphviz.Digraph(name=f"cluster_{graph_idx}")
                     graph_idx += 1
 
@@ -2382,7 +2442,7 @@ class Chip:
             swap('library', lib, 'option', 'library')
 
     ########################################################################
-    def collect(self, directory=None, verbose=True, whitelist=None):
+    def collect(self, directory=None, verbose=True, whitelist=None, exclude_packages=None):
         '''
         Collects files found in the configuration dictionary and places
         them in inputs/. The function only copies in files that have the 'copy'
@@ -2400,6 +2460,8 @@ class Chip:
             whitelist (list[path]): List of directories that are allowed to be
                 collected. If a directory is is found that is not on this list
                 a RuntimeError will be raised.
+            package_filter (list[str]): List of packages to exclude from
+                collection.
         '''
 
         if not directory:
@@ -2412,6 +2474,9 @@ class Chip:
         if verbose:
             self.logger.info('Collecting input sources')
 
+        if not exclude_packages:
+            exclude_packages = []
+
         dirs = {}
         files = {}
 
@@ -2451,6 +2516,8 @@ class Chip:
                             if not package:
                                 # Ensure package is an empty string
                                 package = ''
+                            if package in exclude_packages:
+                                continue
                             if is_dir:
                                 dirs[(package, path)] = abspath
                             else:
@@ -3126,7 +3193,7 @@ class Chip:
             extension (str): extension of file to show
 
         Examples:
-            >>> show('build/oh_add/job0/write_gds/0/outputs/oh_add.gds')
+            >>> show('build/oh_add/job0/write.gds/0/outputs/oh_add.gds')
             Displays gds file with a viewer assigned by showtool
         '''
 

siliconcompiler/flows/__init__.py

@@ -0,0 +1,34 @@
+from siliconcompiler.flows import asicflow
+from siliconcompiler.flows import asictopflow
+from siliconcompiler.flows import drcflow
+from siliconcompiler.flows import dvflow
+from siliconcompiler.flows import fpgaflow
+from siliconcompiler.flows import generate_openroad_rcx
+from siliconcompiler.flows import interposerflow
+from siliconcompiler.flows import lintflow
+from siliconcompiler.flows import screenshotflow
+from siliconcompiler.flows import showflow
+from siliconcompiler.flows import signoffflow
+from siliconcompiler.flows import synflow
+
+
+def get_flows():
+    '''
+    Returns a dict of builtin flows
+    '''
+    return {
+        module.__name__.split(".")[-1]: module for module in (
+            asicflow,
+            asictopflow,
+            drcflow,
+            dvflow,
+            fpgaflow,
+            generate_openroad_rcx,
+            interposerflow,
+            lintflow,
+            screenshotflow,
+            showflow,
+            signoffflow,
+            synflow
+        )
+    }

siliconcompiler/flows/_common.py

@@ -22,17 +22,17 @@ def _make_docs(chip):
 
 def __get_frontends(allow_system_verilog):
     systemverilog_frontend = [
-        ('import', surelog_parse)
+        ('import.verilog', surelog_parse)
     ]
     if not allow_system_verilog:
-        systemverilog_frontend.append(('convert', sv2v_convert))
+        systemverilog_frontend.append(('import.convert', sv2v_convert))
 
     return {
         "verilog": systemverilog_frontend,
-        "chisel": [('import', chisel_convert)],
-        "c": [('import', bambu_convert)],
-        "bluespec": [('import', bluespec_convert)],
-        "vhdl": [('import', ghdl_convert)]
+        "chisel": [('import.chisel', chisel_convert)],
+        "c": [('import.c', bambu_convert)],
+        "bluespec": [('import.bluespec', bluespec_convert)],
+        "vhdl": [('import.vhdl', ghdl_convert)]
     }
 
 
@@ -45,21 +45,19 @@ def setup_multiple_frontends(flow, allow_system_verilog=False):
 
     concat_nodes = []
     flowname = flow.design
-    for frontend, pipe in __get_frontends(allow_system_verilog).items():
+    for _, pipe in __get_frontends(allow_system_verilog).items():
         prev_step = None
         for step, task in pipe:
-            step_name = f'{step}_{frontend}'
-
-            flow.node(flowname, step_name, task)
+            flow.node(flowname, step, task)
             if prev_step:
-                flow.edge(flowname, prev_step, step_name)
+                flow.edge(flowname, prev_step, step)
 
-            prev_step = step_name
+            prev_step = step
 
         if prev_step:
             concat_nodes.append(prev_step)
 
-    final_node = 'combine'
+    final_node = 'import.combine'
     flow.node(flowname, final_node, concatenate)
     for node in concat_nodes:
         flow.edge(flowname, node, final_node)