siliconcompiler 0.29.4__py3-none-any.whl → 0.31.0__py3-none-any.whl

siliconcompiler/schema/schema_obj.py

@@ -39,7 +39,7 @@ except ImportError:
     _has_yaml = False
 
 from .schema_cfg import schema_cfg
-from .utils import escape_val_tcl, PACKAGE_ROOT, translate_loglevel
+from .utils import escape_val_tcl, PACKAGE_ROOT, translate_loglevel, PerNode, Scope
 
 
 class Schema:
@@ -287,7 +287,7 @@ class Schema:
             try:
                 return cfg['node'][step][index][field]
             except KeyError:
-                if cfg['pernode'] == 'required':
+                if PerNode(cfg['pernode']) == PerNode.REQUIRED:
                     return cfg['node']['default']['default'][field]
 
             try:
@@ -300,6 +300,10 @@ class Schema:
             except KeyError:
                 return cfg['node']['default']['default'][field]
         elif field in cfg:
+            if field == "pernode":
+                return PerNode(cfg[field])
+            if field == "scope":
+                return Scope(cfg[field])
             return cfg[field]
         else:
             raise ValueError(f'Invalid field {field}')
@@ -621,7 +625,7 @@ class Schema:
                         has_global = True
                     vals.append((cfg['node'][step][index]['value'], step_arg, index_arg))
 
-        if (cfg['pernode'] != 'required') and not has_global and return_defvalue:
+        if (PerNode(cfg['pernode']) != PerNode.REQUIRED) and not has_global and return_defvalue:
             vals.append((cfg['node']['default']['default']['value'], None, None))
 
         return vals
@@ -707,7 +711,7 @@ class Schema:
             # ignore history in case of cumulative history
             if key[0] != 'history':
                 scope = self.get(*key, field='scope')
-                if not self.is_empty(*key) and (scope == 'job'):
+                if not self.is_empty(*key) and (scope == Scope.JOB):
                     self.__copyparam(self.cfg,
                                      self.cfg['history'][jobname],
                                      key)
@@ -865,15 +869,21 @@ class Schema:
 
         if field == 'scope':
             # Restricted allowed values
-            if not (isinstance(value, str) and value in ('global', 'job', 'scratch')):
-                raise TypeError(error_msg('one of "global", "job", or "scratch"'))
+            if isinstance(value, Scope):
+                return value.value
+            scope_values = [val.value for val in Scope]
+            if not (isinstance(value, str) and value in scope_values):
+                raise TypeError(error_msg(f'one of {", ".join(sorted(scope_values))}'))
             return value
 
         if field == 'pernode':
             # Restricted allowed values
-            if not (isinstance(value, str) and value in ('never', 'optional', 'required')):
+            if isinstance(value, PerNode):
+                return value.value
+            pernode_values = [val.value for val in PerNode]
+            if not (isinstance(value, str) and value in pernode_values):
                 raise TypeError(f'Invalid value {value} for field {field}: '
-                                'expected one of "never", "optional", or "required"')
+                                f'expected one of {", ".join(sorted(pernode_values))}')
             return value
 
         if field in (
@@ -955,10 +965,10 @@ class Schema:
                 return 'step and index are only valid for value fields'
             return None
 
-        if pernode == 'never' and (step is not None or index is not None):
+        if PerNode(pernode) == PerNode.NEVER and (step is not None or index is not None):
             return 'step and index are not valid for this parameter'
 
-        if pernode == 'required' and (step is None or index is None):
+        if PerNode(pernode) == PerNode.REQUIRED and (step is None or index is None):
             return 'step and index are required for this parameter'
 
         if step is None and index is not None:
@@ -989,11 +999,15 @@ class Schema:
             if key in cfg:
                 cfg = cfg[key]
             elif 'default' in cfg:
+                cfg_default = cfg['default']
                 if insert_defaults:
-                    cfg[key] = copy.deepcopy(cfg['default'])
+                    if Schema._is_leaf(cfg_default) and cfg_default['lock']:
+                        raise ValueError(f'{keypath} is locked and key cannot be added')
+
+                    cfg[key] = copy.deepcopy(cfg_default)
                     cfg = cfg[key]
                 elif use_default:
-                    cfg = cfg['default']
+                    cfg = cfg_default
                 else:
                     raise ValueError(f'Invalid keypath {keypath}: unexpected key: {key}')
             else:
@@ -1081,12 +1095,12 @@ class Schema:
             typestr = self.get(*key, field='type')
             pernode = self.get(*key, field='pernode')
 
-            if pernode == 'required' and (step is None or index is None):
+            if PerNode(pernode) == PerNode.REQUIRED and (step is None or index is None):
                 # Skip mandatory per-node parameters if step and index are not specified
                 # TODO: how should we dump these?
                 continue
 
-            if pernode != 'never':
+            if not pernode.is_never():
                 value = self.get(*key, step=step, index=index)
             else:
                 value = self.get(*key)
@@ -1515,7 +1529,7 @@ class Schema:
                 used_switches.update(switchstrs)
                 if typestr == 'bool':
                     # Boolean type arguments
-                    if pernodestr == 'never':
+                    if pernodestr.is_never():
                         parser.add_argument(*switchstrs,
                                             nargs='?',
                                             metavar=metavar,
@@ -1531,7 +1545,7 @@ class Schema:
                                             action='append',
                                             help=helpstr,
                                             default=argparse.SUPPRESS)
-                elif '[' in typestr or pernodestr != 'never':
+                elif '[' in typestr or not pernodestr.is_never():
                     # list type arguments
                     parser.add_argument(*switchstrs,
                                         metavar=metavar,
@@ -1683,13 +1697,13 @@ class Schema:
                 sctype = self.get(*keypath, field='type')
                 pernode = self.get(*keypath, field='pernode')
                 step, index = None, None
-                if pernode == 'required':
+                if PerNode(pernode) == PerNode.REQUIRED:
                     try:
                         step, index, val = remainder.split(' ', 2)
                     except ValueError:
                         self.logger.error(f"Invalid value '{item}' for switch {switchstr}. "
                                           "Requires step and index before final value.")
-                elif pernode == 'optional':
+                elif PerNode(pernode) == PerNode.OPTIONAL:
                     # Split on spaces, preserving items that are grouped in quotes
                     items = shlex.split(remainder)
                     if len(items) > 3:

siliconcompiler/schema/utils.py

@@ -7,10 +7,29 @@
 import os
 import re
 import sys
+from enum import Enum
 
 PACKAGE_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
 
 
+#############################################################################
+# ENUM DEFINITIONs
+#############################################################################
+class Scope(Enum):
+    GLOBAL = 'global'
+    JOB = 'job'
+    SCRATCH = 'scratch'
+
+
+class PerNode(Enum):
+    NEVER = 'never'
+    OPTIONAL = 'optional'
+    REQUIRED = 'required'
+
+    def is_never(self):
+        return self == PerNode.NEVER
+
+
 def escape_val_tcl(val, typestr):
     '''Recursive helper function for converting Python values to safe TCL
     values, based on the SC type string.'''

siliconcompiler/sphinx_ext/schemagen.py

@@ -37,9 +37,11 @@ class SchemaGen(SphinxDirective):
             entries = [[strong('Description'), para(schema['shorthelp'])],
                        [strong('Type'), para(schema['type'])]]
 
-            if schema['pernode'] != 'never':
+            if schema['pernode'] != utils.PerNode.NEVER:
                 entries.append([strong('Per step/index'), para(schema['pernode'])])
 
+            entries.append([strong('Scope'), para(schema['scope'])])
+
             if 'enum' in schema['type']:
                 entries.append([strong('Allowed Values'),
                                 build_list([code(val) for val in schema['enum']])])

siliconcompiler/templates/replay/replay.sh.j2

@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+if [ "${BASH_SOURCE[0]}" != "$0" ]; then
+    echo "${BASH_SOURCE[0]} must be executed."
+    return
+fi
+
+# Parse replay arguments
+CD_WORK="{{ work_dir }}"
+PRINT=""
+CMDPREFIX=""
+SKIPEXPORT=0
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --which)
+            PRINT="which"
+            shift
+            ;;
+        --version)
+            PRINT="version"
+            shift
+            ;;
+        --directory)
+            PRINT="directory"
+            shift
+            ;;
+        --command)
+            PRINT="command"
+            shift
+            ;;
+        --skipcd)
+            CD_WORK="."
+            shift
+            ;;
+        --skipexports)
+            SKIPEXPORT=1
+            shift
+            ;;
+        --cmdprefix)
+            CMDPREFIX="$2"
+            shift
+            shift
+            ;;
+        -h|--help)
+            echo "Usage: $0"
+            echo "  Options:"
+            echo "    --which           print which executable would be used"
+            echo "    --version         print the version of the executable, if supported"
+            echo "    --directory       print the execution directory"
+            echo "    --command         print the execution command"
+            echo "    --skipcd          do not change directory into replay directory"
+            echo "    --skipexports     do not export environmental variables"
+            echo "    --cmdprefix <cmd> prefix to add to the replay command, such as gdb"
+            echo "    -h,--help         print this help"
+            exit 0
+            ;;
+        *)
+            echo "Unknown option $1"
+            exit 1
+            ;;
+    esac
+done
+
+if [ $SKIPEXPORT == 0 ]; then
+    # Environmental variables{% for key, value in exports.items() %}
+    export {{ key }}="{{ value }}"{% endfor %}
+fi
+
+# Switch to the working directory
+cd "$CD_WORK"
+
+case $PRINT in
+    "which")
+        which {{ executable }}
+        exit 0
+        ;;
+    "version")
+        {% if version_flag is defined %}{{ executable }} {{ version_flag }}{% else %}echo "--version is not supported"{% endif %}
+        exit 0
+        ;;
+    "directory")
+        echo "Working directory: $PWD"
+        exit 0
+        ;;
+    "command")
+        echo "{% for cmd in cmds %}{% if not loop.first %} {% endif %}{{ cmd }}{% endfor %}"
+        exit 0
+        ;;
+esac
+
+# Command execution
+$CMDPREFIX \{% for cmd in cmds %}
+{% if not loop.first %}  {% endif %}{{ cmd }}{% if not loop.last %} \{% endif %}{% endfor %}

siliconcompiler/tools/__init__.py

@@ -1,11 +1,12 @@
 from siliconcompiler.tools import bambu
-from siliconcompiler.tools.bluespec import bluespec
+from siliconcompiler.tools import bluespec
 from siliconcompiler.tools.builtin import builtin
 from siliconcompiler.tools.chisel import chisel
 from siliconcompiler.tools.execute import execute
 from siliconcompiler.tools.genfasm import genfasm
 from siliconcompiler.tools.ghdl import ghdl
 from siliconcompiler.tools import gtkwave
+from siliconcompiler.tools import graphviz
 from siliconcompiler.tools.icarus import icarus
 from siliconcompiler.tools.icepack import icepack
 from siliconcompiler.tools.klayout import klayout
@@ -39,6 +40,7 @@ def get_tools():
             execute,
             genfasm,
             ghdl,
+            graphviz,
             gtkwave,
             icarus,
             icepack,

siliconcompiler/tools/_common/__init__.py

@@ -161,7 +161,7 @@ def __get_step_index(chip, *key):
     step = chip.get('arg', 'step')
     index = chip.get('arg', 'index')
 
-    if chip.get(*key, field='pernode') == 'never':
+    if chip.get(*key, field='pernode').is_never():
         step = None
         index = None
 
@@ -330,7 +330,7 @@ def pick_key(chip, check_keys, step=None, index=None):
             check_step = step
             check_index = index
 
-            if chip.get(*key, field='pernode') == 'never':
+            if chip.get(*key, field='pernode').is_never():
                 check_step = None
                 check_index = None
 
@@ -347,9 +347,15 @@ def input_provides(chip, step, index, flow=None):
     if not flow:
         flow = chip.get('option', 'flow')
 
+    pruned_nodes = chip.get('option', 'prune')
+
     nodes = chip.get('flowgraph', flow, step, index, 'input')
     inputs = {}
     for in_step, in_index in nodes:
+        if (in_step, in_index) in pruned_nodes:
+            # node has been pruned so will not provide anything
+            continue
+
         if chip.get('record', 'status', step=in_step, index=in_index) == \
                 NodeStatus.SKIPPED:
             for file, nodes in input_provides(chip, in_step, in_index, flow=flow).items():

siliconcompiler/tools/_common/asic.py

@@ -188,7 +188,7 @@ def set_tool_task_lib_var(chip,
         get_step = step
         get_index = index
 
-        if chip.get(*lib_key, field='pernode') == 'never':
+        if chip.get(*lib_key, field='pernode').is_never():
             get_step = None
             get_index = None
 

siliconcompiler/tools/bluespec/__init__.py

@@ -0,0 +1,35 @@
+'''
+Bluespec is a high-level hardware description language. It has a variety of
+advanced features including a powerful type system that can prevent errors
+prior to synthesis time, and its most distinguishing feature, Guarded Atomic
+Actions, allow you to define hardware components in a modular manner based
+on their invariants, and let the compiler pick a scheduler.
+
+Documentation: https://github.com/B-Lang-org/bsc#documentation
+
+Sources: https://github.com/B-Lang-org/bsc
+
+Installation: https://github.com/B-Lang-org/bsc#download
+'''
+
+from siliconcompiler.tools.bluespec import convert
+
+
+####################################################################
+# Make Docs
+####################################################################
+def make_docs(chip):
+    convert.setup(chip)
+    return chip
+
+
+################################
+# Setup Tool (pre executable)
+################################
+def parse_version(stdout):
+    # Examples:
+    # Bluespec Compiler, version 2021.12.1-27-g9a7d5e05 (build 9a7d5e05)
+    # Bluespec Compiler, version 2021.07 (build 4cac6eba)
+
+    long_version = stdout.split()[3]
+    return long_version.split('-')[0]

siliconcompiler/tools/bluespec/convert.py

@@ -8,6 +8,7 @@ from siliconcompiler import sc_open
 
 # Directory inside step/index dir to store bsc intermediate results.
 VLOG_DIR = 'verilog'
+BSC_DIR = 'bluespec'
 
 
 def setup(chip):
@@ -39,6 +40,7 @@ def setup(chip):
 
     # Input/Output requirements
     chip.add('tool', tool, 'task', task, 'output', chip.top() + '.v', step=step, index=index)
+    chip.add('tool', tool, 'task', task, 'output', chip.top() + '.dot', step=step, index=index)
 
     # Schema requirements
     add_require_input(chip, 'input', 'hll', 'bsv')
@@ -50,9 +52,10 @@ def setup(chip):
 ################################
 def pre_process(chip):
     # bsc requires its output directory exists before being called.
-    if os.path.isdir(VLOG_DIR):
-        shutil.rmtree(VLOG_DIR)
-    os.makedirs(VLOG_DIR)
+    for path in (VLOG_DIR, BSC_DIR):
+        if os.path.isdir(path):
+            shutil.rmtree(path)
+        os.makedirs(path)
 
 
 ################################
@@ -68,7 +71,13 @@ def runtime_options(chip):
 
     cmdlist.append('-verilog')
     cmdlist.append(f'-vdir {VLOG_DIR}')
+    cmdlist.append(f'-bdir {BSC_DIR}')
+    cmdlist.append('-info-dir reports')
     cmdlist.append('-u')
+    cmdlist.append('-v')
+
+    cmdlist.append('-show-module-use')
+    cmdlist.append('-sched-dot')
 
     cmdlist.append(f'-g {chip.top(step, index)}')
 
@@ -95,10 +104,40 @@ def post_process(chip):
     ''' Tool specific function to run after step execution
     '''
 
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+
+    shutil.copyfile(f"reports/{chip.top(step, index)}_combined_full.dot",
+                    f"outputs/{chip.top()}.dot")
+
+    extra_modules = set()
+    use_file = os.path.join(VLOG_DIR, f"{chip.top(step, index)}.use")
+    if os.path.exists(use_file):
+        BSC_BASE = os.path.dirname(
+            os.path.dirname(
+                chip.get('record', 'toolpath', step=step, index=index)))
+        BSC_LIB = os.path.join(BSC_BASE, "lib", "Verilog")
+
+        with sc_open(use_file) as f:
+            for module in f:
+                module = module.strip()
+                mod_path = os.path.join(BSC_LIB, f"{module}.v")
+                if os.path.exists(mod_path):
+                    extra_modules.add(mod_path)
+                else:
+                    chip.logger.warn(f"Unable to find module {module} source files at: {BSC_LIB}")
+
     # bsc outputs each compiled module to its own Verilog file, so we
     # concatenate them all to create a pickled output we can pass along.
     design = chip.top()
     with open(os.path.join('outputs', f'{design}.v'), 'w') as pickled_vlog:
         for src in os.listdir(VLOG_DIR):
-            with sc_open(os.path.join(VLOG_DIR, src)) as vlog_mod:
-                pickled_vlog.write(vlog_mod.read())
+            if src.endswith(".v"):
+                with sc_open(os.path.join(VLOG_DIR, src)) as vlog_mod:
+                    pickled_vlog.write(vlog_mod.read())
+
+        pickled_vlog.write("\n")
+        pickled_vlog.write("// Bluespec imports\n\n")
+        for vfile in extra_modules:
+            with sc_open(os.path.join(BSC_LIB, vfile)) as vlog_mod:
+                pickled_vlog.write(vlog_mod.read() + "\n")

siliconcompiler/tools/graphviz/__init__.py

@@ -0,0 +1,12 @@
+'''
+Graphviz is open source graph visualization software.
+Graph visualization is a way of representing structural information as diagrams
+of abstract graphs and networks.
+It has important applications in networking, bioinformatics, software engineering,
+database and web design, machine learning, and in visual interfaces for other
+technical domains.
+'''
+
+
+def make_docs(chip):
+    return chip

siliconcompiler/tools/graphviz/screenshot.py

@@ -0,0 +1,48 @@
+import graphviz
+import os
+
+from siliconcompiler import sc_open
+from siliconcompiler.tools._common import get_tool_task
+
+
+def setup(chip):
+    '''
+    Generate a screenshot of a dot file
+    '''
+
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    chip.set('tool', tool, 'task', task, 'threads', 1, step=step, index=index)
+
+    chip.add('tool', tool, 'task', task, 'output', chip.top() + '.png', step=step, index=index)
+
+
+def run(chip):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    if os.path.exists(f'inputs/{chip.top()}.dot'):
+        file = f'inputs/{chip.top()}.dot'
+    elif os.path.exists(f'inputs/{chip.top()}.xdot'):
+        file = f'inputs/{chip.top()}.xdot'
+    elif chip.valid('tool', tool, 'task', task, 'var', 'show_filepath') and \
+            chip.get('tool', tool, 'task', task, 'var', 'show_filepath', step=step, index=index):
+        file = chip.get('tool', tool, 'task', task, 'var', 'show_filepath',
+                        step=step, index=index)[0]
+    else:
+        file = chip.find_files('input', 'image', 'dot', step=step, index=index)[0]
+
+    with sc_open(file) as dot:
+        dot_content = dot.read()
+
+    try:
+        dot = graphviz.Source(dot_content, format="png")
+        dot.render(filename=f"outputs/{chip.top()}", cleanup=True)
+        pass
+    except graphviz.ExecutableNotFound:
+        return 1
+
+    return 0

siliconcompiler/tools/graphviz/show.py

@@ -0,0 +1,20 @@
+from PIL import Image
+from siliconcompiler.tools.graphviz import screenshot
+
+
+def setup(chip):
+    '''
+    Show a graphviz dot file
+    '''
+
+    screenshot.setup(chip)
+
+
+def run(chip):
+    screenshot_ret = screenshot.run(chip)
+    if screenshot_ret != 0:
+        return screenshot_ret
+
+    Image.open(f"outputs/{chip.top()}.png").show()
+
+    return 0

siliconcompiler/tools/klayout/export.py

@@ -1,5 +1,6 @@
 import os
 from siliconcompiler.tools.klayout.klayout import setup as setup_tool
+from siliconcompiler.tools.klayout.klayout import process_metrics
 from siliconcompiler.tools.klayout.klayout import runtime_options as runtime_options_tool
 from siliconcompiler.tools.klayout.screenshot import setup_gui_screenshot
 from siliconcompiler.tools._common import input_provides, get_tool_task
@@ -127,3 +128,7 @@ def runtime_options(chip):
     return runtime_options_tool(chip) + [
         '-rd', f'SC_TOOLS_ROOT={os.path.dirname(os.path.dirname(__file__))}'
     ]
+
+
+def post_process(chip):
+    process_metrics(chip)

siliconcompiler/tools/klayout/klayout.py

@@ -12,9 +12,11 @@ Installation: https://www.klayout.de/build.html
 
 import os
 from pathlib import Path
+import json
 import platform
 import shutil
-from siliconcompiler.tools._common import get_tool_task
+from siliconcompiler.tools._common import get_tool_task, record_metric
+from siliconcompiler import sc_open
 
 
 ####################################################################
@@ -113,6 +115,21 @@ def parse_version(stdout):
     return stdout.split()[1]
 
 
+def process_metrics(chip):
+    metrics_file = "reports/metrics.json"
+    if not os.path.exists(metrics_file):
+        return
+
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+
+    with sc_open(metrics_file) as f:
+        metrics = json.load(f)
+
+    if "area" in metrics:
+        record_metric(chip, step, index, "totalarea", metrics["area"], metrics_file, "um^2")
+
+
 ##################################################
 if __name__ == "__main__":
 

siliconcompiler/tools/klayout/klayout_export.py

@@ -127,7 +127,8 @@ def main():
         technology,
         get_streams,
         save_technology,
-        get_schema
+        get_schema,
+        generate_metrics
     )
     from klayout_show import show
     from _common.asic import get_libraries
@@ -205,6 +206,8 @@ def main():
     # Save tech files
     save_technology(design, sc_tech)
 
+    generate_metrics()
+
 
 if __name__ == '__main__':
     main()

siliconcompiler/tools/klayout/klayout_operations.py

@@ -25,7 +25,7 @@ def __get_keypath_step_index(schema, *keypath):
         'index': schema.get('arg', 'index')
     }
     pernode = schema.get(*keypath, field='pernode')
-    if pernode == 'never':
+    if pernode.is_never():
         ret['step'] = None
         ret['index'] = None
 
@@ -330,7 +330,8 @@ if __name__ == "__main__":
     from klayout_utils import (
         technology,
         get_streams,
-        get_schema
+        get_schema,
+        generate_metrics
     )
 
     schema = get_schema(manifest='sc_manifest.json')
@@ -362,3 +363,5 @@ if __name__ == "__main__":
     parse_operations(schema, base_layout, sc_klayout_ops)
 
     write_stream(base_layout, out_gds, __with_timestamps(schema))
+
+    generate_metrics()