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

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
@@ -411,6 +411,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 +431,7 @@ class APRTask(OpenROADTask):
             "fmax",
             "power",
             "check_setup",
+            "report_buffers",
             "placement_density",
             "routing_congestion",
             "power_density",
@@ -456,11 +465,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):
         """

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,38 @@ 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():
+            self.add_required_key(component, "placement")
+            self.add_required_key(component, "rotation")
+            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")

siliconcompiler/tools/openroad/power_grid_analysis.py

@@ -0,0 +1,174 @@
+from typing import Optional, Union
+
+from siliconcompiler.tools.openroad._apr import APRTask
+from siliconcompiler.tools.openroad._apr import OpenROADSTAParameter, OpenROADPSMParameter
+
+
+class PowerGridAnalysisTask(APRTask, OpenROADPSMParameter, OpenROADSTAParameter):
+    '''
+    Performs static IR drop analysis on the power grid using OpenROAD.
+
+    This task utilizes the OpenROAD PDN (Power Distribution Network) analysis
+    capabilities (PSM) to calculate static IR drop based on instance power
+    consumption and grid resistance.
+    '''
+
+    def __init__(self):
+        super().__init__()
+
+        self.add_parameter("source_disconnection_rate", "float",
+                           "Fraction (0.0-100.0) of power source bumps to simulate "
+                           "disconnected/failing bumps.",
+                           defvalue=0.0)
+        self.add_parameter("source_disconnection_seed", "int",
+                           "Random seed used for determining which power bumps to disconnect.",
+                           defvalue=123)
+
+        self.add_parameter("instance_power", "[(str,float)]",
+                           "List of (instance_name, power_value) tuples to override specific "
+                           "instance power consumption.")
+
+        self.add_parameter("net", "{str}",
+                           "Set of specific power/ground nets to analyze (e.g., VDD, VSS).")
+
+        self.add_parameter("heatmap_grid", "(float,float)",
+                           "Resolution of the IR drop heatmap grid (x_step, y_step).",
+                           defvalue=(10, 10), units="um")
+
+        self.add_parameter("external_resistance", "float",
+                           "Resistance value to add to the power grid model to account for "
+                           "external factors (e.g., package, PCB).",
+                           units="ohm")
+
+    def set_openroad_disconnectrate(self, rate: float,
+                                    step: Optional[str] = None,
+                                    index: Optional[Union[str, int]] = None):
+        '''
+        Sets the fraction of power pads/bumps to disconnect to simulate robustness.
+
+        Args:
+            rate (float): A value between 0.0 and 100.0 representing the percentage to disconnect.
+            step (str, optional): step name
+            index (str, optional): index
+        '''
+        self.set("var", "source_disconnection_rate", rate, step=step, index=index)
+
+    def set_openroad_disconnectseed(self, seed: int,
+                                    step: Optional[str] = None,
+                                    index: Optional[Union[str, int]] = None):
+        '''
+        Sets the random seed for the power bump disconnection logic.
+
+        Args:
+            seed (int): The random seed integer.
+            step (str, optional): step name
+            index (str, optional): index
+        '''
+        self.set("var", "source_disconnection_seed", seed, step=step, index=index)
+
+    def set_openroad_heatmapgrid(self, x: float, y: float,
+                                 step: Optional[str] = None,
+                                 index: Optional[Union[str, int]] = None):
+        '''
+        Sets the resolution for the IR drop heatmap generation.
+
+        Args:
+            x (float): Grid spacing in the X direction (microns).
+            y (float): Grid spacing in the Y direction (microns).
+            step (str, optional): step name
+            index (str, optional): index
+        '''
+        self.set("var", "heatmap_grid", (x, y), step=step, index=index)
+
+    def set_openroad_externalresistance(self, res: float,
+                                        step: Optional[str] = None,
+                                        index: Optional[Union[str, int]] = None):
+        '''
+        Sets the external resistance to be modeled in the power grid analysis.
+
+        Args:
+            res (float): External resistance to add.
+            step (str, optional): step name
+            index (str, optional): index
+        '''
+        self.set("var", "external_resistance", res, step=step, index=index)
+
+    def add_openroad_irdropnet(self, net: str,
+                               step: Optional[str] = None, index: Optional[Union[str, int]] = None,
+                               clobber: bool = False):
+        '''
+        Adds a specific net to the list of nets to be analyzed for IR drop.
+
+        Args:
+            net (str): The name of the net (e.g., "VDD").
+            step (str, optional): step name
+            index (str, optional): index
+            clobber (bool): If True, replaces existing nets. If False, appends to the list.
+        '''
+        if clobber:
+            self.set("var", "net", net, step=step, index=index)
+        else:
+            self.add("var", "net", net, step=step, index=index)
+
+    def add_openroad_instancepower(self, inst: str, power: float,
+                                   step: Optional[str] = None,
+                                   index: Optional[Union[str, int]] = None,
+                                   clobber: bool = False):
+        '''
+        Manually sets the power consumption for a specific instance.
+
+        Args:
+            inst (str): The name of the instance.
+            power (float): The power value (typically in Watts, depending on library units).
+            step (str, optional): step name
+            index (str, optional): index
+            clobber (bool): If True, replaces the existing list. If False, appends.
+        '''
+        if clobber:
+            self.set("var", "instance_power", (inst, power), step=step, index=index)
+        else:
+            self.add("var", "instance_power", (inst, power), step=step, index=index)
+
+    def task(self) -> str:
+        '''
+        Returns the internal task name for this tool task.
+        '''
+        return "irdrop_analysis"
+
+    def setup(self):
+        '''
+        Configures the tool runtime parameters, scripts, and requirements.
+        '''
+        super().setup()
+        self.set_script("apr/sc_irdrop.tcl")
+
+        self.add_version(">=v2.0-26750", clobber=True)
+
+        # Output is not a standard design file, unset default expectation
+        self.unset("output")
+
+        # Define keys required for this task to run successfully
+        self.add_required_key("var", "source_disconnection_rate")
+        self.add_required_key("var", "source_disconnection_seed")
+        self.add_required_key("var", "heatmap_grid")
+
+        # Conditionally require these keys if they have been set
+        if self.get("var", "instance_power"):
+            self.add_required_key("var", "instance_power")
+
+        if self.get("var", "net"):
+            self.add_required_key("var", "net")
+        if self.get("var", "external_resistance") is not None:
+            self.add_required_key("var", "external_resistance")
+
+    def runtime_options(self):
+        '''
+        Returns the command line arguments for the OpenROAD executable.
+
+        Ensures the GUI flag is present, as visualization is often required
+        or implied for heatmap analysis contexts in this workflow.
+        '''
+        args = super().runtime_options()
+        if "-gui" not in args:
+            args.append("-gui")
+        return args

siliconcompiler/tools/openroad/repair_design.py

@@ -34,6 +34,7 @@ class RepairDesignTask(APRTask, OpenROADSTAParameter, OpenROADRSZDRVParameter):
             'power',
             'drv_violations',
             'fmax',
+            'report_buffers',
 
             # Images
             'placement_density',

siliconcompiler/tools/openroad/repair_timing.py

@@ -37,6 +37,7 @@ class RepairTimingTask(APRTask, OpenROADSTAParameter, OpenROADDPLParameter,
             'power',
             'drv_violations',
             'fmax',
+            'report_buffers',
 
             # Images
             'placement_density',

siliconcompiler/tools/openroad/scripts/apr/preamble.tcl

@@ -89,6 +89,6 @@ if { [llength $openroad_dont_touch] > 0 } {
 tee -quiet -file reports/dont_touch.start.rpt {report_dont_touch}
 tee -quiet -file reports/dont_use.start.rpt {report_dont_use}
 tee -file reports/global_connections.start.rpt {report_global_connect}
-if { [sc_check_version 23264] } {
+if { [sc_cfg_tool_task_check_in_list report_buffers var reports] && [sc_check_version 23264] } {
     tee -quiet -file reports/report_buffers.rpt {report_buffers -filtered}
 }

siliconcompiler/tools/openroad/scripts/apr/sc_init_floorplan.tcl

@@ -73,14 +73,52 @@ if { $sc_openroad_tracks != "" } {
     make_tracks
 }
 
-# TODO
+###############################
+# Bump Creation
+###############################
+
 set do_automatic_pins 1
+if { [llength [sc_cfg_tool_task_get var bumpmapfileset]] > 0 } {
+    if { [sc_check_version 26154] == 0 } {
+        utl::error FLW 1 "bmaps are not supported in this version of openroad"
+    }
+
+    set do_automatic_pins 0
+
+    set bmaps_read []
+    set bumpmapfileset [sc_cfg_tool_task_get var bumpmapfileset]
+    set bmapfiles [sc_cfg_get_fileset $sc_designlib $bumpmapfileset bmap]
+    foreach bmap_file $bmapfiles {
+        if { [lsearch -exact $bmaps_read $bmap_file] != -1 } {
+            continue
+        }
+        puts "Reading 3DBlox bump map: ${bmap_file}"
+        read_3dblox_bmap $bmap_file
+
+        lappend bmaps_read $bmap_file
+    }
+
+    # Check ports
+    set failed 0
+    foreach port [[ord::get_db_block] getBTerms] {
+        set placement [$port getFirstPinPlacementStatus]
+        if { $placement != "FIRM" } {
+            incr failed
+            utl::warn FLW 2 "Unplaced port: [$port getName]"
+        }
+    }
+    if { $failed > 0 } {
+        utl::warn FLW 3 "There are $failed unplaced ports in the design"
+    }
+}
+
+###############################
+# Generate pad ring
+###############################
+
 if { [llength [sc_cfg_tool_task_get var padringfileset]] > 0 } {
     set do_automatic_pins 0
 
-    ###############################
-    # Generate pad ring
-    ###############################
     set padringfiles_read []
     set padringfileset [sc_cfg_tool_task_get var padringfileset]
     set padringfiles [sc_cfg_get_fileset $sc_designlib $padringfileset tcl]