siliconcompiler 0.32.3__py3-none-any.whl → 0.33.0__py3-none-any.whl

siliconcompiler/fpga.py

@@ -0,0 +1,84 @@
+from siliconcompiler.schema import BaseSchema
+from siliconcompiler.schema import EditableSchema, Parameter, Scope
+from siliconcompiler.schema.utils import trim
+
+
+class FPGASchema(BaseSchema):
+    def __init__(self):
+        super().__init__()
+
+        schema_fpga(self)
+
+
+###############################################################################
+# FPGA
+###############################################################################
+def schema_fpga(schema):
+    schema = EditableSchema(schema)
+
+    partname = 'default'
+    key = 'default'
+
+    schema.insert(
+        'partname',
+        Parameter(
+            'str',
+            scope=Scope.GLOBAL,
+            shorthelp="FPGA: part name",
+            switch="-fpga_partname <str>",
+            example=["cli: -fpga_partname fpga64k",
+                     "api: chip.set('fpga', 'partname', 'fpga64k')"],
+            help=trim("""
+            Complete part name used as a device target by the FPGA compilation
+            tool. The part name must be an exact string match to the partname
+            hard coded within the FPGA EDA tool.""")))
+
+    schema.insert(
+        partname, 'vendor',
+        Parameter(
+            'str',
+            scope=Scope.GLOBAL,
+            shorthelp="FPGA: vendor name",
+            switch="-fpga_vendor 'partname <str>'",
+            example=["cli: -fpga_vendor 'fpga64k acme'",
+                     "api: chip.set('fpga', 'fpga64k', 'vendor', 'acme')"],
+            help=trim("""
+            Name of the FPGA vendor for the FPGA partname.""")))
+
+    schema.insert(
+        partname, 'lutsize',
+        Parameter(
+            'int',
+            scope=Scope.GLOBAL,
+            shorthelp="FPGA: lutsize",
+            switch="-fpga_lutsize 'partname <int>'",
+            example=["cli: -fpga_lutsize 'fpga64k 4'",
+                     "api: chip.set('fpga', 'fpga64k', 'lutsize', '4')"],
+            help=trim("""
+            Specify the number of inputs in each lookup table (LUT) for the
+            FPGA partname.  For architectures with fracturable LUTs, this is
+            the number of inputs of the unfractured LUT.""")))
+
+    schema.insert(
+        partname, 'file', key,
+        Parameter(
+            '[file]',
+            scope=Scope.GLOBAL,
+            shorthelp="FPGA: file",
+            switch="-fpga_file 'partname key <file>'",
+            example=["cli: -fpga_file 'fpga64k archfile my_arch.xml'",
+                     "api: chip.set('fpga', 'fpga64k', 'file', 'archfile', 'my_arch.xml')"],
+            help=trim("""
+            Specify a file for the FPGA partname.""")))
+
+    schema.insert(
+        partname, 'var', key,
+        Parameter(
+            '[str]',
+            scope=Scope.GLOBAL,
+            shorthelp="FPGA: var",
+            switch="-fpga_var 'partname key <str>'",
+            example=["cli: -fpga_var 'fpga64k channelwidth 100'",
+                     "api: chip.set('fpga', 'fpga64k', 'var', 'channelwidth', '100')"],
+            help=trim("""
+            Specify a variable value for the FPGA partname.""")))

siliconcompiler/metric.py

@@ -0,0 +1,420 @@
+from siliconcompiler.schema import BaseSchema
+from siliconcompiler.schema import EditableSchema, Parameter, PerNode, Scope
+from siliconcompiler.schema.utils import trim
+
+from siliconcompiler.utils.units import convert
+
+
+class MetricSchema(BaseSchema):
+    def __init__(self):
+        super().__init__()
+
+        schema_metric(self)
+
+    def clear(self, step, index):
+        '''
+        Clear all saved metrics for a given step and index
+
+        Args:
+            step (str): Step name to clear.
+            index (str/int): Index name to clear.
+        '''
+        for metric in self.getkeys():
+            self.unset(metric, step=step, index=str(index))
+
+    def record(self, step, index, metric, value, unit=None):
+        """
+        Record a metric
+
+        Args:
+            step (str): step to record
+            index (str/int): index to record
+            metric (str): name of metric
+            value (int/float): value to record
+            unit (str): unit associated with value
+        """
+        metric_unit = self.get(metric, field='unit')
+
+        if not metric_unit and unit:
+            raise ValueError(f"{metric} does not have a unit, but {unit} was supplied")
+
+        if metric_unit:
+            value = convert(value, from_unit=unit, to_unit=metric_unit)
+
+        return self.set(metric, value, step=step, index=str(index))
+
+
+###########################################################################
+# Metrics to Track
+###########################################################################
+def schema_metric(schema):
+    schema = EditableSchema(schema)
+
+    metrics = {'errors': 'errors',
+               'warnings': 'warnings',
+               'drvs': 'design rule violations',
+               'drcs': 'physical design rule violations',
+               'unconstrained': 'unconstrained timing paths'}
+
+    for item, description in metrics.items():
+        schema.insert(
+            item,
+            Parameter(
+                'int',
+                scope=Scope.JOB,
+                shorthelp=f"Metric: total {item}",
+                switch=f"-metric_{item} 'step index <int>'",
+                example=[
+                    f"cli: -metric_{item} 'dfm 0 0'",
+                    f"api: chip.set('metric', '{item}', 0, step='dfm', index=0)"],
+                pernode=PerNode.REQUIRED,
+                help=trim(f"""Metric tracking the total number of {description} on a
+                per step and index basis.""")))
+
+    schema.insert(
+        'coverage',
+        Parameter(
+            'float',
+            unit='%',
+            scope=Scope.JOB,
+            shorthelp="Metric: coverage",
+            switch="-metric_coverage 'step index <float>'",
+            example=[
+                "cli: -metric_coverage 'place 0 99.9'",
+                "api: chip.set('metric', 'coverage', 99.9, step='place', index=0)"],
+            pernode=PerNode.REQUIRED,
+            help=trim("""
+            Metric tracking the test coverage in the design expressed as a percentage
+            with 100 meaning full coverage. The meaning of the metric depends on the
+            task being executed. It can refer to code coverage, feature coverage,
+            stuck at fault coverage.""")))
+
+    schema.insert(
+        'security',
+        Parameter(
+            'float',
+            unit='%',
+            scope=Scope.JOB,
+            shorthelp="Metric: security",
+            switch="-metric_security 'step index <float>'",
+            example=[
+                "cli: -metric_security 'place 0 100'",
+                "api: chip.set('metric', 'security', 100, step='place', index=0)"],
+            pernode=PerNode.REQUIRED,
+            help=trim("""
+            Metric tracking the level of security (1/vulnerability) of the design.
+            A completely secure design would have a score of 100. There is no
+            absolute scale for the security metrics (like with power, area, etc)
+            so the metric will be task and tool dependent.""")))
+
+    metrics = {'luts': 'FPGA LUTs used',
+               'dsps': 'FPGA DSP slices used',
+               'brams': 'FPGA BRAM tiles used'}
+
+    for item, description in metrics.items():
+        schema.insert(
+            item,
+            Parameter(
+                'int',
+                scope=Scope.JOB,
+                shorthelp=f"Metric: {description}",
+                switch=f"-metric_{item} 'step index <int>'",
+                example=[
+                    f"cli: -metric_{item} 'place 0 100'",
+                    f"api: chip.set('metric', '{item}', 100, step='place', index=0)"],
+                pernode=PerNode.REQUIRED,
+                help=trim(f"""
+                Metric tracking the total {description} used by the design as reported
+                by the implementation tool. There is no standardized definition
+                for this metric across vendors, so metric comparisons can
+                generally only be done between runs on identical tools and
+                device families.""")))
+
+    metrics = {'cellarea': 'cell area (ignoring fillers)',
+               'totalarea': 'physical die area',
+               'macroarea': 'macro cell area',
+               'padcellarea': 'io pad cell area',
+               'stdcellarea': 'standard cell area'}
+
+    for item, description in metrics.items():
+        schema.insert(
+            item,
+            Parameter(
+                'float',
+                unit='um^2',
+                scope=Scope.JOB,
+                shorthelp=f"Metric: {item}",
+                switch=f"-metric_{item} 'step index <float>'",
+                example=[
+                    f"cli: -metric_{item} 'place 0 100.00'",
+                    f"api: chip.set('metric', '{item}', 100.00, step='place', index=0)"],
+                pernode=PerNode.REQUIRED,
+                help=trim(f"""
+                Metric tracking the total {description} occupied by the design.""")))
+
+    schema.insert(
+        'utilization',
+        Parameter(
+            'float',
+            unit='%',
+            scope=Scope.JOB,
+            shorthelp="Metric: area utilization",
+            switch="-metric_utilization 'step index <float>'",
+            example=[
+                "cli: -metric_utilization 'place 0 50.00'",
+                "api: chip.set('metric', 'utilization', 50.00, step='place', index=0)"],
+            pernode=PerNode.REQUIRED,
+            help=trim("""
+            Metric tracking the area utilization of the design calculated as
+            100 * (cellarea/totalarea).""")))
+
+    schema.insert(
+        'logicdepth',
+        Parameter(
+            'int',
+            scope=Scope.JOB,
+            shorthelp="Metric: logic depth",
+            switch="-metric_logicdepth 'step index <int>'",
+            example=[
+                "cli: -metric_logicdepth 'place 0 8'",
+                "api: chip.set('metric', 'logicdepth', 8, step='place', index=0)"],
+            pernode=PerNode.REQUIRED,
+            help=trim("""
+            Metric tracking the logic depth of the design. This is determined
+            by the number of logic gates between the start of the critital timing
+            path to the end of the path.""")))
+
+    metrics = {'peakpower': 'worst case total peak power',
+               'averagepower': 'average workload power',
+               'leakagepower': 'leakage power with rails active but without any dynamic '
+                               'switching activity'}
+
+    for item, description in metrics.items():
+        schema.insert(
+             item,
+             Parameter(
+                'float',
+                unit='mw',
+                scope=Scope.JOB,
+                shorthelp=f"Metric: {item}",
+                switch=f"-metric_{item} 'step index <float>'",
+                example=[
+                    f"cli: -metric_{item} 'place 0 0.01'",
+                    f"api: chip.set('metric', '{item}', 0.01, step='place', index=0)"],
+                pernode=PerNode.REQUIRED,
+                help=trim(f"""
+                Metric tracking the {description} of the design specified on a per step
+                and index basis. Power metric depend heavily on the method
+                being used for extraction: dynamic vs static, workload
+                specification (vcd vs saif), power models, process/voltage/temperature.
+                The power {item} metric tries to capture the data that would
+                usually be reflected inside a datasheet given the appropriate
+                footnote conditions.""")))
+
+    schema.insert(
+        'irdrop',
+        Parameter(
+            'float',
+            unit='mv',
+            scope=Scope.JOB,
+            shorthelp="Metric: peak IR drop",
+            switch="-metric_irdrop 'step index <float>'",
+            example=[
+                "cli: -metric_irdrop 'place 0 0.05'",
+                "api: chip.set('metric', 'irdrop', 0.05, step='place', index=0)"],
+            pernode=PerNode.REQUIRED,
+            help=trim("""
+            Metric tracking the peak IR drop in the design based on extracted
+            power and ground rail parasitics, library power models, and
+            switching activity. The switching activity calculated on a per
+            node basis is taken from one of three possible sources, in order
+            of priority: VCD file, SAIF file, 'activityfactor' parameter.""")))
+
+    metrics = {'holdpaths': 'hold',
+               'setuppaths': 'setup'}
+
+    for item, description in metrics.items():
+        schema.insert(
+            item,
+            Parameter(
+                'int',
+                scope=Scope.JOB,
+                shorthelp=f"Metric: {item}",
+                switch=f"-metric_{item} 'step index <int>'",
+                example=[
+                    f"cli: -metric_{item} 'place 0 10'",
+                    f"api: chip.set('metric', '{item}', 10, step='place', index=0)"],
+                pernode=PerNode.REQUIRED,
+                help=trim(f"""
+                Metric tracking the total number of timing paths violating {description}
+                constraints.""")))
+
+    metrics = {'holdslack': 'worst hold slack (positive or negative)',
+               'holdwns': 'worst negative hold slack (positive values truncated to zero)',
+               'holdtns': 'total negative hold slack (TNS)',
+               'holdskew': 'hold clock skew',
+               'setupslack': 'worst setup slack (positive or negative)',
+               'setupwns': 'worst negative setup slack (positive values truncated to zero)',
+               'setuptns': 'total negative setup slack (TNS)',
+               'setupskew': 'setup clock skew'}
+
+    for item, description in metrics.items():
+        schema.insert(
+            item,
+            Parameter(
+                'float',
+                unit='ns',
+                scope=Scope.JOB,
+                shorthelp=f"Metric: {item}",
+                switch=f"-metric_{item} 'step index <float>'",
+                example=[
+                    f"cli: -metric_{item} 'place 0 0.01'",
+                    f"api: chip.set('metric', '{item}', 0.01, step='place', index=0)"],
+                pernode=PerNode.REQUIRED,
+                help=trim(f"""
+                Metric tracking the {description} on a per step and index basis.""")))
+
+    metrics = {'fmax': 'maximum clock frequency'}
+
+    for item, description in metrics.items():
+        schema.insert(
+            item,
+            Parameter(
+                'float',
+                unit='Hz',
+                scope=Scope.JOB,
+                shorthelp=f"Metric: {item}",
+                switch=f"-metric_{item} 'step index <float>'",
+                example=[
+                    f"cli: -metric_{item} 'place 0 100e6'",
+                    f"api: chip.set('metric', '{item}', 100e6, step='place', index=0)"],
+                pernode=PerNode.REQUIRED,
+                help=trim(f"""
+                Metric tracking the {description} on a per step and index basis.""")))
+
+    metrics = {'macros': 'macros',
+               'cells': 'cell instances',
+               'registers': 'register instances',
+               'buffers': 'buffer instances',
+               'inverters': 'inverter instances',
+               'transistors': 'transistors',
+               'pins': 'pins',
+               'nets': 'nets',
+               'vias': 'vias'}
+
+    for item, description in metrics.items():
+        schema.insert(
+            item,
+            Parameter(
+                'int',
+                scope=Scope.JOB,
+                shorthelp=f"Metric: {item}",
+                switch=f"-metric_{item} 'step index <int>'",
+                example=[
+                    f"cli: -metric_{item} 'place 0 100'",
+                    f"api: chip.set('metric', '{item}', 50, step='place', index=0)"],
+                pernode=PerNode.REQUIRED,
+                help=trim(f"""
+                Metric tracking the total number of {description} in the design
+                on a per step and index basis.""")))
+
+    schema.insert(
+        'wirelength',
+        Parameter(
+            'float',
+            unit='um',
+            scope=Scope.JOB,
+            shorthelp="Metric: wirelength",
+            switch="-metric_wirelength 'step index <float>'",
+            example=[
+                "cli: -metric_wirelength 'place 0 100.0'",
+                "api: chip.set('metric', 'wirelength', 50.0, step='place', index=0)"],
+            pernode=PerNode.REQUIRED,
+            help=trim("""
+            Metric tracking the total wirelength of the design on a per step
+            and index basis.""")))
+
+    schema.insert(
+        'overflow',
+        Parameter(
+            'int',
+            scope=Scope.JOB,
+            shorthelp="Metric: overflow",
+            switch="-metric_overflow 'step index <int>'",
+            example=[
+                "cli: -metric_overflow 'place 0 0'",
+                "api: chip.set('metric', 'overflow', 50, step='place', index=0)"],
+            pernode=PerNode.REQUIRED,
+            help=trim("""
+            Metric tracking the total number of overflow tracks for the routing
+            on per step and index basis. Any non-zero number suggests an over
+            congested design. To analyze where the congestion is occurring
+            inspect the router log files for detailed per metal overflow
+            reporting and open up the design to find routing hotspots.""")))
+
+    schema.insert(
+        'memory',
+        Parameter(
+            'float',
+            unit='B',
+            scope=Scope.JOB,
+            shorthelp="Metric: memory",
+            switch="-metric_memory 'step index <float>'",
+            example=[
+                "cli: -metric_memory 'dfm 0 10e9'",
+                "api: chip.set('metric', 'memory', 10e9, step='dfm', index=0)"],
+            pernode=PerNode.REQUIRED,
+            help=trim("""
+            Metric tracking total peak program memory footprint on a per
+            step and index basis.""")))
+
+    schema.insert(
+        'exetime',
+        Parameter(
+            'float',
+            unit='s',
+            scope=Scope.JOB,
+            shorthelp="Metric: exetime",
+            switch="-metric_exetime 'step index <float>'",
+            example=[
+                "cli: -metric_exetime 'dfm 0 10.0'",
+                "api: chip.set('metric', 'exetime', 10.0, step='dfm', index=0)"],
+            pernode=PerNode.REQUIRED,
+            help=trim("""
+            Metric tracking time spent by the EDA executable :keypath:`tool,<tool>,exe` on a
+            per step and index basis. It does not include the SiliconCompiler
+            runtime overhead or time waiting for I/O operations and
+            inter-processor communication to complete.""")))
+
+    schema.insert(
+        'tasktime',
+        Parameter(
+            'float',
+            unit='s',
+            scope=Scope.JOB,
+            shorthelp="Metric: tasktime",
+            switch="-metric_tasktime 'step index <float>'",
+            example=[
+                "cli: -metric_tasktime 'dfm 0 10.0'",
+                "api: chip.set('metric', 'tasktime', 10.0, step='dfm', index=0)"],
+            pernode=PerNode.REQUIRED,
+            help=trim("""
+            Metric tracking the total amount of time spent on a task from
+            beginning to end, including data transfers and pre/post
+            processing.""")))
+
+    schema.insert(
+        'totaltime',
+        Parameter(
+            'float',
+            unit='s',
+            scope=Scope.JOB,
+            shorthelp="Metric: totaltime",
+            switch="-metric_totaltime 'step index <float>'",
+            example=[
+                "cli: -metric_totaltime 'dfm 0 10.0'",
+                "api: chip.set('metric', 'totaltime', 10.0, step='dfm', index=0)"],
+            pernode=PerNode.REQUIRED,
+            help=trim("""
+            Metric tracking the total amount of time spent from the beginning
+            of the run up to and including the current step and index.""")))

siliconcompiler/optimizer/vizier.py

@@ -3,7 +3,6 @@ import uuid
 import math
 from siliconcompiler import Chip
 from siliconcompiler.optimizer import Optimizer
-from siliconcompiler.flowgraph import _get_flowgraph_nodes
 
 try:
     from vizier.service import clients as vz_clients
@@ -158,7 +157,7 @@ class VizierOptimizier(Optimizer):
                 chip.graph(flow, org_flow, name=graph_name)
 
             # Complete nodes
-            nodes = _get_flowgraph_nodes(chip, org_flow)
+            nodes = chip.schema.get("flowgraph", org_flow, field="schema").get_nodes()
             for step, _ in list(nodes):
                 nodes.append((step, None))
             nodes = set(nodes)
@@ -168,7 +167,7 @@ class VizierOptimizier(Optimizer):
                 if key[0] == 'history':
                     continue
 
-                for value, step, index in chip.schema._getvals(*key):
+                for value, step, index in chip.schema.get(*key, field=None).getvalues():
                     node = (step, index)
 
                     if node in nodes:

siliconcompiler/package/__init__.py

@@ -3,14 +3,15 @@ from urllib.parse import urlparse
 import importlib
 import re
 from siliconcompiler import SiliconCompilerError
-from siliconcompiler.utils import default_cache_dir, _resolve_env_vars
+from siliconcompiler.utils import default_cache_dir
 import json
 from importlib.metadata import distributions, distribution
 import functools
 import time
 from pathlib import Path
 
-from siliconcompiler.utils import get_plugins
+from siliconcompiler.utils import get_plugins, get_env_vars
+from siliconcompiler.schema.parametervalue import PathNodeValue
 
 
 def get_cache_path(chip):
@@ -46,6 +47,18 @@ def _python_path_resolver(chip, package, path, ref, url, fetch):
     return path_from_python(chip, url.netloc)
 
 
+def _key_path_resolver(chip, package, path, ref, url, fetch):
+    key = url.netloc.split(',')
+    if chip.get(*key, field='pernode').is_never():
+        paths = chip.find_files(*key)
+    else:
+        paths = chip.find_files(*key, step=chip.get('arg', 'step'), index=chip.get('arg', 'index'))
+
+    if isinstance(paths, list):
+        return paths[0]
+    return paths
+
+
 def _get_path_resolver(path):
     url = urlparse(path)
 
@@ -54,6 +67,9 @@ def _get_path_resolver(path):
         if func:
             return func, url
 
+    if url.scheme == "key":
+        return _key_path_resolver, url
+
     if url.scheme == "file":
         return _file_path_resolver, url
 
@@ -69,11 +85,15 @@ def _path(chip, package, fetch):
     data['path'] = chip.get('package', 'source', package, 'path')
     data['ref'] = chip.get('package', 'source', package, 'ref')
     if not data['path']:
-        raise SiliconCompilerError(
-            f'Could not find package source for {package} in schema. '
-            'You can use register_source() to add it.', chip=chip)
+        if package.startswith("key://"):
+            data['path'] = package
+        else:
+            raise SiliconCompilerError(
+                f'Could not find package source for {package} in schema. '
+                'You can use register_source() to add it.', chip=chip)
 
-    data['path'] = _resolve_env_vars(chip, data['path'], None, None)
+    env_vars = get_env_vars(chip, None, None)
+    data['path'] = PathNodeValue.resolve_env_vars(data['path'], envvars=env_vars)
 
     if os.path.exists(data['path']):
         # Path is already a path
@@ -102,6 +122,9 @@ def path(chip, package, fetch=True):
         if isinstance(data_path, tuple) and len(data_path) == 2:
             data_path, changed = data_path
 
+        if package.startswith("key://"):
+            return data_path
+
         if os.path.exists(data_path):
             if package not in chip._packages and changed:
                 chip.logger.info(f'Saved {package} data to {data_path}')