siliconcompiler 0.35.4__py3-none-any.whl → 0.36.1__py3-none-any.whl

siliconcompiler/constraints/timing_mode.py

@@ -0,0 +1,82 @@
+from typing import Union, List, Tuple, Optional
+
+from siliconcompiler.schema import NamedSchema, EditableSchema, Parameter, \
+    PerNode, Scope
+from siliconcompiler import Design
+
+
+class TimingModeSchema(NamedSchema):
+    """
+    Represents a single timing mode for design constraints.
+
+    This class encapsulates the SDC filesets used for a specific timing mode.
+    """
+
+    def __init__(self, name: Optional[str] = None):
+        super().__init__()
+        self.set_name(name)
+
+        schema = EditableSchema(self)
+        schema.insert(
+            'sdcfileset',
+            Parameter(
+                '[(str,str)]',
+                pernode=PerNode.OPTIONAL,
+                scope=Scope.GLOBAL,
+                shorthelp="Constraint: SDC files",
+                switch="-constraint_timing_file 'scenario <file>'",
+                example=["api: mode.set('constraint', 'timing', 'worst', 'file', 'hello.sdc')"],
+                help="""List of timing constraint sets files to use for the scenario. The
+                values are combined with any constraints specified by the design
+                'constraint' parameter. If no constraints are found, a default
+                constraint file is used based on the clock definitions."""))
+
+    def add_sdcfileset(self,
+                       design: Union[Design, str],
+                       fileset: str,
+                       clobber: bool = False,
+                       step: Optional[str] = None, index: Optional[Union[str, int]] = None):
+        """
+        Adds an SDC fileset for a given design.
+
+        Args:
+            design (:class:`Design` or str): The design object or the name of the design to
+                associate the fileset with.
+            fileset (str): The name of the SDC fileset to add.
+            clobber (bool): If True, existing SDC filesets for the design at the specified
+                    step/index will be overwritten.
+                    If False (default), the SDC fileset will be added.
+            step (str, optional): step name.
+            index (str, optional): index name.
+
+        Raises:
+            TypeError: If `design` is not a Design object or a string, or if `fileset` is not
+                a string.
+        """
+        if isinstance(design, Design):
+            design = design.name
+
+        if not isinstance(design, str):
+            raise TypeError("design must be a design object or string")
+
+        if not isinstance(fileset, str):
+            raise TypeError("fileset must be a string")
+
+        if clobber:
+            return self.set("sdcfileset", (design, fileset), step=step, index=index)
+        else:
+            return self.add("sdcfileset", (design, fileset), step=step, index=index)
+
+    def get_sdcfileset(self, step: Optional[str] = None, index: Optional[Union[str, int]] = None) \
+            -> List[Tuple[str, str]]:
+        """
+        Gets the list of SDC filesets.
+
+        Args:
+            step (str, optional): step name.
+            index (str, optional): index name.
+
+        Returns:
+            A list of tuples, where each tuple contains the design name and the SDC fileset name.
+        """
+        return self.get("sdcfileset", step=step, index=index)

siliconcompiler/data/templates/tcl/manifest.tcl.j2

@@ -17,12 +17,6 @@ proc sc_root {} {
 
 {% include 'tools/_common/tcl/sc_schema_access.tcl' %}
 
-# Redefine
-proc _sc_cfg_get_debug { args } {
-    {% if record_access %}puts "{{ record_access_id }} [join $args ,]"{% endif %}
-}
-
-
 #############################################
 # Tool variables
 #############################################

siliconcompiler/flowgraph.py

@@ -734,7 +734,7 @@ class Flowgraph(NamedSchema, DocsSchema):
         """
         return Flowgraph.__name__
 
-    def __get_graph_information(self):
+    def __get_graph_information(self, landscape):
         '''
         Internal helper to gather all node and edge info for graphviz.
 
@@ -744,6 +744,14 @@ class Flowgraph(NamedSchema, DocsSchema):
                 - dict: Information about each node.
                 - list: Information about each edge.
         '''
+        from siliconcompiler import Project
+        if landscape:
+            out_label_suffix = ':e'
+            in_label_suffix = ':w'
+        else:
+            out_label_suffix = ':s'
+            in_label_suffix = ':n'
+
         # Setup nodes
         node_exec_order = self.get_execution_order()
 
@@ -752,13 +760,9 @@ class Flowgraph(NamedSchema, DocsSchema):
             for step, index in rank_nodes:
                 node_rank[f'{step}/{index}'] = rank
 
-        # TODO: This appears to be unused, legacy from when files were nodes
-        all_graph_inputs = set()
-
         exit_nodes = [f'{step}/{index}' for step, index in self.get_exit_nodes()]
 
         nodes = {}
-        edges = []
 
         def clean_label(label):
             return label.replace("<", "").replace(">", "")
@@ -770,19 +774,34 @@ class Flowgraph(NamedSchema, DocsSchema):
 
         runtime_flow = RuntimeFlowgraph(self)
 
+        root = self._parent()._parent()  # Brittle since this replies on location
+        if not isinstance(root, Project):
+            root = None
+            has_io = False
+        else:
+            has_io = True
+
         for step, index in all_nodes:
             graph_node = self.get_graph_node(step, index)
-            tool = graph_node.get("tool")
-            task = graph_node.get("task")
+            tool: str = graph_node.get("tool")
+            task: str = graph_node.get("task")
 
             inputs = []
             outputs = []
+            if has_io and root:
+                try:
+                    inputs = root.get('tool', tool, 'task', task, 'input', step=step, index=index)
+                    outputs = root.get('tool', tool, 'task', task, 'output', step=step, index=index)
+                except KeyError:
+                    has_io = False
+                if not inputs and not outputs:
+                    has_io = False
 
             node = f'{step}/{index}'
 
             nodes[node] = {
                 "node": (step, index),
-                "file_inputs": inputs,
+                "file_inputs": set(inputs),
                 "inputs": {clean_text(f): f'input-{clean_label(f)}' for f in sorted(inputs)},
                 "outputs": {clean_text(f): f'output-{clean_label(f)}' for f in sorted(outputs)},
                 "task": f'{tool}/{task}' if tool != 'builtin' else task,
@@ -800,23 +819,41 @@ class Flowgraph(NamedSchema, DocsSchema):
                 rank_diff[in_node_name] = node_rank[node] - node_rank[in_node_name]
             nodes[node]["rank_diff"] = rank_diff
 
+        if not has_io:
+            for info in nodes.values():
+                info["inputs"] = []
+                info["outputs"] = []
+
+        edges = []
+        edges_io = []
         for step, index in all_nodes:
             node = f'{step}/{index}'
             all_inputs = []
             for in_step, in_index in self.get_graph_node(step, index).get_input():
                 all_inputs.append(f'{in_step}/{in_index}')
             for item in all_inputs:
-                edges.append((item, node, 1 if node in exit_nodes else 2))
-
-        return all_graph_inputs, nodes, edges
+                edges.append((f"{item}{out_label_suffix}",
+                              f"{node}{in_label_suffix}",
+                              1 if node in exit_nodes else 2))
+                if has_io:
+                    for infile in nodes[node]["inputs"]:
+                        if infile in nodes[item]["outputs"]:
+                            outlabel = f"{item}:output-{clean_label(infile)}"
+                            inlabel = f"{node}:input-{clean_label(infile)}"
+                            edges_io.append((f"{outlabel}{out_label_suffix}",
+                                             f"{inlabel}{in_label_suffix}",
+                                             1 if node in exit_nodes else 2))
+
+        return nodes, edges, edges_io, has_io
 
     def write_flowgraph(self, filename: str,
-                        fillcolor: Optional[str] = '#ffffff',
-                        fontcolor: Optional[str] = '#000000',
-                        background: Optional[str] = 'transparent',
-                        fontsize: Optional[Union[int, str]] = 14,
-                        border: Optional[bool] = True,
-                        landscape: Optional[bool] = False) -> None:
+                        fillcolor: str = '#ffffff',
+                        fontcolor: str = '#000000',
+                        background: str = 'transparent',
+                        fontsize: Union[int, str] = 14,
+                        border: bool = True,
+                        landscape: bool = False,
+                        show_io: Optional[bool] = None) -> None:
         r'''
         Renders and saves the compilation flowgraph to a file.
 
@@ -837,6 +874,7 @@ class Flowgraph(NamedSchema, DocsSchema):
             fontsize (str): Node text font size
             border (bool): Enables node border if True
             landscape (bool): Renders graph in landscape layout if True
+            show_io (bool): Add file input/outputs to graph
 
         Examples:
             >>> flow.write_flowgraph('mydump.png')
@@ -858,21 +896,22 @@ class Flowgraph(NamedSchema, DocsSchema):
         # controlling graph direction
         if landscape:
             rankdir = 'LR'
-            out_label_suffix = ':e'
-            in_label_suffix = ':w'
         else:
             rankdir = 'TB'
-            out_label_suffix = ':s'
-            in_label_suffix = ':n'
 
-        all_graph_inputs, nodes, edges = self.__get_graph_information()
+        nodes, edges, edges_io, has_io = self.__get_graph_information(landscape)
 
-        out_label_suffix = ''
-        in_label_suffix = ''
+        if show_io is None:
+            show_io = has_io
+        elif not has_io:
+            show_io = False
 
         dot = graphviz.Digraph(format=fileformat)
         dot.graph_attr['rankdir'] = rankdir
         dot.attr(bgcolor=background)
+        if show_io:
+            dot.graph_attr['concentrate'] = 'true'
+            dot.graph_attr['ranksep'] = '0.75'
 
         subgraphs = {
             "graphs": {},
@@ -901,24 +940,25 @@ class Flowgraph(NamedSchema, DocsSchema):
 
             subgraph_temp["nodes"].append(node)
 
-        with dot.subgraph(name='inputs') as input_graph:
-            input_graph.graph_attr['cluster'] = 'true'
-            input_graph.graph_attr['color'] = background
-
-            # add inputs
-            for graph_input in sorted(all_graph_inputs):
-                input_graph.node(
-                    graph_input, label=graph_input, bordercolor=fontcolor, style='filled',
-                    fontcolor=fontcolor, fontsize=fontsize, ordering="in",
-                    penwidth=penwidth, fillcolor=fillcolor, shape="box")
-
         def make_node(graph, node, prefix):
             '''Helper function to create a node in the graphviz object.'''
             info = nodes[node]
 
-            shape = "oval"
+            shape = "oval" if not show_io else "Mrecord"
             task_label = f"\\n ({info['task']})" if info['task'] is not None else ""
-            labelname = f"{node.replace(prefix, '')}{task_label}"
+            if show_io:
+                input_labels = [f"<{ikey}> {ifile}" for ifile, ikey in info['inputs'].items()]
+                output_labels = [f"<{okey}> {ofile}" for ofile, okey in info['outputs'].items()]
+                center_text = f"\\n {node.replace(prefix, '')} {task_label} \\n\\n"
+                labelname = "{"
+                if input_labels:
+                    labelname += f"{{ {' | '.join(input_labels)} }} |"
+                labelname += center_text
+                if output_labels:
+                    labelname += f"| {{ {' | '.join(output_labels)} }}"
+                labelname += "}"
+            else:
+                labelname = f"{node.replace(prefix, '')}{task_label}"
 
             graph.node(node, label=labelname, bordercolor=fontcolor, style='filled',
                        fontcolor=fontcolor, fontsize=fontsize, ordering="in",
@@ -975,8 +1015,12 @@ class Flowgraph(NamedSchema, DocsSchema):
         build_graph(subgraphs, dot, "")
 
         # Add all the edges
-        for edge0, edge1, weight in edges:
-            dot.edge(f'{edge0}{out_label_suffix}', f'{edge1}{in_label_suffix}', weight=str(weight))
+        if show_io:
+            for edge0, edge1, weight in edges_io:
+                dot.edge(edge0, edge1, weight=str(weight))
+        else:
+            for edge0, edge1, weight in edges:
+                dot.edge(edge0, edge1, weight=str(weight))
 
         dot.render(filename=fileroot, cleanup=True)
 
@@ -1270,21 +1314,30 @@ class RuntimeFlowgraph:
         if (step, index) not in self.get_nodes():
             raise ValueError(f"{step}/{index} is not a valid node")
 
+        base_nodes = set(self.__base.get_nodes())
+
         if record is None:
             inputs = set()
             for in_step, in_index in self.__base.get(step, index, "input"):
-                if (in_step, in_index) not in self.get_nodes():
+                if (in_step, in_index) not in base_nodes:
+                    continue
+                if (in_step, in_index) in self.__prune:
                     continue
                 inputs.add((in_step, in_index))
             return sorted(inputs)
 
         inputs = set()
         for in_step, in_index in self.__base.get(step, index, "input"):
-            if (in_step, in_index) not in self.get_nodes():
+            if (in_step, in_index) not in base_nodes:
+                continue
+            if (in_step, in_index) in self.__prune:
                 continue
 
             if record.get("status", step=in_step, index=in_index) == NodeStatus.SKIPPED:
-                inputs.update(self.get_node_inputs(in_step, in_index, record=record))
+                if (in_step, in_index) not in self.get_nodes():
+                    inputs.update(self.__base.get(in_step, in_index, "input"))
+                else:
+                    inputs.update(self.get_node_inputs(in_step, in_index, record=record))
             else:
                 inputs.add((in_step, in_index))
         return sorted(inputs)

siliconcompiler/flows/generate_openroad_rcx.py

@@ -74,8 +74,8 @@ class GenerateOpenRCXFlow(Flowgraph):
     @classmethod
     def make_docs(cls):
         from siliconcompiler.tools.builtin.nop import NOPTask
-        return [GenerateOpenRCXFlow(NOPTask(), corners=3, serial_extraction=False),
-                GenerateOpenRCXFlow(NOPTask(), corners=3, serial_extraction=True)]
+        return [cls(NOPTask(), corners=3, serial_extraction=False),
+                cls(NOPTask(), corners=3, serial_extraction=True)]
 
 
 ##################################################

siliconcompiler/flows/highresscreenshotflow.py

@@ -0,0 +1,37 @@
+from siliconcompiler import Flowgraph
+
+from siliconcompiler.tools.builtin import importfiles
+from siliconcompiler.tools.klayout import operations
+from siliconcompiler.tools.klayout import screenshot
+from siliconcompiler.tools.montage import tile
+
+
+class HighResScreenshotFlow(Flowgraph):
+    '''A high resolution screenshot flow.
+
+    This flow is designed to generate a high resolution design image from a GDS
+    or OAS file by preparing the layout, taking tiled screenshots, and merging
+    them into a single image.
+    '''
+    def __init__(self, name: str = "screenshotflow", add_prepare: bool = True):
+        super().__init__(name)
+
+        self.node('import', importfiles.ImportFilesTask())
+        if add_prepare:
+            self.node('prepare', operations.OperationsTask())
+        self.node('screenshot', screenshot.ScreenshotTask())
+        self.node('merge', tile.TileTask())
+
+        if add_prepare:
+            self.edge('import', 'prepare')
+            self.edge('prepare', 'screenshot')
+        else:
+            self.edge('import', 'screenshot')
+        self.edge('screenshot', 'merge')
+
+    @classmethod
+    def make_docs(cls):
+        return [
+            cls(add_prepare=True),
+            cls(add_prepare=False)
+        ]

siliconcompiler/library.py

@@ -276,7 +276,8 @@ class StdCellLibrary(DependencySchema, ToolLibrarySchema):
                 'filler',
                 'tap',
                 'endcap',
-                'antenna']:
+                'antenna',
+                'physicalonly']:
             schema.insert(
                 'asic', 'cells', item,
                 Parameter(

siliconcompiler/package/__init__.py

@@ -23,7 +23,7 @@ import uuid
 
 import os.path
 
-from typing import Optional, List, Dict, Type, Union, TYPE_CHECKING, ClassVar
+from typing import Optional, List, Dict, Type, Union, TYPE_CHECKING, Final
 
 from fasteners import InterProcessLock
 from importlib.metadata import distributions, distribution
@@ -32,6 +32,7 @@ from urllib import parse as url_parse
 
 from siliconcompiler.utils import get_plugins, default_cache_dir
 from siliconcompiler.utils.paths import cwdirsafe
+from siliconcompiler.utils.multiprocessing import MPManager
 
 if TYPE_CHECKING:
     from siliconcompiler.project import Project
@@ -54,12 +55,7 @@ class Resolver:
         source (str): The URI or path specifying the data source.
         reference (str): A version, commit hash, or tag for remote sources.
     """
-    _RESOLVERS_LOCK: ClassVar[threading.Lock] = threading.Lock()
-    _RESOLVERS: ClassVar[Dict[str, Type["Resolver"]]] = {}
-    __STORAGE: str = "__Resolver_cache_id"
-
-    __CACHE_LOCK: ClassVar[threading.Lock] = threading.Lock()
-    __CACHE: ClassVar[Dict[str, Dict[str, str]]] = {}
+    __STORAGE: Final[str] = "__Resolver_cache_id"
 
     def __init__(self, name: str,
                  root: Optional[Union["Project", "BaseSchema"]],
@@ -89,18 +85,19 @@ class Resolver:
         built-in resolvers (file, key, python) and any resolvers provided
         by external plugins.
         """
-        with Resolver._RESOLVERS_LOCK:
-            Resolver._RESOLVERS.clear()
+        settings = MPManager().get_transient_settings()
+        if settings.get_category("resolvers"):
+            # Already populated
+            return
 
-            Resolver._RESOLVERS.update({
-                "": FileResolver,
-                "file": FileResolver,
-                "key": KeyPathResolver,
-                "python": PythonPathResolver
-            })
+        settings.set("resolvers", "", FileResolver)
+        settings.set("resolvers", "file", FileResolver)
+        settings.set("resolvers", "key", KeyPathResolver)
+        settings.set("resolvers", "python", PythonPathResolver)
 
-            for resolver in get_plugins("path_resolver"):
-                Resolver._RESOLVERS.update(resolver())
+        for resolver in get_plugins("path_resolver"):
+            for scheme, res in resolver().items():
+                settings.set("resolvers", scheme, res)
 
     @staticmethod
     def find_resolver(source: str) -> Type["Resolver"]:
@@ -119,13 +116,13 @@ class Resolver:
         if os.path.isabs(source):
             return FileResolver
 
-        if not Resolver._RESOLVERS:
-            Resolver.populate_resolvers()
+        Resolver.populate_resolvers()
 
         url = url_parse.urlparse(source)
-        with Resolver._RESOLVERS_LOCK:
-            if url.scheme in Resolver._RESOLVERS:
-                return Resolver._RESOLVERS[url.scheme]
+        settings = MPManager().get_transient_settings()
+        resolver = settings.get("resolvers", url.scheme, None)
+        if resolver:
+            return resolver
 
         raise ValueError(f"Source URI '{source}' is not supported")
 
@@ -231,15 +228,14 @@ class Resolver:
         if root is None:
             return None
 
-        with Resolver.__CACHE_LOCK:
-            root_id = Resolver.__get_root_id(root)
-            if root_id not in Resolver.__CACHE:
-                Resolver.__CACHE[root_id] = {}
+        cache_id = f"resolver-cache-{Resolver.__get_root_id(root)}"
 
-            if name:
-                return Resolver.__CACHE[root_id].get(name, None)
+        settings = MPManager().get_transient_settings()
 
-            return Resolver.__CACHE[root_id].copy()
+        if name is not None:
+            return settings.get(cache_id, name, None)
+
+        return settings.get_category(cache_id)
 
     @staticmethod
     def set_cache(root: Optional[Union["Project", "BaseSchema"]],
@@ -256,11 +252,11 @@ class Resolver:
         if root is None:
             return
 
-        with Resolver.__CACHE_LOCK:
-            root_id = Resolver.__get_root_id(root)
-            if root_id not in Resolver.__CACHE:
-                Resolver.__CACHE[root_id] = {}
-            Resolver.__CACHE[root_id][name] = str(path)
+        cache_id = f"resolver-cache-{Resolver.__get_root_id(root)}"
+
+        settings = MPManager().get_transient_settings()
+
+        settings.set(cache_id, name, str(path))
 
     @staticmethod
     def reset_cache(root: Optional[Union["Project", "BaseSchema"]]) -> None:
@@ -272,11 +268,11 @@ class Resolver:
         """
         if root is None:
             return
+        cache_id = f"resolver-cache-{Resolver.__get_root_id(root)}"
+
+        settings = MPManager().get_transient_settings()
 
-        with Resolver.__CACHE_LOCK:
-            root_id = Resolver.__get_root_id(root)
-            if root_id in Resolver.__CACHE:
-                del Resolver.__CACHE[root_id]
+        settings.delete(cache_id)
 
     def get_path(self) -> str:
         """
@@ -334,9 +330,6 @@ class RemoteResolver(Resolver):
     both thread-safe and process-safe locking to prevent race conditions when
     multiple SC instances try to download the same resource simultaneously.
     """
-    _CACHE_LOCKS = {}
-    _CACHE_LOCK = threading.Lock()
-
     def __init__(self, name: str,
                  root: Optional[Union["Project", "BaseSchema"]],
                  source: str,
@@ -429,10 +422,11 @@ class RemoteResolver(Resolver):
 
     def thread_lock(self) -> threading.Lock:
         """Gets a threading.Lock specific to this resolver instance."""
-        with RemoteResolver._CACHE_LOCK:
-            if self.name not in RemoteResolver._CACHE_LOCKS:
-                RemoteResolver._CACHE_LOCKS[self.name] = threading.Lock()
-            return RemoteResolver._CACHE_LOCKS[self.name]
+        settings = MPManager().get_transient_settings()
+        locks = settings.get_category("resolver-remote-cache-locks")
+        if self.name not in locks:
+            settings.set("resolver-remote-cache-locks", self.name, threading.Lock(), keep=True)
+        return settings.get("resolver-remote-cache-locks", self.name)
 
     @contextlib.contextmanager
     def __thread_lock(self):

siliconcompiler/project.py

@@ -205,7 +205,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         Returns:
             str: The name of the top-level design.
         """
-        return self.get("option", "design")
+        return self.option.get_design()
 
     @property
     def design(self) -> Design:
@@ -373,6 +373,9 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         """
         if isinstance(obj, DependencySchema):
             for dep in obj.get_dep():
+                if isinstance(dep, (Design, LibrarySchema)):
+                    if self._has_library(dep.name):
+                        continue
                 self.add_dep(dep)
 
             # Rebuild dependencies to ensure instances are correct