siliconcompiler 0.29.0__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.29.0'
+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/utils/replay.py

@@ -1,9 +1,18 @@
 # 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
@@ -11,6 +20,26 @@ 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"
@@ -25,9 +54,10 @@ def main():
 
     # Read command-line inputs and generate Chip objects to run the flow on.
     try:
-        generation_arg = {
-            'metavar': '<path>',
-            'help': '(optional) Path to generate replay files to, if specified.',
+        file_arg = {
+            'metavar': '<file>',
+            'help': 'Path to generate replay file to.',
+            'default': 'replay.sh',
             'sc_print': True
         }
         args = chip.create_cmdline(
@@ -37,7 +67,7 @@ def main():
                         '-jobname',
                         '-loglevel'],
             additional_args={
-                '-path': generation_arg
+                '-file': file_arg
             })
     except SiliconCompilerError:
         return 1
@@ -93,40 +123,68 @@ def main():
     for tool, version in tools.items():
         print(f"  {os.path.basename(tool):<{tool_len}}: {', '.join(version)}")
 
-    if 'path' in args and args['path']:
-        path = args['path']
-        os.makedirs(path, exist_ok=True)
-        with open(os.path.join(path, 'requirements.txt'), 'w', encoding='utf-8') as wf:
-            wf.write(utils.get_file_template('replay/requirements.txt').render(
-                design=chip.design,
-                source=', '.join(chip.find_files('option', 'cfg')),
-                jobname=jobname,
-                pkgs=pythonpackages
-            ))
-
-        scripts = []
-        scripts.append(os.path.join(path, 'setup.sh'))
-        with open(scripts[-1], 'w', encoding='utf-8') as wf:
-            wf.write(utils.get_file_template('replay/setup.sh').render(
-                design=chip.design,
-                source=', '.join(chip.find_files('option', 'cfg')),
-                jobname=jobname,
-                pythonversion=pythonversion
-            ))
-
-        scripts.append(os.path.join(path, 'run.py'))
-        with open(scripts[-1], 'w', encoding='utf-8') as wf:
-            wf.write(utils.get_file_template('replay/run.py.j2').render(
-                design=chip.design,
-                source=', '.join(chip.find_files('option', 'cfg')),
-                cfgs=chip.find_files('option', 'cfg'),
-                jobname=jobname,
-                tool_versions=sorted(tool_versions)
-            ))
-
-        for script in scripts:
-            permissions = stat.S_IMODE(os.lstat(script).st_mode)
-            os.chmod(script, permissions | stat.S_IXUSR)
+    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
 

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):
@@ -2384,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'
@@ -2402,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:
@@ -2414,6 +2474,9 @@ class Chip:
         if verbose:
             self.logger.info('Collecting input sources')
 
+        if not exclude_packages:
+            exclude_packages = []
+
         dirs = {}
         files = {}
 
@@ -2453,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:

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/showflow.py

@@ -1,12 +1,12 @@
 import siliconcompiler
 from siliconcompiler import SiliconCompilerError
-from siliconcompiler.targets import freepdk45_demo
 
 
 ############################################################################
 # DOCS
 ############################################################################
 def make_docs(chip):
+    from siliconcompiler.targets import freepdk45_demo
     chip.use(freepdk45_demo)
     return setup(filetype='gds', showtools=chip._showtools, np=3)
 

siliconcompiler/libs/__init__.py

@@ -0,0 +1,5 @@
+def get_libs():
+    '''
+    Returns a dict of builtin libraries
+    '''
+    return {}

siliconcompiler/optimizer/__init__.py

@@ -0,0 +1,199 @@
+class Optimizer:
+    def __init__(self, chip):
+        self._chip = chip
+
+        self._parameters = {}
+        self._goals = {}
+        self._assertions = {}
+
+        self.__results = []
+
+    def __generate_print_name(self, key, step, index):
+        name = f'[{",".join(key)}]'
+
+        node_name = None
+        if step is not None:
+            node_name = step
+
+            if index is not None:
+                node_name += f'{index}'
+
+        if node_name:
+            name += f' ({node_name})'
+
+        return name
+
+    def __generate_param_name(self, key, step, index):
+        name = ",".join(key)
+
+        if step is not None:
+            name += f'-step-{step}'
+
+        if index is not None:
+            name += f'-index-{index}'
+
+        return name
+
+    def add_parameter(self, key, values, value_type=None, step=None, index=None):
+        if value_type is None:
+            value_type = self._chip.get(*key, field='type')
+            if value_type.startswith('['):
+                value_type = value_type[1:-1]
+            elif value_type.startswith('('):
+                value_type = value_type[1:-1].split(",")
+                value_type = [value.strip() for value in value_type]
+                if not all([value == value_type[0] for value in value_type]):
+                    raise ValueError("Cannot support unequal tuples")
+                value_type = value_type[0]
+
+        if value_type not in ('float', 'int', 'bool', 'enum', 'str'):
+            raise ValueError(f"{value_type} is not supported")
+
+        if value_type in ('float', 'int'):
+            if 'max' not in values:
+                raise ValueError("value must have a max key")
+            if 'min' not in values:
+                raise ValueError("value must have a min key")
+            values = [values["min"], values["max"]]
+        elif value_type in ('enum', 'str', 'bool'):
+            if not isinstance(values, (tuple, list, set)):
+                raise ValueError("value must be a list")
+            if value_type == 'str':
+                value_type = 'enum'
+
+        if value_type == 'bool' and not values:
+            values = [True, False]
+
+        self._parameters["param-" + self.__generate_param_name(key, step, index)] = {
+            "print": self.__generate_print_name(key, step, index),
+            "key": tuple(key),
+            "type": value_type,
+            "values": tuple(values),
+            "step": step,
+            "index": index
+        }
+
+    def _set_parameter(self, parameter, value, chip, flow_prefix=None):
+        param_entry = self._parameters[parameter]
+
+        self._chip.logger.info(f'  Setting {param_entry["print"]} = {value}')
+        if param_entry["step"]:
+            if not flow_prefix:
+                flow_prefix = ""
+            step = f'{flow_prefix}{param_entry["step"]}'
+        else:
+            step = param_entry["step"]
+
+        key_type = chip.get(*param_entry["key"], field='type')
+        if key_type[0] == "(":
+            key_type = key_type[1:-1].split(",")
+            value = len(key_type) * [value]
+
+        chip.set(
+            *param_entry["key"],
+            value,
+            step=step,
+            index=param_entry["index"])
+
+    def add_assertion(self, key, criteria, step=None, index=None):
+        if not callable(criteria):
+            raise ValueError('criteria must be a function')
+
+        if not step:
+            raise ValueError('step is required')
+
+        if not index:
+            raise ValueError('index is required')
+
+        self._assertions["assert-" + self.__generate_param_name(key, step, index)] = {
+            "print": self.__generate_print_name(key, step, index),
+            "key": tuple(key),
+            "criteria": criteria,
+            "step": step,
+            "index": index
+        }
+
+    def _check_assertions(self, chip, step_prefix):
+        if not step_prefix:
+            step_prefix = ""
+
+        for info in self._assertions.values():
+            value = chip.get(
+                *info["key"],
+                step=f'{step_prefix}{info["step"]}',
+                index=info["index"])
+            if not info["criteria"](value):
+                self._chip.logger.error(f"Failed to meet assertion: {info['print']} with {value}")
+                return False
+
+        return True
+
+    def add_goal(self, key, goal, stop_goal=None, step=None, index=None):
+        if goal not in ('min', 'max'):
+            raise ValueError(f"{goal} is not supported")
+
+        if not step:
+            raise ValueError('step is required')
+
+        if not index:
+            raise ValueError('index is required')
+
+        self._goals["goal-" + self.__generate_param_name(key, step, index)] = {
+            "print": self.__generate_print_name(key, step, index),
+            "key": tuple(key),
+            "goal": goal,
+            "stop": stop_goal,
+            "step": step,
+            "index": index
+        }
+
+    def _check_stop_goal(self, measurements):
+        cont = []
+
+        for param, info in self._goals.items():
+            if info["stop"] is None:
+                continue
+
+            if param not in measurements:
+                cont.append(False)
+                continue
+
+            if info["goal"] == "min":
+                if measurements[param] <= info["stop"]:
+                    cont.append(True)
+            elif info["goal"] == "max":
+                if measurements[param] >= info["stop"]:
+                    cont.append(True)
+
+        if not cont:
+            return False
+
+        return all(cont)
+
+    def run(self, experiments=None, parallel=None):
+        raise NotImplementedError
+
+    def _clear_results(self):
+        self.__results.clear()
+
+    def _add_result(self, parameters, measurements):
+        self.__results.append({
+            "parameters": parameters,
+            "measurements": measurements
+        })
+
+    def report(self, count=None):
+        for n, result in enumerate(self.__results):
+            if count and n >= count:
+                return
+
+            self._chip.logger.info(f"Result {n+1} / {len(self.__results)}:")
+            self._chip.logger.info("  Parameters:")
+            for param_name, param_key in result["parameters"].items():
+                param_print = self._parameters[param_name]['print']
+                self._chip.logger.info(f"    {param_print} = {param_key}")
+
+            self._chip.logger.info("  Measurements:")
+            for meas_name, meas_key in result["measurements"].metrics.items():
+                goal_print = self._goals[meas_name]['print']
+                self._chip.logger.info(f"    {goal_print} = {meas_key.value}")