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

siliconcompiler/flowgraph.py

@@ -1,4 +1,5 @@
 import inspect
+import importlib
 
 from siliconcompiler import Schema
 from siliconcompiler.schema import BaseSchema, NamedSchema
@@ -9,8 +10,9 @@ from siliconcompiler import NodeStatus
 
 
 class FlowgraphSchema(NamedSchema):
-    def __init__(self, name):
-        super().__init__(name=name)
+    def __init__(self, name=None):
+        super().__init__()
+        self.set_name(name)
 
         schema = EditableSchema(self)
         schema.insert("default", "default", FlowgraphNodeSchema())
@@ -30,6 +32,8 @@ class FlowgraphSchema(NamedSchema):
 
         self.__cache_node_outputs = None
 
+        self.__cache_tasks = None
+
     def node(self, step, task, index=0):
         '''
         Creates a flowgraph node.
@@ -64,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):
@@ -114,7 +123,7 @@ class FlowgraphSchema(NamedSchema):
 
         for step, index in [(head, head_index), (tail, tail_index)]:
             if not self.valid(step, index):
-                raise ValueError(f"{step}{index} is not a defined node in {self.name()}.")
+                raise ValueError(f"{step}/{index} is not a defined node in {self.name()}.")
 
         tail_node = (tail, tail_index)
         if tail_node in self.get(head, head_index, 'input'):
@@ -183,7 +192,7 @@ class FlowgraphSchema(NamedSchema):
         before_index = str(before_index)
 
         if (before_step, before_index) not in self.get_nodes():
-            raise ValueError(f'{before_step}{before_index} is not a valid node in {self.name()}')
+            raise ValueError(f'{before_step}/{before_index} is not a valid node in {self.name()}')
 
         # add the node
         self.node(step, task, index=index)
@@ -388,7 +397,7 @@ class FlowgraphSchema(NamedSchema):
         index = str(index)
 
         if (step, index) not in self.get_nodes():
-            raise ValueError(f"{step}{index} is not a valid node")
+            raise ValueError(f"{step}/{index} is not a valid node")
 
         if self.__cache_node_outputs is not None:
             return self.__cache_node_outputs[(step, index)]
@@ -464,15 +473,15 @@ class FlowgraphSchema(NamedSchema):
                 if input_nodes.count(node) > 1:
                     in_step, in_index = node
                     if logger:
-                        logger.error(f'Duplicate edge from {in_step}{in_index} to '
-                                     f'{step}{index} in the {self.name()} flowgraph')
+                        logger.error(f'Duplicate edge from {in_step}/{in_index} to '
+                                     f'{step}/{index} in the {self.name()} flowgraph')
                     error = True
 
         diff_nodes = check_nodes.difference(self.get_nodes())
         if diff_nodes:
             if logger:
                 for step, index in diff_nodes:
-                    logger.error(f'{step}{index} is missing in the {self.name()} flowgraph')
+                    logger.error(f'{step}/{index} is missing in the {self.name()} flowgraph')
             error = True
 
         # Detect missing definitions
@@ -480,7 +489,7 @@ class FlowgraphSchema(NamedSchema):
             for item in ('tool', 'task', 'taskmodule'):
                 if not self.get(step, index, item):
                     if logger:
-                        logger.error(f'{step}{index} is missing a {item} definition in the '
+                        logger.error(f'{step}/{index} is missing a {item} definition in the '
                                      f'{self.name()} flowgraph')
                     error = True
 
@@ -490,11 +499,50 @@ class FlowgraphSchema(NamedSchema):
             if loop_path:
                 error = True
                 if logger:
-                    loop_path = [f"{step}{index}" for step, index in loop_path]
+                    loop_path = [f"{step}/{index}" for step, index in loop_path]
                     logger.error(f"{' -> '.join(loop_path)} forms a loop in {self.name()}")
 
         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
+
+        Args:
+            step (str): Step name
+            index (int/str): Step index
+        """
+
+        index = str(index)
+
+        if (step, index) not in self.get_nodes():
+            raise ValueError(f"{step}/{index} is not a valid node in {self.name()}.")
+
+        return self.__get_task_module(self.get(step, index, 'taskmodule'))
+
+    def get_all_tasks(self):
+        '''
+        Returns all the task modules used in this flow
+
+        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:
     '''
@@ -649,13 +697,13 @@ class RuntimeFlowgraph:
         index = str(index)
 
         if (step, index) not in self.get_nodes():
-            raise ValueError(f"{step}{index} is not a valid node")
+            raise ValueError(f"{step}/{index} is not a valid node")
 
         return tuple(sorted(self.__walk_graph((step, str(index)), reverse=False)))
 
     def get_node_inputs(self, step, index, record=None):
         if (step, index) not in self.get_nodes():
-            raise ValueError(f"{step}{index} is not a valid node")
+            raise ValueError(f"{step}/{index} is not a valid node")
 
         if record is None:
             inputs = set()
@@ -722,7 +770,7 @@ class RuntimeFlowgraph:
         # Check for undefined prunes
         for step, index in sorted(prune_nodes.difference(flow.get_nodes())):
             if logger:
-                logger.error(f'{step}{index} is not defined in the {flow.name()} flowgraph')
+                logger.error(f'{step}/{index} is not defined in the {flow.name()} flowgraph')
             error = True
 
         if not error:
@@ -763,9 +811,9 @@ class RuntimeFlowgraph:
                         if entrynode in runtime.__walk_graph(exitnode):
                             found = True
                     if not found:
-                        exits = ",".join([f"{step}{index}"
+                        exits = ",".join([f"{step}/{index}"
                                           for step, index in runtime.get_exit_nodes()])
-                        missing.append(f'no path from {entrynode[0]}{entrynode[1]} to {exits} '
+                        missing.append(f'no path from {entrynode[0]}/{entrynode[1]} to {exits} '
                                        f'in the {flow.name()} flowgraph')
                     if found:
                         found_any = True

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"
+]