siliconcompiler 0.35.3__py3-none-any.whl → 0.36.0__py3-none-any.whl

siliconcompiler/tools/klayout/scripts/klayout_show.py

@@ -25,7 +25,7 @@ def show(schema, tech, input_path, output_path, screenshot=False, report=None):
     layout_options.lefdef_config.produce_obstructions = True
 
     # Always use LEF geometry even when LEF file contains FOREIGN statement.
-    layout_options.lefdef_config.macro_resolution_mode = 1
+    layout_options.lefdef_config.macro_resolution_mode = 0
 
     tech.load_layout_options = layout_options
 
@@ -118,9 +118,9 @@ def __screenshot_montage(schema, view, xbins, ybins):
 
     app.set_config("background-color", "#000000")  # Black
 
-    design = schema.get('option', 'entrypoint')
-    if not design:
-        design = schema.get('design')
+    design_name = schema.get('option', 'design')
+    fileset = schema.get("option", "fileset")[0]
+    design = schema.get("library", design_name, "fileset", fileset, "topmodule")
 
     horizontal_resolution, vertical_resolution = schema.get(
         'tool', 'klayout', 'task', task, 'var', 'show_resolution', step=step, index=index)
@@ -193,6 +193,7 @@ def main():
     # SC_ROOT provided by CLI, and is only accessible when this is main module
     sys.path.append(SC_KLAYOUT_ROOT)  # noqa: F821
     sys.path.append(SC_TOOLS_ROOT)  # noqa: F821
+    sys.path.append(SC_ROOT)  # noqa: F821
 
     from klayout_utils import (
         technology,

siliconcompiler/tools/klayout/scripts/klayout_utils.py

@@ -1,7 +1,6 @@
 import pya
 import json
 import shutil
-import sys
 import os.path
 
 
@@ -77,7 +76,7 @@ def technology(design, schema):
 
     layout_options = tech.load_layout_options
 
-    layout_options.lefdef_config.macro_resolution_mode = 1
+    layout_options.lefdef_config.macro_resolution_mode = 0
     layout_options.lefdef_config.via_cellname_prefix = "VIA_"
     pathed_files = set()
     for lef_file in layout_options.lefdef_config.lef_files:
@@ -99,6 +98,18 @@ def technology(design, schema):
     for lef_file in layout_options.lefdef_config.lef_files:
         print(f"[INFO] LEF file: {lef_file}")
 
+    in_files = layout_options.lefdef_config.macro_layout_files
+    for lib in schema.get("asic", "asiclib"):
+        libobj = schema.get("library", lib, field="schema")
+        for s in get_streams(schema):
+            for fileset in libobj.get("asic", "aprfileset"):
+                if libobj.valid("fileset", fileset, "file", s):
+                    in_files.extend(libobj.get("fileset", fileset, "file", s))
+                    break
+    layout_options.lefdef_config.macro_layout_files = in_files
+    for lef_file in layout_options.lefdef_config.macro_layout_files:
+        print(f"[INFO] Layout file: {lef_file}")
+
     # Set layer properties
     layer_properties = tech.layer_properties_file
     if layer_properties:
@@ -129,8 +140,9 @@ def technology(design, schema):
             map_file = os.path.abspath(os.path.join(os.path.dirname(tech_file),
                                                     map_file))
     for s in get_streams(schema):
-        if schema.valid('library', sc_pdk, 'layermapfileset', 'klayout', 'def', s):
-            for fileset in schema.get('library', sc_pdk, 'layermapfileset', 'klayout', 'def', s):
+        if schema.valid('library', sc_pdk, 'pdk', 'layermapfileset', 'klayout', 'def', s):
+            for fileset in schema.get('library', sc_pdk, 'pdk', 'layermapfileset', 'klayout',
+                                      'def', s):
                 if schema.valid('library', sc_pdk, "fileset", fileset, "file", "layermap"):
                     map_file = schema.get('library', sc_pdk, "fileset", fileset, "file", "layermap")
                 if map_file:
@@ -170,7 +182,6 @@ def get_write_options(filename, timestamps):
 
 
 def get_schema(manifest):
-    sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
     from schema.safeschema import SafeSchema
     return SafeSchema.from_manifest(filepath=manifest)
 

siliconcompiler/tools/montage/tile.py

@@ -1,20 +1,11 @@
-from siliconcompiler import Task
+from typing import Optional, Union
+
+from siliconcompiler import Task, TaskSkip
 
 
 class TileTask(Task):
     '''
     Tiles input images into a single output image.
-
-    Notes:
-        Need to make ensure that /etc/ImageMagick-6/policy.xml
-        <policy domain="resource" name="memory" value="8GiB"/>
-        <policy domain="resource" name="map" value="8GiB"/>
-        <policy domain="resource" name="width" value="32KP"/>
-        <policy domain="resource" name="height" value="32KP"/>
-        <policy domain="resource" name="area" value="1GP"/>
-        <policy domain="resource" name="disk" value="8GiB"/>
-        This ensures there are enough resources available to generate
-        the final image.
     '''
 
     def __init__(self):
@@ -23,6 +14,19 @@ class TileTask(Task):
         self.add_parameter("bins", "(int,int)", "Number of bins along the (x, y)-axis",
                            defvalue=(2, 2))
 
+    def set_montage_bins(self, xbins: int, ybins: int,
+                         step: Optional[str] = None, index: Optional[Union[str, int]] = None):
+        """
+        Set the number of bins for Montage tiling.
+
+        Args:
+            xbins (int): Number of bins along the x-axis.
+            ybins (int): Number of bins along the y-axis.
+            step (Optional[str]): Flow step to set the parameter for. Defaults to None.
+            index (Optional[Union[str, int]]): Index to set the parameter for. Defaults to None.
+        """
+        self.set("var", "bins", (xbins, ybins), step=step, index=index)
+
     def tool(self):
         return "montage"
 
@@ -41,12 +45,22 @@ class TileTask(Task):
 
         xbins, ybins = self.get("var", "bins")
 
+        if f"{self.design_topmodule}.png" in self.get_files_from_input_nodes():
+            raise TaskSkip("Input provides a single image; skipping tiling.")
+
         for x in range(xbins):
             for y in range(ybins):
                 self.add_input_file(f'{self.design_topmodule}_X{x}_Y{y}.png')
 
         self.add_output_file(ext="png")
 
+        self.add_commandline_option(['-limit', 'memory', '8GiB'])
+        self.add_commandline_option(['-limit', 'map', '8GiB'])
+        self.add_commandline_option(['-limit', 'disk', '8GiB'])
+        self.add_commandline_option(['-limit', 'width', '32KP'])
+        self.add_commandline_option(['-limit', 'height', '32KP'])
+        self.add_commandline_option(['-limit', 'area', '1GP'])
+
     def runtime_options(self):
         options = super().runtime_options()
 

siliconcompiler/tools/openroad/__init__.py

@@ -10,7 +10,7 @@ Sources: https://github.com/The-OpenROAD-Project/OpenROAD
 
 Installation: https://github.com/The-OpenROAD-Project/OpenROAD
 '''
-from typing import List, Union
+from typing import List, Union, Optional
 
 from siliconcompiler import StdCellLibrary
 from siliconcompiler import PDK
@@ -346,12 +346,38 @@ class OpenROADStdCellLibrary(StdCellLibrary):
 
 
 class OpenROADTask(ASICTask):
+    """
+    Base class for tasks involving the OpenROAD EDA tool chain.
+
+    This class provides common functionality for configuring OpenROAD execution,
+    such as setting up debug levels for internal tools.
+    """
     def __init__(self):
         super().__init__()
 
         self.add_parameter("debug_level", "{(str,str,int)}",
                            'list of "tool key level" to enable debugging of OpenROAD')
 
+    def add_openroad_debuglevel(self, tool: str, category: str, level: int,
+                                step: Optional[str] = None, index: Optional[str] = None,
+                                clobber: bool = False) -> None:
+        """
+        Configures the debug logging level for a specific OpenROAD tool and category.
+
+        Args:
+            tool: The name of the OpenROAD tool (e.g., "GRT", "PSM").
+            category: The specific debug category or keyword within the tool.
+            level: The integer verbosity level for the debug output.
+            step: The specific step to apply this configuration to.
+            index: The specific index to apply this configuration to.
+            clobber: If True, overwrites the existing debug level configuration.
+                     If False, appends this configuration to the existing list.
+        """
+        if clobber:
+            self.set("var", "debug_level", (tool, category, level), step=step, index=index)
+        else:
+            self.add("var", "debug_level", (tool, category, level), step=step, index=index)
+
     def tool(self):
         return "openroad"
 

siliconcompiler/tools/openroad/_apr.py

@@ -1,7 +1,7 @@
 import os
 import json
 
-from typing import List
+from typing import List, Union, Optional
 
 from siliconcompiler import sc_open
 from siliconcompiler import utils
@@ -374,9 +374,12 @@ class OpenROADDRTParameter(_OpenROADDRTCommonParameter):
         self.add_parameter("drt_disable_via_gen", "bool",
                            "true/false, when true turns off via generation in detailed router "
                            "and only uses the specified tech vias", defvalue=False)
-        self.add_parameter("drt_via_in_pin_bottom_layer", "str", "TODO")
-        self.add_parameter("drt_via_in_pin_top_layer", "str", "TODO")
-        self.add_parameter("drt_repair_pdn_vias", "str", "TODO")
+        self.add_parameter("drt_via_in_pin_bottom_layer", "str",
+                           "bottom layer to allow vias inside pins")
+        self.add_parameter("drt_via_in_pin_top_layer", "str",
+                           "top layer to allow vias inside pins")
+        self.add_parameter("drt_repair_pdn_vias", "str",
+                           "layer to repair PDN vias on")
 
         self.add_parameter("drt_report_interval", "int",
                            "reporting interval in steps for generating a DRC report.", defvalue=5)
@@ -411,6 +414,14 @@ class OpenROADDRTParameter(_OpenROADDRTCommonParameter):
 
 
 class APRTask(OpenROADTask):
+    """
+    Base class for OpenROAD-based Automatic Place and Route (APR) tasks.
+
+    This task initializes specific configurations for OpenROAD, including
+    report filtering, image generation settings, heatmap binning, and
+    power analysis corners.
+    """
+
     def __init__(self):
         super().__init__()
 
@@ -423,6 +434,7 @@ class APRTask(OpenROADTask):
             "fmax",
             "power",
             "check_setup",
+            "report_buffers",
             "placement_density",
             "routing_congestion",
             "power_density",
@@ -456,11 +468,79 @@ class APRTask(OpenROADTask):
         self.add_parameter("global_connect_fileset", "[(str,str)]",
                            "list of libraries and filesets to generate connects from")
 
-    def add_openroad_globalconnectfileset(self, library, fileset, clobber=False):
+    def add_openroad_skipreport(self, report_type: Union[List[str], str],
+                                step: Optional[str] = None, index: Optional[str] = None,
+                                clobber: bool = False) -> None:
+        """
+        Adds or sets report types to be skipped during OpenROAD execution.
+
+        Args:
+            report_type: The name of the report(s) to skip (e.g., 'routing_congestion').
+            step: The specific step to apply this configuration to.
+            index: The specific index to apply this configuration to.
+            clobber: If True, overwrites the existing list of skipped reports.
+                     If False, appends to the existing list.
+        """
+        if clobber:
+            self.set("var", "skip_reports", report_type, step=step, index=index)
+        else:
+            self.add("var", "skip_reports", report_type, step=step, index=index)
+
+    def set_openroad_enableimages(self, enable: bool,
+                                  step: Optional[str] = None, index: Optional[str] = None) -> None:
+        """
+        Enables or disables the generation of design images at the end of the task.
+
+        Args:
+            enable: True to generate images, False to disable.
+            step: The specific step to apply this configuration to.
+            index: The specific index to apply this configuration to.
+        """
+        self.set("var", "ord_enable_images", enable, step=step, index=index)
+
+    def set_openroad_heatmapbins(self, x: int, y: int,
+                                 step: Optional[str] = None, index: Optional[str] = None) -> None:
+        """
+        Configures the resolution of the heatmap images.
+
+        Args:
+            x: The number of bins in the X direction.
+            y: The number of bins in the Y direction.
+            step: The specific step to apply this configuration to.
+            index: The specific index to apply this configuration to.
+        """
+        self.set("var", "ord_heatmap_bins", (x, y), step=step, index=index)
+
+    def set_openroad_powercorner(self, corner: str,
+                                 step: Optional[str] = None, index: Optional[str] = None) -> None:
+        """
+        Sets the specific process corner used for power analysis.
+
+        Args:
+            corner: The name of the timing/power corner.
+            step: The specific step to apply this configuration to.
+            index: The specific index to apply this configuration to.
+        """
+        self.set("var", "power_corner", corner, step=step, index=index)
+
+    def add_openroad_globalconnectfileset(self, library: str, fileset: str,
+                                          step: Optional[str] = None, index: Optional[str] = None,
+                                          clobber: bool = False):
+        """
+        Adds a library and fileset pair to the global connect configuration.
+
+        Args:
+            library: The name of the library.
+            fileset: The name of the fileset.
+            step: The specific step to apply this configuration to.
+            index: The specific index to apply this configuration to.
+            clobber: If True, overwrites the existing global connect settings.
+                     If False, appends to the existing settings.
+        """
         if clobber:
-            self.set("var", "global_connect_fileset", (library, fileset))
+            self.set("var", "global_connect_fileset", (library, fileset), step=step, index=index)
         else:
-            self.add("var", "global_connect_fileset", (library, fileset))
+            self.add("var", "global_connect_fileset", (library, fileset), step=step, index=index)
 
     def setup(self):
         """
@@ -558,13 +638,22 @@ class APRTask(OpenROADTask):
     def _add_pnr_outputs(self):
         self.add_output_file(ext="sdc")
         self.add_output_file(ext="vg")
+        self.add_output_file(ext="lec.vg")
         self.add_output_file(ext="def")
         self.add_output_file(ext="odb")
 
+        for lib in self.project.get("asic", "asiclib"):
+            libobj = self.project.get("library", lib, field="schema")
+            for celltype in ["decap", "tie", "filler", "tap", "endcap", "antenna", "physicalonly"]:
+                if libobj.valid("asic", "cells", celltype) and \
+                        libobj.get("asic", "cells", celltype):
+                    self.add_required_key(libobj, "asic", "cells", celltype)
+
     def _get_pex_mapping(self):
         corners = {}
-        for constraint in self.project.getkeys('constraint', 'timing'):
-            pexcorner = self.project.get('constraint', 'timing', constraint, 'pexcorner',
+        for constraint in self.project.getkeys('constraint', 'timing', 'scenario'):
+            pexcorner = self.project.get('constraint', 'timing', 'scenario',
+                                         constraint, 'pexcorner',
                                          step=self.step, index=self.index)
             if pexcorner:
                 corners[constraint] = pexcorner
@@ -572,13 +661,17 @@ class APRTask(OpenROADTask):
         return corners
 
     def _get_constraint_by_check(self, check: str) -> str:
-        for constraint in self.project.getkeys('constraint', 'timing'):
-            if check in self.project.get('constraint', 'timing', constraint, 'check',
+        for constraint in self.project.getkeys('constraint', 'timing', 'scenario'):
+            if check in self.project.get('constraint', 'timing', 'scenario',
+                                         constraint, 'check',
                                          step=self.step, index=self.index):
                 return constraint
 
         # if not specified, just pick the first constraint available
-        return self.project.getkeys('constraint', 'timing')[0]
+        scenarios = self.project.getkeys('constraint', 'timing', 'scenario')
+        if not scenarios:
+            raise ValueError("No timing scenarios defined in project constraints.")
+        return scenarios[0]
 
     def _build_pex_estimation_file(self):
         corners = self._get_pex_mapping()
@@ -684,9 +777,9 @@ class APRTask(OpenROADTask):
             ],
             "peakpower": [
                 *[f"power/{corner}.rpt"
-                  for corner in self.project.getkeys('constraint', 'timing')],
+                  for corner in self.project.getkeys('constraint', 'timing', 'scenario')],
                 *[f"images/heatmap/power_density/{corner}.png"
-                    for corner in self.project.getkeys('constraint', 'timing')]
+                    for corner in self.project.getkeys('constraint', 'timing', 'scenario')]
             ],
             "drvs": [
                 "timing/drv_violators.rpt",

siliconcompiler/tools/openroad/clock_tree_synthesis.py

@@ -26,6 +26,7 @@ class CTSTask(APRTask, OpenROADSTAParameter, OpenROADDPLParameter, OpenROADCTSPa
             'power',
             'drv_violations',
             'fmax',
+            'report_buffers',
 
             # Images
             'placement_density',

siliconcompiler/tools/openroad/global_placement.py

@@ -37,6 +37,7 @@ class GlobalPlacementTask(APRTask, OpenROADSTAParameter, OpenROADGPLParameter,
             'unconstrained',
             'power',
             'fmax',
+            'report_buffers',
 
             # Images
             'placement_density',

siliconcompiler/tools/openroad/init_floorplan.py

@@ -1,3 +1,5 @@
+from typing import Union, List, Optional
+
 from siliconcompiler.tools.openroad._apr import APRTask
 from siliconcompiler.tools.openroad._apr import OpenROADSTAParameter, OpenROADPPLParameter
 
@@ -5,9 +7,13 @@ from siliconcompiler.tools.openroad._apr import OpenROADSTAParameter, OpenROADPP
 class InitFloorplanTask(APRTask,
                         OpenROADSTAParameter,
                         OpenROADPPLParameter):
-    '''
-    Perform floorplanning and initial pin placements
-    '''
+    """
+    Perform floorplanning and initial pin placements.
+
+    This task handles the initialization of the floorplan, including macro placement
+    snapping strategies, cleaning up synthesis artifacts (buffers/dead logic),
+    and defining padring or bumpmap configurations.
+    """
     def __init__(self):
         super().__init__()
 
@@ -19,6 +25,79 @@ class InitFloorplanTask(APRTask,
                            "remove logic which does not drive a primary output", defvalue=True)
 
         self.add_parameter("padringfileset", "[str]", "filesets to generate a padring")
+        self.add_parameter("bumpmapfileset", "[str]", "filesets to generate a bumpmap")
+
+    def set_openroad_snapstrategy(self, snap: str,
+                                  step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the snapping strategy for macro placement.
+
+        Args:
+            snap: The snapping mode. Options are typically 'none', 'site', or 'grid'.
+            step: The specific step to apply this configuration to.
+            index: The specific index to apply this configuration to.
+        """
+        self.set("var", "ifp_snap_strategy", snap, step=step, index=index)
+
+    def set_openroad_removebuffers(self, enable: bool,
+                                   step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Enables or disables the removal of buffers inserted during synthesis.
+
+        Args:
+            enable: True to remove synthesis buffers, False to keep them.
+            step: The specific step to apply this configuration to.
+            index: The specific index to apply this configuration to.
+        """
+        self.set("var", "remove_synth_buffers", enable, step=step, index=index)
+
+    def set_openroad_removedeadlogic(self, enable: bool,
+                                     step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Enables or disables the removal of logic that does not drive a primary output.
+
+        Args:
+            enable: True to remove dead logic, False to keep it.
+            step: The specific step to apply this configuration to.
+            index: The specific index to apply this configuration to.
+        """
+        self.set("var", "remove_dead_logic", enable, step=step, index=index)
+
+    def add_openroad_padringfileset(self, fileset: Union[str, List[str]],
+                                    step: Optional[str] = None, index: Optional[str] = None,
+                                    clobber: bool = False):
+        """
+        Adds fileset(s) used to generate the I/O pad ring.
+
+        Args:
+            fileset: A string name or list of names representing the padring filesets.
+            step: The specific step to apply this configuration to.
+            index: The specific index to apply this configuration to.
+            clobber: If True, overwrites the existing padring fileset list.
+                     If False, appends to the existing list.
+        """
+        if clobber:
+            self.set("var", "padringfileset", fileset, step=step, index=index)
+        else:
+            self.add("var", "padringfileset", fileset, step=step, index=index)
+
+    def add_openroad_bumpmapfileset(self, fileset: Union[str, List[str]],
+                                    step: Optional[str] = None, index: Optional[str] = None,
+                                    clobber: bool = False):
+        """
+        Adds fileset(s) used to generate the bump map for flip-chip or 3D designs.
+
+        Args:
+            fileset: A string name or list of names representing the bumpmap filesets.
+            step: The specific step to apply this configuration to.
+            index: The specific index to apply this configuration to.
+            clobber: If True, overwrites the existing bumpmap fileset list.
+                     If False, appends to the existing list.
+        """
+        if clobber:
+            self.set("var", "bumpmapfileset", fileset, step=step, index=index)
+        else:
+            self.add("var", "bumpmapfileset", fileset, step=step, index=index)
 
     def task(self):
         return "init_floorplan"
@@ -62,8 +141,41 @@ class InitFloorplanTask(APRTask,
             for fileset in self.get("var", "padringfileset"):
                 self.add_required_key(self.project.design, "fileset", fileset, "file", "tcl")
 
-    def add_openroad_padringfileset(self, fileset: str, clobber=False):
-        if clobber:
-            self.set("var", "padringfileset", fileset)
+        if self.get("var", "bumpmapfileset"):
+            self.add_required_key("var", "bumpmapfileset")
+
+            for fileset in self.get("var", "bumpmapfileset"):
+                self.add_required_key(self.project.design, "fileset", fileset, "file", "bmap")
+
+        # Mark requires for components, pin, and floorplan placements
+        for component in self.project.constraint.component.get_component().values():
+            if component.get_placement(step=self.step, index=self.index) is not None:
+                self.add_required_key(component, "placement")
+                self.add_required_key(component, "rotation")
+            if component.get_halo(step=self.step, index=self.index) is not None:
+                self.add_required_key(component, "halo")
+            if component.get_partname(step=self.step, index=self.index):
+                self.add_required_key(component, "partname")
+
+        for pin in self.project.constraint.pin.get_pinconstraint().values():
+            if pin.get_placement(step=self.step, index=self.index) is not None:
+                self.add_required_key(pin, "placement")
+            if pin.get_layer(step=self.step, index=self.index) is not None:
+                self.add_required_key(pin, "layer")
+            if pin.get_side(step=self.step, index=self.index) is not None:
+                self.add_required_key(pin, "side")
+            if pin.get_order(step=self.step, index=self.index) is not None:
+                self.add_required_key(pin, "order")
+
+        self.add_required_key(self.mainlib, "asic", "site")
+        if self.project.constraint.area.get_diearea(step=self.step, index=self.index) and \
+                self.project.constraint.area.get_corearea(step=self.step, index=self.index):
+            self.add_required_key(self.project.constraint.area, "diearea")
+            self.add_required_key(self.project.constraint.area, "corearea")
         else:
-            self.add("var", "padringfileset", fileset)
+            self.add_required_key(self.project.constraint.area, "aspectratio")
+            self.add_required_key(self.project.constraint.area, "density")
+            self.add_required_key(self.project.constraint.area, "coremargin")
+
+        if self.mainlib.get("tool", "openroad", "tracks"):
+            self.add_required_key(self.mainlib, "tool", "openroad", "tracks")