siliconcompiler 0.26.5__py3-none-any.whl

siliconcompiler/__init__.py

@@ -0,0 +1,24 @@
+from siliconcompiler._common import NodeStatus, SiliconCompilerError
+
+from siliconcompiler.utils import sc_open
+
+from siliconcompiler.core import Chip
+from siliconcompiler.schema import Schema
+
+from siliconcompiler._metadata import version as __version__
+
+from siliconcompiler.use import PDK, FPGA, Library, Flow, Checklist
+
+__all__ = [
+    "__version__",
+    "Chip",
+    "SiliconCompilerError",
+    "NodeStatus",
+    "PDK",
+    "FPGA",
+    "Library",
+    "Flow",
+    "Checklist",
+    "Schema",
+    "sc_open"
+]

siliconcompiler/__main__.py

@@ -0,0 +1,12 @@
+# Copyright 2020 Silicon Compiler Authors. All Rights Reserved.
+
+
+from siliconcompiler.apps import sc
+
+
+def main():
+    sc.main()
+
+
+if __name__ == '__main__':
+    main()

siliconcompiler/_common.py

@@ -0,0 +1,49 @@
+class NodeStatus():
+    # node waiting to run
+    PENDING = 'pending'
+
+    # node ready to run and waiting
+    QUEUED = 'queued'
+
+    # node running
+    RUNNING = 'running'
+
+    # node exit status
+    SUCCESS = 'success'
+    ERROR = 'error'
+    SKIPPED = 'skipped'
+    TIMEOUT = 'timeout'
+
+    def is_done(status):
+        return status in (
+            NodeStatus.SUCCESS,
+            NodeStatus.ERROR,
+            NodeStatus.SKIPPED,
+            NodeStatus.TIMEOUT
+        )
+
+    def is_running(status):
+        return status in (
+            NodeStatus.QUEUED,
+            NodeStatus.RUNNING
+        )
+
+    def is_waiting(status):
+        return status in (
+            NodeStatus.PENDING,
+        )
+
+
+###############################################################################
+# Package Customization classes
+###############################################################################
+class SiliconCompilerError(Exception):
+    ''' Minimal Exception wrapper used to raise sc runtime errors.
+    '''
+    def __init__(self, message, chip=None):
+        super(Exception, self).__init__(message)
+
+        if chip:
+            logger = getattr(chip, 'logger', None)
+            if logger:
+                logger.error(message)

siliconcompiler/_metadata.py

@@ -0,0 +1,36 @@
+# Version number following semver standard.
+version = '0.26.5'
+
+# Default server address for remote runs, if unspecified.
+default_server = 'https://server.siliconcompiler.com'
+
+# This is the list of significant contributors to SiliconCompiler in
+# chronological order.
+#
+# This does not necessarily list everyone who has contributed code,
+# especially since many employees of one corporation may be contributing.
+# To see the full list of contributors, see the git revision history
+authors = [
+    'Andreas Olofsson',
+    'William Ransohoff',
+    'Noah Moroze',
+    'Zachary Yedidia',
+    'Massimiliano Giacometti',
+    'Kimia Talaei',
+    'Peter Gadfort',
+    'Aulihan Teng',
+    'Peter Grossmann',
+    'Gabriel Aguirre',
+    'Martin Troiber'
+]
+
+# CLI entry banner autogenerated using pyfiglet.
+# >> pyfiglet.figlet_format("Silicon Compiler")
+banner = r'''
+ ____  _ _ _                    ____                      _ _
+/ ___|(_) (_) ___ ___  _ __    / ___|___  _ __ ___  _ __ (_) | ___ _ __
+\___ \| | | |/ __/ _ \| '_ \  | |   / _ \| '_ ` _ \| '_ \| | |/ _ \ '__|
+ ___) | | | | (_| (_) | | | | | |__| (_) | | | | | | |_) | | |  __/ |
+|____/|_|_|_|\___\___/|_| |_|  \____\___/|_| |_| |_| .__/|_|_|\___|_|
+                                                   |_|
+'''

siliconcompiler/apps/_common.py

@@ -0,0 +1,76 @@
+import glob
+import os
+
+
+def manifest_switches():
+    '''
+    Returns a list of manifest switches that can be used
+    to find the manifest based on their values
+    '''
+    return ['-design',
+            '-cfg',
+            '-arg_step',
+            '-arg_index',
+            '-jobname']
+
+
+def load_manifest(chip, src_file):
+    manifest = None
+    if (src_file is not None) and (not chip.get('option', 'cfg')):
+        if not os.path.exists(src_file):
+            chip.logger.error(f'{src_file} cannot be found.')
+            return False
+        # only autoload manifest if user doesn't supply manually
+        manifest = _get_manifest(os.path.dirname(src_file))
+        if not manifest:
+            design = os.path.splitext(os.path.basename(src_file))[0]
+            chip.logger.error(f'Unable to automatically find manifest for design {design}. '
+                              'Please provide a manifest explicitly using -cfg.')
+            return False
+    elif not chip.get('option', 'cfg'):
+        manifest = _get_manifest_from_design(chip)
+        if not manifest:
+            chip.logger.error(f'Could not find manifest for {chip.design}')
+            return False
+
+    if manifest:
+        chip.logger.info(f'Loading manifest: {manifest}')
+        chip.read_manifest(manifest)
+    return True
+
+
+def _get_manifest(dirname, design='*'):
+    # pkg.json file may have a different name from the design due to the entrypoint
+    glob_paths = [os.path.join(dirname, f'{design}.pkg.json'),
+                  os.path.join(dirname, 'outputs', f'{design}.pkg.json')]
+    manifest = None
+    for path in glob_paths:
+        manifest = glob.glob(path)
+        if manifest:
+            manifest = manifest[0]
+            break
+
+    if not manifest or not os.path.isfile(manifest):
+        return None
+    return manifest
+
+
+def _get_manifest_from_design(chip):
+    for jobname, step, index in [
+            (chip.get('option', 'jobname'),
+             chip.get('arg', 'step'),
+             chip.get('arg', 'index')),
+            (chip.get('option', 'jobname'),
+             None,
+             None),
+            (chip.schema.get_default('option', 'jobname'),
+             chip.get('arg', 'step'),
+             chip.get('arg', 'index')),
+            (chip.schema.get_default('option', 'jobname'),
+             None,
+             None)]:
+        manifest = _get_manifest(chip.getworkdir(jobname=jobname, step=step, index=index))
+
+        if manifest:
+            return manifest
+    return None

siliconcompiler/apps/sc.py

@@ -0,0 +1,92 @@
+# Copyright 2020 Silicon Compiler Authors. All Rights Reserved.
+
+# Standard Modules
+import os
+import sys
+
+import siliconcompiler
+from siliconcompiler.utils import get_default_iomap
+from siliconcompiler.targets import skywater130_demo
+from siliconcompiler import SiliconCompilerError
+
+
+###########################
+def main():
+    progname = "sc"
+    description = """
+    ------------------------------------------------------------
+    SiliconCompiler is an open source compiler framework that
+    aims to enable automated translation from source code to
+    silicon.
+
+    The sc program includes the following steps.
+
+    1. Read command line arguments
+    2. If not set, 'design' is set to base of first source file.
+    3. If not set, 'target' is set to 'skywater130_demo'.
+    4. Run compilation
+    5. Display summary
+
+    Sources: https://github.com/siliconcompiler/siliconcompiler
+    ------------------------------------------------------------
+    """
+    # TODO: this is a hack to get around design name requirement: since legal
+    # design names probably can't contain spaces, we can detect if it is unset.
+    UNSET_DESIGN = '  unset  '
+
+    # Create a base chip class.
+    chip = siliconcompiler.Chip(UNSET_DESIGN)
+
+    # Read command-line inputs and generate Chip objects to run the flow on.
+    try:
+        chip.create_cmdline(progname,
+                            description=description,
+                            input_map=get_default_iomap())
+    except Exception as e:
+        chip.logger.error(e)
+        return 1
+
+    # Set design if none specified
+    if chip.get('design') == UNSET_DESIGN:
+        topfile = None
+        for sourceset in ('rtl', 'hll'):
+            for filetype in chip.getkeys('input', sourceset):
+                all_vals = chip.schema._getvals('input', sourceset, filetype)
+                if all_vals:
+                    # just look at first value
+                    sources, _, _ = all_vals[0]
+                    # grab first source
+                    topfile = sources[0]
+                    break
+            if topfile:
+                break
+
+        if not topfile:
+            chip.logger.error('Invalid arguments: either specify -design or provide sources.')
+            return 1
+
+        topmodule = os.path.splitext(os.path.basename(topfile))[0]
+        chip.set('design', topmodule)
+
+    # Set demo target if none specified
+    if not chip.get('option', 'target'):
+        chip.load_target(skywater130_demo)
+
+    try:
+        # Run flow
+        chip.run()
+
+        # Print Job Summary
+        chip.summary()
+    except SiliconCompilerError:
+        return 1
+    except Exception as e:
+        chip.logger.error(e)
+        return 1
+
+    return 0
+
+
+#########################
+if __name__ == "__main__":
+    sys.exit(main())

siliconcompiler/apps/sc_dashboard.py

@@ -0,0 +1,94 @@
+# Copyright 2023 Silicon Compiler Authors. All Rights Reserved.
+import sys
+import siliconcompiler
+import os
+from siliconcompiler.apps._common import load_manifest, manifest_switches
+
+
+def main():
+    progname = "sc-dashboard"
+    description = """
+-----------------------------------------------------------
+SC app to open a dashboard for a given manifest.
+
+To open:
+    sc-dashboard -cfg <path to manifest>
+
+To specify a different port than the default:
+    sc-dashboard -cfg <path to manifest> -port 10000
+
+To include another chip object to compare to:
+    sc-dashboard -cfg <path to manifest> -graph_cfg <name of manifest> <path to other manifest>
+        -graph_cfg <path to other manifest> ...
+-----------------------------------------------------------
+"""
+
+    # TODO: this is a hack to get around design name requirement: since legal
+    # design names probably can't contain spaces, we can detect if it is unset.
+    UNSET_DESIGN = '  unset  '
+
+    # Create a base chip class.
+    chip = siliconcompiler.Chip(UNSET_DESIGN)
+
+    dashboard_arguments = {
+        "-port": {'type': int,
+                  'help': 'port to open the dashboard app on',
+                  'metavar': '<port>',
+                  'sc_print': False},
+        "-graph_cfg": {'type': str,
+                       'nargs': '+',
+                       'action': 'append',
+                       'help': 'chip name - optional, path to chip manifest (json)',
+                       'metavar': '<[manifest name, manifest path>',
+                       'sc_print': False}
+    }
+
+    try:
+        switches = chip.create_cmdline(
+            progname,
+            switchlist=[*manifest_switches(),
+                        '-loglevel'],
+            description=description,
+            additional_args=dashboard_arguments)
+    except Exception as e:
+        chip.logger.error(e)
+        return 1
+
+    # Error checking
+    design = chip.get('design')
+    if design == UNSET_DESIGN:
+        chip.logger.error('Design not loaded')
+        return 1
+
+    if not load_manifest(chip, None):
+        return 1
+
+    graph_chips = []
+    if switches['graph_cfg']:
+        for i, name_and_file_path in enumerate(switches['graph_cfg']):
+            args = len(name_and_file_path)
+            if args == 0:
+                continue
+            elif args == 1:
+                name = f'cfg{i}'
+                file_path = name_and_file_path[0]
+            elif args == 2:
+                name = name_and_file_path[0]
+                file_path = name_and_file_path[1]
+            else:
+                raise ValueError(('graph_cfg accepts a max of 2 values, you supplied'
+                                  f' {args} in "-graph_cfg {name_and_file_path}"'))
+            if not os.path.isfile(file_path):
+                raise ValueError(f'not a valid file path : {file_path}')
+            graph_chip = siliconcompiler.core.Chip(design='')
+            graph_chip.read_manifest(file_path)
+            graph_chips.append({'chip': graph_chip, 'name': name})
+
+    chip._dashboard(wait=True, port=switches['port'], graph_chips=graph_chips)
+
+    return 0
+
+
+#########################
+if __name__ == "__main__":
+    sys.exit(main())

siliconcompiler/apps/sc_issue.py

@@ -0,0 +1,178 @@
+# Copyright 2023 Silicon Compiler Authors. All Rights Reserved.
+import sys
+import os
+import siliconcompiler
+import tarfile
+import json
+import importlib
+from siliconcompiler.scheduler import _runtask, _executenode
+from siliconcompiler.issue import generate_testcase
+from siliconcompiler.tools._common import get_tool_task
+
+
+def main():
+    progname = "sc-issue"
+    chip = siliconcompiler.Chip(progname)
+    switchlist = ['-cfg',
+                  '-arg_step',
+                  '-arg_index',
+                  '-tool_task_var',
+                  '-tool_task_option',
+                  '-loglevel']
+    description = """
+-----------------------------------------------------------
+Restricted SC app that generates a sharable testcase from a
+failed flow or runs an issue generated with this program.
+
+To generate a testcase, use:
+    sc-issue -cfg <stepdir>/outputs/<design>.pkg.json
+
+    or include a different step/index than what the cfg_file is pointing to:
+    sc-issue -cfg <otherdir>/outputs/<design>.pkg.json -arg_step <step> -arg_index <index>
+
+    or include specific libraries while excluding others:
+    sc-issue -cfg <stepdir>/outputs/<design>.pkg.json -exclude_libraries -add_library sram -add_library gpio
+
+To run a testcase, use:
+    sc-issue -run -file sc_issue_<...>.tar.gz
+-----------------------------------------------------------
+"""  # noqa E501
+
+    issue_arguments = {
+        '-exclude_libraries': {'action': 'store_true',
+                               'help': 'flag to ensure libraries are excluded in the testcase',
+                               'sc_print': False},
+        '-exclude_pdks': {'action': 'store_true',
+                          'help': 'flag to ensure pdks are excluded in the testcase',
+                          'sc_print': False},
+        '-hash_files': {'action': 'store_true',
+                        'help': 'flag to hash the files in the schema before generating '
+                                'the manifest',
+                        'sc_print': False},
+
+        '-run': {'action': 'store_true',
+                 'help': 'run a provided testcase',
+                 'sc_print': False},
+
+        '-use': {'action': 'append',
+                 'help': 'modules to load into test run',
+                 'metavar': '<module>',
+                 'sc_print': False},
+
+        '-add_library': {'action': 'append',
+                         'help': 'library to include in the testcase, if not provided all '
+                                 'libraries will be added according to the -exclude_libraries flag',
+                         'metavar': '<library>',
+                         'sc_print': False},
+        '-add_pdk': {'action': 'append',
+                     'help': 'pdk to include in the testcase, if not provided all libraries '
+                             'will be added according to the -exclude_pdks flag',
+                     'metavar': '<pdk>',
+                     'sc_print': False},
+
+        '-file': {'help': 'filename for the generated testcase',
+                  'metavar': '<file>',
+                  'sc_print': False},
+    }
+
+    try:
+        switches = chip.create_cmdline(progname,
+                                       switchlist=switchlist,
+                                       description=description,
+                                       additional_args=issue_arguments)
+    except Exception as e:
+        chip.logger.error(e)
+        return 1
+
+    if not switches['run']:
+        step = chip.get('arg', 'step')
+        index = chip.get('arg', 'index')
+
+        if not step:
+            chip.logger.error('Unable to determine step from manifest')
+        if not index:
+            chip.logger.error('Unable to determine index from manifest')
+        if not step or not index:
+            # Exit out
+            return 1
+
+        generate_testcase(chip,
+                          step,
+                          index,
+                          switches['file'],
+                          include_pdks=not switches['exclude_pdks'],
+                          include_specific_pdks=switches['add_pdk'],
+                          include_libraries=not switches['exclude_libraries'],
+                          include_specific_libraries=switches['add_library'],
+                          hash_files=switches['hash_files'])
+
+        return 0
+
+    if switches['run']:
+        if not switches['file']:
+            raise ValueError('-file must be provided')
+
+        test_dir = os.path.basename(switches['file']).split('.')[0]
+        with tarfile.open(switches['file'], 'r:gz') as f:
+            f.extractall(path='.')
+
+        chip.read_manifest(f'{test_dir}/orig_manifest.json')
+
+        with open(f'{test_dir}/issue.json', 'r') as f:
+            issue_info = json.load(f)
+
+        # Report major information
+        sc_version = issue_info['version']['sc']
+        if 'commit' in issue_info['version']['git']:
+            sc_source = issue_info['version']['git']['commit']
+        else:
+            sc_source = 'installed'
+
+        chip.logger.info(f"Design: {chip.design}")
+        chip.logger.info(f"SiliconCompiler version: {sc_version} / {sc_source}")
+        chip.logger.info(f"Schema version: {issue_info['version']['schema']}")
+        chip.logger.info(f"Python version: {issue_info['python']['version']}")
+
+        sc_machine = issue_info['machine']
+        sc_os = sc_machine['system']
+        if 'distro' in sc_machine:
+            sc_os += f" {sc_machine['distro']}"
+        sc_os += f" {sc_machine['osversion']} {sc_machine['arch']} {sc_machine['kernelversion']}"
+        chip.logger.info(f"Machine: {sc_os}")
+        chip.logger.info(f"Date: {issue_info['date']}")
+
+        step = issue_info['run']['step']
+        index = issue_info['run']['index']
+
+        chip.set('arg', 'step', step)
+        chip.set('arg', 'index', index)
+        tool, task = get_tool_task(chip, step, index)
+        chip.logger.info(f'Preparing run for {step}{index} - {tool}/{task}')
+
+        # Modify run environment to point to extracted files
+        builddir_key = ['option', 'builddir']
+        new_builddir = f"{test_dir}/{chip.get(*builddir_key)}"
+        chip.logger.info(f"Changing {builddir_key} to '{new_builddir}'")
+        chip.set(*builddir_key, new_builddir)
+
+        if switches['use']:
+            for use in switches['use']:
+                try:
+                    module = importlib.import_module(use)
+                    chip.logger.info(f"Loading '{use}' module")
+                    chip.use(module)
+                except ModuleNotFoundError:
+                    chip.logger.error(f"Unable to use '{use}' module")
+
+        # Run task
+        # Rerun setup task, assumed to be running in its own thread so
+        # multiprocess is not needed
+        flow = chip.get('option', 'flow')
+        _runtask(chip, flow, step, index, _executenode, replay=True)
+
+        return 0
+
+
+#########################
+if __name__ == "__main__":
+    sys.exit(main())