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

siliconcompiler/tools/ghdl/convert.py

@@ -1,3 +1,4 @@
+from typing import Optional
 from siliconcompiler import Task
 
 
@@ -12,10 +13,44 @@ class ConvertTask(Task):
         self.add_parameter("use_latches", "bool", "add the --latches flag", defvalue=False)
 
     def set_usefsynopsys(self, value: bool):
-        self.set("var", "use_fsynopsys", value)
+        """Deprecated: use set_ghdl_usefsynopsys instead."""
+        import warnings
+        warnings.warn("set_usefsynopsys is deprecated, use set_ghdl_usefsynopsys instead.",
+                      DeprecationWarning, stacklevel=2)
+        self.set_ghdl_usefsynopsys(value)
+
+    def set_ghdl_usefsynopsys(self, value: bool,
+                              step: Optional[str] = None,
+                              index: Optional[str] = None):
+        """
+        Adds the -fsynopsys flag to the GHDL command.
+
+        Args:
+            value (bool): Whether to add the flag.
+            step (str, optional): The step to associate with this setting.
+            index (str, optional): The index to associate with this setting.
+        """
+        self.set("var", "use_fsynopsys", value, step=step, index=index)
 
     def set_uselatches(self, value: bool):
-        self.set("var", "use_latches", value)
+        """Deprecated: use set_ghdl_uselatches instead."""
+        import warnings
+        warnings.warn("set_uselatches is deprecated, use set_ghdl_uselatches instead.",
+                      DeprecationWarning, stacklevel=2)
+        self.set_ghdl_uselatches(value)
+
+    def set_ghdl_uselatches(self, value: bool,
+                            step: Optional[str] = None,
+                            index: Optional[str] = None):
+        """
+        Adds the --latches flag to the GHDL command.
+
+        Args:
+            value (bool): Whether to add the flag.
+            step (str, optional): The step to associate with this setting.
+            index (str, optional): The index to associate with this setting.
+        """
+        self.set("var", "use_latches", value, step=step, index=index)
 
     def tool(self):
         return "ghdl"

siliconcompiler/tools/icarus/compile.py

@@ -1,3 +1,4 @@
+from typing import Optional
 from siliconcompiler import Task
 
 
@@ -14,6 +15,19 @@ class CompileTask(Task):
                            'See the corresponding "-g" flags in the Icarus manual for more "'
                            '"information.')
 
+    def set_icarus_veriloggeneration(self, gen: str,
+                                     step: Optional[str] = None,
+                                     index: Optional[str] = None):
+        """
+        Sets the Verilog language generation for Icarus.
+
+        Args:
+            gen (str): The Verilog generation to use.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "verilog_generation", gen, step=step, index=index)
+
     def tool(self):
         return "icarus"
 

siliconcompiler/tools/keplerformal/__init__.py

@@ -0,0 +1,7 @@
+'''
+Kepler-Formal is a logic equivalence checking (LEC) tool that operates on verilog
+and the naja interchange format (https://github.com/najaeda/naja-if) and focuses
+today on combinational equivalence checking only.
+
+Sources: https://github.com/keplertech/kepler-formal
+'''

siliconcompiler/tools/keplerformal/lec.py

@@ -0,0 +1,112 @@
+import os.path
+
+from siliconcompiler import Task
+from siliconcompiler.utils import sc_open
+
+
+class LECTask(Task):
+    """LEC task using Kepler-formal for logical equivalence checking."""
+    def tool(self) -> str:
+        return "kepler-formal"
+
+    def task(self) -> str:
+        return "lec"
+
+    def setup(self) -> None:
+        super().setup()
+
+        self.set_exe("kepler-formal")
+
+        # Log file handled by kepler-formal config
+        self.set_logdestination("stdout", "none")
+        self.set_logdestination("stderr", "none")
+
+        if f"{self.design_topmodule}.lec.vg" in self.get_files_from_input_nodes():
+            inputnodes = self.get_files_from_input_nodes()[f"{self.design_topmodule}.lec.vg"]
+            if len(inputnodes) != 2:
+                raise ValueError("LEC requires exactly two input netlists for comparison.")
+            for node in inputnodes:
+                self.add_input_file(
+                    self.compute_input_file_node_name(f"{self.design_topmodule}.lec.vg", *node))
+
+        scenarios = self.project.constraint.timing.get_scenario()
+        if not scenarios:
+            raise ValueError("LEC requires at least one timing scenario to determine "
+                             "library corners.")
+        scenario = list(scenarios.values())[0]
+        libcorners = scenario.get_libcorner(self.step, self.index)
+        delay_model = self.project.get("asic", "delaymodel")
+        for asiclib in self.project.get("asic", "asiclib"):
+            lib = self.project.get("library", asiclib, field="schema")
+            for corner in libcorners:
+                if not lib.valid("asic", "libcornerfileset", corner, delay_model):
+                    continue
+                self.add_required_key(lib, "asic", "libcornerfileset", corner, delay_model)
+                for fileset in lib.get("asic", "libcornerfileset", corner, delay_model):
+                    self.add_required_key(lib, "fileset", fileset, "file", "liberty")
+
+    def __config_file(self) -> str:
+        return "lec.yaml"
+
+    def pre_process(self):
+        super().pre_process()
+
+        with open(self.__config_file(), "w") as f:
+            f.write("format: verilog\n")
+            f.write("input_paths:\n")
+            for node in self.get_files_from_input_nodes()[f"{self.design_topmodule}.lec.vg"]:
+                filename = self.compute_input_file_node_name(f"{self.design_topmodule}.lec.vg",
+                                                             *node)
+                f.write(f"  - inputs/{filename}\n")
+            f.write("liberty_files:\n")
+
+            scenario = list(self.project.constraint.timing.get_scenario().values())[0]
+            libcorners = scenario.get_libcorner(self.step, self.index)
+            delay_model = self.project.get("asic", "delaymodel")
+            for asiclib in self.project.get("asic", "asiclib"):
+                lib = self.project.get("library", asiclib, field="schema")
+                for corner in libcorners:
+                    if not lib.valid("asic", "libcornerfileset", corner, delay_model):
+                        continue
+                    for fileset in lib.get("asic", "libcornerfileset", corner, delay_model):
+                        for file in lib.get_file(fileset=fileset, filetype="liberty"):
+                            f.write(f"  - {file}\n")
+            f.write(f"log_file: {self.get_logpath('exe')}\n")
+
+    def runtime_options(self):
+        options = super().runtime_options()
+        options.append("--config")
+        options.append(self.__config_file())
+        return options
+
+    def post_process(self):
+        super().post_process()
+        # Kepler-formal writes its own log file; nothing to do here.
+        errors = 0
+        log = self.get_logpath('exe')
+        if os.path.exists(log):
+            with sc_open(log, 'r') as f:
+                for logline in f:
+                    if "Found difference " in logline:
+                        errors += 1
+
+            self.record_metric("drvs", errors, source_file=log)
+
+    @classmethod
+    def make_docs(cls):
+        from siliconcompiler import Flowgraph, Design, ASIC
+        from siliconcompiler.scheduler import SchedulerNode
+        from siliconcompiler.targets import freepdk45_demo
+        design = Design("<design>")
+        with design.active_fileset("docs"):
+            design.set_topmodule("top")
+        proj = ASIC(design)
+        proj.add_fileset("docs")
+        freepdk45_demo(proj)
+        flow = Flowgraph("docsflow")
+        flow.node("<step>", cls(), index="<index>")
+        proj.set_flow(flow)
+
+        node = SchedulerNode(proj, "<step>", "<index>")
+        node.setup()
+        return node.task

siliconcompiler/tools/klayout/drc.py

@@ -2,6 +2,7 @@ import shlex
 
 import os.path
 
+from typing import Optional
 from xml.etree import ElementTree
 
 from siliconcompiler.tools.klayout import KLayoutTask
@@ -14,6 +15,19 @@ class DRCTask(KLayoutTask):
 
         self.add_parameter("drc_name", "str", "name of the DRC deck to run")
 
+    def set_klayout_drcname(self, name: str,
+                            step: Optional[str] = None,
+                            index: Optional[str] = None):
+        """
+        Sets the name of the DRC deck to run.
+
+        Args:
+            name (str): The name of the DRC deck.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "drc_name", name, step=step, index=index)
+
     def task(self):
         return "drc"
 

siliconcompiler/tools/klayout/export.py

@@ -1,3 +1,4 @@
+from typing import Optional
 from siliconcompiler.tools.klayout import KLayoutTask
 from siliconcompiler.tools.klayout.screenshot import ScreenshotParams
 
@@ -13,6 +14,45 @@ class ExportTask(KLayoutTask, ScreenshotParams):
                            "true/false: true will cause KLayout to generate a screenshot of "
                            "the layout", defvalue=True)
 
+    def set_klayout_stream(self, stream: str,
+                           step: Optional[str] = None,
+                           index: Optional[str] = None):
+        """
+        Sets the stream format for generation.
+
+        Args:
+            stream (str): The stream format to use.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "stream", stream, step=step, index=index)
+
+    def set_klayout_timestamps(self, enable: bool,
+                               step: Optional[str] = None,
+                               index: Optional[str] = None):
+        """
+        Enables or disables exporting GDSII with timestamps.
+
+        Args:
+            enable (bool): Whether to enable timestamps.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "timestamps", enable, step=step, index=index)
+
+    def set_klayout_screenshot(self, enable: bool,
+                               step: Optional[str] = None,
+                               index: Optional[str] = None):
+        """
+        Enables or disables generating a screenshot of the layout.
+
+        Args:
+            enable (bool): Whether to generate a screenshot.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "screenshot", enable, step=step, index=index)
+
     def task(self):
         return "export"
 

siliconcompiler/tools/klayout/operations.py

@@ -1,3 +1,4 @@
+from typing import Optional, List, Tuple
 from siliconcompiler.tools.klayout import KLayoutTask
 
 
@@ -15,6 +16,45 @@ class OperationsTask(KLayoutTask):
         self.add_parameter("timestamps", "bool",
                            "Export GDSII with timestamps", defvalue=True)
 
+    def set_klayout_operations(self, operations: List[Tuple[str, str]],
+                               step: Optional[str] = None,
+                               index: Optional[str] = None):
+        """
+        Sets the list of operations to perform.
+
+        Args:
+            operations (List[Tuple[str, str]]): The list of operations.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "operations", operations, step=step, index=index)
+
+    def set_klayout_stream(self, stream: str,
+                           step: Optional[str] = None,
+                           index: Optional[str] = None):
+        """
+        Sets the stream format for generation.
+
+        Args:
+            stream (str): The stream format to use.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "stream", stream, step=step, index=index)
+
+    def set_klayout_timestamps(self, enable: bool,
+                               step: Optional[str] = None,
+                               index: Optional[str] = None):
+        """
+        Enables or disables exporting GDSII with timestamps.
+
+        Args:
+            enable (bool): Whether to enable timestamps.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "timestamps", enable, step=step, index=index)
+
     def task(self):
         return "operations"
 

siliconcompiler/tools/klayout/screenshot.py

@@ -1,3 +1,5 @@
+from typing import Optional, Union
+
 from siliconcompiler import ScreenshotTask, Task
 from siliconcompiler.tools.klayout.show import ShowTask
 
@@ -20,7 +22,70 @@ class ScreenshotParams(Task):
         self.add_parameter("show_linewidth", "int",
                            "Width of lines in detailed screenshots", defvalue=0, unit="px")
         self.add_parameter("show_oversampling", "int",
-                           "Image oversampling used in detailed screenshots'", defvalue=2)
+                           "Image oversampling used in detailed screenshots", defvalue=2)
+
+    def set_klayout_bins(self, xbins: int, ybins: int,
+                         step: Optional[str] = None, index: Optional[Union[str, int]] = None):
+        """
+        Set the number of bins for KLayout screenshotting.
+
+        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", "show_bins", (xbins, ybins), step=step, index=index)
+
+    def set_klayout_margin(self, margin: float,
+                           step: Optional[str] = None, index: Optional[Union[str, int]] = None):
+        """
+        Set the margin for KLayout screenshotting.
+
+        Args:
+            margin (float): Margin around the design in microns.
+            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", "show_margin", margin, step=step, index=index)
+
+    def set_klayout_resolution(self, xres: int, yres: int,
+                               step: Optional[str] = None, index: Optional[Union[str, int]] = None):
+        """
+        Set the resolution for KLayout screenshotting.
+
+        Args:
+            xres (int): Horizontal resolution in pixels.
+            yres (int): Vertical resolution in pixels.
+            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", "show_resolution", (xres, yres), step=step, index=index)
+
+    def set_klayout_linewidth(self, linewidth: int,
+                              step: Optional[str] = None, index: Optional[Union[str, int]] = None):
+        """
+        Set the linewidth for KLayout screenshotting.
+
+        Args:
+            linewidth (int): Width of lines in detailed screenshots.
+            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", "show_linewidth", linewidth, step=step, index=index)
+
+    def set_klayout_oversampling(self, oversampling: int,
+                                 step: Optional[str] = None,
+                                 index: Optional[Union[str, int]] = None):
+        """
+        Set the oversampling for KLayout screenshotting.
+
+        Args:
+            oversampling (int): Image oversampling used in detailed screenshots.
+            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", "show_oversampling", oversampling, step=step, index=index)
 
     def setup(self):
         super().setup()

siliconcompiler/tools/klayout/scripts/klayout_export.py

@@ -39,24 +39,23 @@ import sys
 import fnmatch
 
 
-def gds_export(design_name, in_def, in_files, out_file, tech, allow_missing, config_file='',
-               seal_file='',
-               timestamps=True):
+def gds_export(design_name, in_def, out_file, tech, allow_missing, timestamps=True):
     from klayout_utils import get_write_options  # noqa E402
 
     # Load def file
     main_layout = pya.Layout()
     main_layout.technology_name = tech.name
-    main_layout.read(in_def, tech.load_layout_options)
+    layout_options = tech.load_layout_options
+    main_layout.read(in_def, layout_options)
 
     # List cells
     def_cells = []
-    for def_cell in main_layout.each_cell():
-        def_cells.append(def_cell.name)
+    for cell_idx in main_layout.cell(design_name).each_child_cell():
+        def_cells.append(main_layout.cell_name(cell_idx))
 
-    def_cells.remove(design_name)
     # Remove vias
-    def_cells = sorted([cell for cell in def_cells if not cell.startswith("VIA_")])
+    via_prefix = layout_options.lefdef_config.via_cellname_prefix
+    def_cells = sorted([cell for cell in def_cells if not cell.startswith(via_prefix)])
     print(f"[INFO] Read in {len(def_cells)} cells from DEF file")
     for cell in def_cells:
         print(f"  [INFO] DEF cell: {cell}")
@@ -65,16 +64,11 @@ def gds_export(design_name, in_def, in_files, out_file, tech, allow_missing, con
         def_cells.remove(f"{design_name}_DEF_FILL")
 
     # Load in the gds to merge
-    print("[INFO] Merging GDS/OAS files...")
-    for fil in in_files:
+    for fil in layout_options.lefdef_config.macro_layout_files:
         macro_layout = pya.Layout()
         macro_layout.read(fil)
-        print(f"[INFO] Read in {fil}")
         for cell in list(def_cells):
             if macro_layout.has_cell(cell):
-                subcell = main_layout.cell(cell)
-                print(f"  [INFO] Merging in {cell}")
-                subcell.copy_tree(macro_layout.cell(cell))
                 def_cells.remove(cell)
 
     # Copy the top level only to a new layout
@@ -100,18 +94,6 @@ def gds_export(design_name, in_def, in_files, out_file, tech, allow_missing, con
         if i.name != design_name and i.parent_cells() == 0:
             print("[ERROR] Found orphan cell '{0}'".format(i.name))
 
-    if seal_file:
-        top_cell = top_only_layout.top_cell()
-
-        print("[INFO] Reading seal GDS/OAS file...")
-        print("\t{0}".format(seal_file))
-        top_only_layout.read(seal_file)
-
-        for cell in top_only_layout.top_cells():
-            if cell != top_cell:
-                print("[INFO] Merging '{0}' as child of '{1}'".format(cell.name, top_cell.name))
-                top.insert(pya.CellInstArray(cell.cell_index(), pya.Trans()))
-
     # Write out the GDS
     print("[INFO] Writing out GDS/OAS '{0}'".format(out_file))
     top_only_layout.write(out_file, get_write_options(out_file, timestamps))
@@ -125,7 +107,6 @@ def main():
 
     from klayout_utils import (
         technology,
-        get_streams,
         save_technology,
         get_schema,
         generate_metrics
@@ -155,18 +136,8 @@ def main():
 
     out_file = os.path.join('outputs', f'{design}.{sc_stream}')
 
-    in_files = []
-    libs = schema.get("asic", "asiclib")
-    for lib in libs:
-        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
-
     allow_missing = []
-    for lib in libs:
+    for lib in schema.get("asic", "asiclib"):
         if schema.valid('library', lib, 'tool', 'klayout', 'allow_missing_cell'):
             patterns = [pattern for pattern in schema.get('library', lib, 'tool', 'klayout',
                                                           'allow_missing_cell') if pattern]
@@ -179,8 +150,7 @@ def main():
 
     sc_tech = technology(design, schema)
 
-    gds_export(design, in_def, in_files, out_file, sc_tech, allow_missing,
-               config_file='', seal_file='', timestamps=sc_timestamps)
+    gds_export(design, in_def, out_file, sc_tech, allow_missing, timestamps=sc_timestamps)
 
     if sc_screenshot:
         show(schema, sc_tech, out_file, f'outputs/{design}.png', screenshot=True)

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)

siliconcompiler/tools/klayout/scripts/klayout_utils.py

@@ -76,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:
@@ -98,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:

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

@@ -51,6 +51,8 @@ class OpenROADPDK(PDK):
                                    "router and only uses the specified tech vias")
         self.define_tool_parameter("openroad", "drt_repair_pdn_vias", "str",
                                    "Via layer to repair after detailed routing")
+        self.define_tool_parameter("openroad", "drt_via_in_pin_layers", "(str,str)",
+                                   "Tuple of layers for vias in pin layers")
 
     def set_openroad_rclayers(self, signal: str = None, clock: str = None):
         """
@@ -155,6 +157,15 @@ class OpenROADPDK(PDK):
         """
         self.set("tool", "openroad", "drt_repair_pdn_vias", layer)
 
+    def set_openroad_detailedrouteviainpinlayers(self, layer1: str, layer2: str):
+        """Sets the via layers used in pin layers during detailed routing.
+
+        Args:
+            layer1 (str): The first layer for vias in pin layers.
+            layer2 (str): The second layer for vias in pin layers.
+        """
+        self.set("tool", "openroad", "drt_via_in_pin_layers", (layer1, layer2))
+
 
 class OpenROADStdCellLibrary(StdCellLibrary):
     """