siliconcompiler 0.34.1__py3-none-any.whl → 0.34.2__py3-none-any.whl

siliconcompiler/flowgraph.py

@@ -68,6 +68,11 @@ class FlowgraphSchema(NamedSchema):
         if index in (Schema.GLOBAL_KEY, 'default'):
             raise ValueError(f"{index} is a reserved name")
 
+        if '/' in step:
+            raise ValueError(f"{step} is not a valid step, it cannot contain '/'")
+        if '/' in index:
+            raise ValueError(f"{index} is not a valid index, it cannot contain '/'")
+
         # Determine task name and module
         task_module = None
         if isinstance(task, str):
@@ -83,11 +88,6 @@ class FlowgraphSchema(NamedSchema):
             raise ValueError(f"{task} is not a valid task, it must be associated with "
                              "a tool '<tool>.<task>'.")
 
-        if '/' in step:
-            raise ValueError(f"{step} is not a valid step, it cannot contain '/'")
-        if '/' in index:
-            raise ValueError(f"{index} is not a valid index, it cannot contain '/'")
-
         tool_name, task_name = task_parts[-2:]
 
         # bind tool to node
@@ -504,6 +504,17 @@ class FlowgraphSchema(NamedSchema):
 
         return not error
 
+    def __get_task_module(self, name):
+        # Create cache
+        if self.__cache_tasks is None:
+            self.__cache_tasks = {}
+
+        if name in self.__cache_tasks:
+            return self.__cache_tasks[name]
+
+        self.__cache_tasks[name] = importlib.import_module(name)
+        return self.__cache_tasks[name]
+
     def get_task_module(self, step, index):
         """
         Returns the module for a given task
@@ -518,17 +529,19 @@ class FlowgraphSchema(NamedSchema):
         if (step, index) not in self.get_nodes():
             raise ValueError(f"{step}/{index} is not a valid node in {self.name()}.")
 
-        taskmodule = self.get(step, index, 'taskmodule')
+        return self.__get_task_module(self.get(step, index, 'taskmodule'))
 
-        # Create cache
-        if self.__cache_tasks is None:
-            self.__cache_tasks = {}
-
-        if taskmodule in self.__cache_tasks:
-            return self.__cache_tasks[taskmodule]
+    def get_all_tasks(self):
+        '''
+        Returns all the task modules used in this flow
 
-        self.__cache_tasks[taskmodule] = importlib.import_module(taskmodule)
-        return self.__cache_tasks[taskmodule]
+        Returns:
+            set of modules
+        '''
+        tasks = set()
+        for step, index in self.get_nodes():
+            tasks.add(self.get_task_module(step, index))
+        return tasks
 
 
 class RuntimeFlowgraph:

siliconcompiler/library.py

@@ -0,0 +1,133 @@
+from typing import final, Union, List
+
+from siliconcompiler.design import DesignSchema
+
+from siliconcompiler.schema import EditableSchema, Parameter, Scope, PerNode
+from siliconcompiler.schema.utils import trim
+
+
+class LibrarySchema(DesignSchema):
+    def __init__(self, name: str = None):
+        super().__init__()
+        self.set_name(name)
+
+    @final
+    def define_tool_parameter(self, tool: str, name: str, type: str, help: str, **kwargs):
+        """
+        Define a new tool parameter for the library
+
+        Args:
+            tool (str): name of the tool
+            name (str): name of the parameter
+            type (str): type of parameter, see :class:`.Parameter`.
+            help (str): help information for this parameter
+            kwargs: passthrough for :class:`.Parameter`.
+        """
+        if isinstance(help, str):
+            # grab first line for short help
+            help = trim(help)
+            shorthelp = help.splitlines()[0].strip()
+        else:
+            raise TypeError("help must be a string")
+
+        kwargs["scope"] = Scope.GLOBAL
+        kwargs["pernode"] = PerNode.NEVER
+        kwargs["shorthelp"] = shorthelp
+        kwargs["help"] = help
+
+        EditableSchema(self).insert(
+            "tool", tool, name,
+            Parameter(type, **kwargs)
+        )
+
+
+class StdCellLibrarySchema(LibrarySchema):
+    def __init__(self, name: str = None):
+        super().__init__()
+        self.set_name(name)
+
+        schema = EditableSchema(self)
+
+        schema.insert(
+            'asic', 'cornerfilesets', 'default',
+            Parameter(
+                '[str]',
+                scope=Scope.GLOBAL,
+                shorthelp="ASIC: map of filesets to timing or pex corners",
+                example=["api: schema.set('asic', 'cornerfilesets', 'slow', 'timing.slow')"],
+                help=trim("""Map between filesets and timing or pex corners.""")))
+
+        # TODO: Expand on the exact definitions of these types of cells.
+        # minimize typing
+        for item in [
+                'decap',
+                'tie',
+                'hold',
+                'clkbuf',
+                'clkgate',
+                'clklogic',
+                'dontuse',
+                'filler',
+                'tap',
+                'endcap',
+                'antenna']:
+            schema.insert(
+                'asic', 'cells', item,
+                Parameter(
+                    '[str]',
+                    scope=Scope.GLOBAL,
+                    shorthelp=f"ASIC: {item} cell list",
+                    example=[f"api: schema.set('asic', 'cells', '{item}', '*eco*')"],
+                    help=trim("""
+                    List of cells grouped by a property that can be accessed
+                    directly by the designer and tools. The example below shows how
+                    all cells containing the string 'eco' could be marked as dont use
+                    for the tool.""")))
+
+        schema.insert(
+            'asic', 'site',
+            Parameter(
+                '[str]',
+                scope=Scope.GLOBAL,
+                shorthelp="ASIC: library sites",
+                example=["api: schema.set('asic', 'site', 'Site_12T')"],
+                help="Site names for a given library architecture."))
+
+    def add_asic_corner_fileset(self, corner: str, fileset: str = None):
+        """
+        Adds a mapping between filesets a corners defined in the library
+
+        Args:
+            corner (str): name of the timing or parasitic corner
+            fileset (str): name of the fileset
+        """
+        if not fileset:
+            fileset = self._get_active("fileset")
+
+        if not isinstance(fileset, str):
+            raise TypeError("fileset must be a string")
+
+        if fileset not in self.getkeys("fileset"):
+            raise ValueError(f"{fileset} is not defined")
+
+        return self.add("asic", "cornerfilesets", corner, fileset)
+
+    def add_asic_cell_list(self, type: str, cells: Union[List[str], str]):
+        """
+        Adds a standard cell library to the specified type.
+
+        Args:
+            type (str): category of cell type
+            cells (list of str): cells to add
+        """
+        return self.add("asic", "cells", type, cells)
+
+    def add_asic_site(self, site: Union[List[str], str]):
+        """
+        Adds a standard site to the library
+
+        Args:
+            type (str): category of cell type
+            cells (list of str): cells to add
+        """
+        return self.add("asic", "site", site)

siliconcompiler/metric.py

@@ -10,7 +10,91 @@ class MetricSchema(BaseSchema):
     def __init__(self):
         super().__init__()
 
-        schema_metric(self)
+        schema = EditableSchema(self)
+
+        for item, description in [
+                ('errors', 'errors'),
+                ('warnings', 'warnings')]:
+            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(
+            '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.""")))
 
     def clear(self, step, index):
         '''
@@ -122,15 +206,20 @@ class MetricSchema(BaseSchema):
         return self.record(step, index, "totaltime", total_time, unit="s")
 
 
+class MetricSchemaTmp(MetricSchema):
+    def __init__(self):
+        super().__init__()
+
+        schema_metric_tmp(self)
+
+
 ###########################################################################
 # Metrics to Track
 ###########################################################################
-def schema_metric(schema):
+def schema_metric_tmp(schema):
     schema = EditableSchema(schema)
 
-    metrics = {'errors': 'errors',
-               'warnings': 'warnings',
-               'drvs': 'design rule violations',
+    metrics = {'drvs': 'design rule violations',
                'drcs': 'physical design rule violations',
                'unconstrained': 'unconstrained timing paths'}
 
@@ -429,70 +518,3 @@ def schema_metric(schema):
             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/metrics/__init__.py

@@ -0,0 +1,7 @@
+from siliconcompiler.metrics.asic import ASICMetricsSchema
+from siliconcompiler.metrics.fpga import FPGAMetricsSchema
+
+__all__ = [
+    "ASICMetricsSchema",
+    "FPGAMetricsSchema"
+]

siliconcompiler/metrics/asic.py

@@ -0,0 +1,245 @@
+from siliconcompiler import MetricSchema
+
+from siliconcompiler.schema import EditableSchema, Parameter, Scope, PerNode
+from siliconcompiler.schema.utils import trim
+
+
+class ASICMetricsSchema(MetricSchema):
+    def __init__(self):
+        super().__init__()
+
+        schema = EditableSchema(self)
+
+        for item, description in [
+                ('drvs', 'design rule violations'),
+                ('drcs', 'physical design rule violations'),
+                ('unconstrained', 'unconstrained timing paths')]:
+            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.""")))
+
+        for item, description in [
+                ('cellarea', 'cell area (ignoring fillers)'),
+                ('totalarea', 'physical die area'),
+                ('macroarea', 'macro cell area'),
+                ('padcellarea', 'io pad cell area'),
+                ('stdcellarea', 'standard cell area')]:
+            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.""")))
+
+        for item, description in [
+                ('peakpower', 'worst case total peak power'),
+                ('averagepower', 'average workload power'),
+                ('leakagepower', 'leakage power with rails active but without any dynamic '
+                                 'switching activity')]:
+            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.""")))
+
+        for item, description in [
+                ('holdpaths', 'hold'),
+                ('setuppaths', 'setup')]:
+            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.""")))
+
+        for item, description in [
+                ('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')]:
+            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.""")))
+
+        for item, description in [
+                ('fmax', 'maximum clock frequency')]:
+            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.""")))
+
+        for item, description in [
+                ('macros', 'macros'),
+                ('cells', 'cell instances'),
+                ('registers', 'register instances'),
+                ('buffers', 'buffer instances'),
+                ('inverters', 'inverter instances'),
+                ('transistors', 'transistors'),
+                ('pins', 'pins'),
+                ('nets', 'nets'),
+                ('vias', 'vias')]:
+            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.""")))