siliconcompiler 0.30.0__py3-none-any.whl → 0.31.1__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:
@@ -1078,15 +1092,19 @@ class Schema:
 
         tcl_set_cmds = []
         for key in self.allkeys():
+            # print out all non default values
+            if 'default' in key:
+                continue
+
             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)
@@ -1096,19 +1114,11 @@ class Schema:
 
             valstr = escape_val_tcl(value, typestr)
 
-            # Turning scalars into lists
-            if not (typestr.startswith('[') or typestr.startswith('(')):
-                valstr = f'[list {valstr}]'
-
-            # TODO: Temp fix to get rid of empty args
+            # Ensure empty values get something
             if valstr == '':
-                valstr = '[list ]'
-
-            outstr = f"{prefix} {keystr} {valstr}"
+                valstr = '{}'
 
-            # print out all non default values
-            if 'default' not in key:
-                tcl_set_cmds.append(outstr)
+            tcl_set_cmds.append(f"{prefix} {keystr} {valstr}")
 
         if template:
             fout.write(template.render(manifest_dict='\n'.join(tcl_set_cmds),
@@ -1515,7 +1525,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 +1541,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 +1693,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/templates/tcl/manifest.tcl.j2

@@ -34,7 +34,7 @@ proc sc_cfg_exists { args } {
 
 proc sc_top {} {
     set sc_entrypoint [sc_cfg_get option entrypoint]
-    if {$sc_entrypoint == ""} {
+    if {$sc_entrypoint == {{ '{}' }}} {
         return [sc_cfg_get design]
     }
     return $sc_entrypoint

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/_common/tcl/sc_pin_constraints.tcl

@@ -15,22 +15,20 @@ proc sc_collect_pin_constraints {
         set side [dict get $params side]
         set place [dict get $params placement]
 
-        if { [llength $place] != 0 } {
+        if { $place != {} } {
             # Pin has placement information
-            if { [llength $order] != 0 } {
+            if { $order != {} } {
                 # Pin also has order information
                 $print_func "Pin $name has placement specified in constraints, but also order."
             }
             lappend placement_pins $name
         } else {
             # Pin doesn't have placement
-            if { [llength $side] == 0 || [llength $order] == 0 } {
+            if { $side == {} || $order == {} } {
                 # Pin information is incomplete
                 $print_func \
                     "Warning: Pin $name doesn't have enough information to perform placement."
             } else {
-                set side [lindex $side 0]
-                set order [lindex $order 0]
                 if { ![dict exists $pin_order $side $order] } {
                     dict set pin_order $side $order []
                 }

siliconcompiler/tools/genfasm/genfasm.py

@@ -24,7 +24,7 @@ def make_docs(chip):
 def setup(chip):
     chip.set('tool', 'genfasm', 'exe', 'genfasm', clobber=False)
     chip.set('tool', 'genfasm', 'vswitch', '--version')
-    chip.set('tool', 'genfasm', 'version', '>=8.1.0', clobber=False)
+    chip.set('tool', 'genfasm', 'version', '>=9.0.0', clobber=False)
 
     add_tool_requirements(chip)
 

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()

siliconcompiler/tools/klayout/klayout_utils.py

@@ -1,5 +1,6 @@
 import pya
 import importlib.util as importlib_util
+import json
 import os
 import shutil
 import sys
@@ -180,3 +181,25 @@ def get_schema(manifest):
     spec.loader.exec_module(module)
     # Return schema
     return module.Schema(manifest=manifest)
+
+
+def generate_metrics():
+    metrics = {}
+
+    main_window = pya.MainWindow.instance()
+    if not main_window:
+        return
+    layout_view = main_window.current_view()
+    if not layout_view:
+        return
+    cell_view = layout_view.active_cellview()
+    if not cell_view:
+        return
+    cell = cell_view.cell
+    if not cell:
+        return
+
+    metrics["area"] = cell.dbbox().area()
+
+    with open('reports/metrics.json', 'w') as f:
+        json.dump(metrics, f, indent=2)

siliconcompiler/tools/klayout/operations.py

@@ -1,6 +1,7 @@
 import os
 from siliconcompiler import SiliconCompilerError
 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._common import input_provides, get_tool_task
 
@@ -202,3 +203,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/magic/magic.py

@@ -87,7 +87,7 @@ def process_file(file_type, chip, *key):
     index = chip.get('arg', 'index')
     tool, task = get_tool_task(chip, step, index)
 
-    if chip.get(*key, field='pernode') == 'never':
+    if chip.get(*key, field='pernode').is_never():
         files = chip.find_files(*key)
     else:
         files = chip.find_files(*key, step=step, index=index)

siliconcompiler/tools/openroad/_apr.py

@@ -197,13 +197,15 @@ def extract_metrics(chip):
             has_timing = metrics['sc__metric__timing__clocks'] > 0
 
         for metric, or_metric, or_use, or_unit in [
+            ('vias', 'sc__step__global_route__vias', True, None),
             ('vias', 'sc__step__route__vias', True, None),
+            ('wirelength', 'sc__step__global_route__wirelength', True, 'distance'),
             ('wirelength', 'sc__step__route__wirelength', True, 'distance'),
             ('cellarea', 'sc__metric__design__instance__area', True, 'area'),
             ('stdcellarea', 'sc__metric__design__instance__area__stdcell', True, 'area'),
             ('macroarea', 'sc__metric__design__instance__area__macros', True, 'area'),
             ('padcellarea', 'sc__metric__design__instance__area__padcells', True, 'area'),
-            ('totalarea', 'sc__metric__design__core__area', True, 'area'),
+            ('totalarea', 'sc__metric__design__die__area', True, 'area'),
             ('utilization', 'sc__metric__design__instance__utilization', True, 100.0),
             ('setuptns', 'sc__metric__timing__setup__tns', has_timing, 'time'),
             ('holdtns', 'sc__metric__timing__hold__tns', has_timing, 'time'),
@@ -763,6 +765,10 @@ def define_drt_params(chip):
                       schelp='list of layers to treat as unidirectional regardless of '
                              'what the tech lef specifies')
 
+    set_tool_task_var(chip, param_key='drt_report_interval',
+                      default_value=5,
+                      schelp='reporting interval in steps for generating a DRC report.')
+
 
 def define_sta_params(chip):
     step = chip.get('arg', 'step')
@@ -868,6 +874,10 @@ def define_mpl_params(chip):
     set_tool_task_var(chip, param_key='rtlmp_fence_weight',
                       schelp='Weight for fence cost, or how far the macro is from zero '
                              'fence violation')
+    set_tool_task_var(chip, param_key='rtlmp_boundary_weight',
+                      schelp='Weight for the boundary, or how far the hard macro clusters are from '
+                             'boundaries. Note that mixed macro clusters are not pushed, thus not '
+                             'considered in this cost.')
     set_tool_task_var(chip, param_key='rtlmp_blockage_weight',
                       schelp='Weight for the boundary, or how far the hard macro clusters are '
                              'from boundaries')
@@ -980,7 +990,8 @@ def set_reports(chip, reports):
         "ir_drop",
         "clock_placement",
         "clock_trees",
-        "optimization_placement"
+        "optimization_placement",
+        "module_view"
     )
 
     chip.set('tool', tool, 'task', task, 'var', 'reports',
@@ -994,7 +1005,7 @@ def set_reports(chip, reports):
         for key in (('tool', tool, 'task', task, 'var', f'skip_{type}'),
                     ('option', 'var', f'openroad_skip_{type}')):
             if chip.valid(*key):
-                if chip.get(*key, field='pernode') == 'never':
+                if chip.get(*key, field='pernode').is_never():
                     if chip.get(*key) == ["true"]:
                         return False
                     elif chip.get(*key, step=step, index=index) == ["true"]:

siliconcompiler/tools/openroad/antenna_repair.py

@@ -54,7 +54,8 @@ def setup(chip):
         'power_density',
         'optimization_placement',
         'clock_placement',
-        'clock_trees'
+        'clock_trees',
+        'module_view'
     ])
 
 

siliconcompiler/tools/openroad/clock_tree_synthesis.py

@@ -51,7 +51,8 @@ def setup(chip):
         'power_density',
         'optimization_placement',
         'clock_placement',
-        'clock_trees'
+        'clock_trees',
+        'module_view'
     ])
 
 

siliconcompiler/tools/openroad/detailed_placement.py

@@ -46,7 +46,8 @@ def setup(chip):
         'placement_density',
         'routing_congestion',
         'power_density',
-        'optimization_placement'
+        'optimization_placement',
+        'module_view'
     ])