librelane 2.4.0.dev8__tar.gz → 3.0.0.dev22__tar.gz

{librelane-2.4.0.dev8 → librelane-3.0.0.dev22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: librelane
-Version: 2.4.0.dev8
+Version: 3.0.0.dev22
 Summary: An infrastructure for implementing chip design flows
 Home-page: https://github.com/librelane/librelane
 License: Apache-2.0

{librelane-2.4.0.dev8 → librelane-3.0.0.dev22}/librelane/__main__.py

@@ -85,28 +85,25 @@ def run(
 
         for config_file in config_files:
             if meta := Config.get_meta(config_file):
-                # to maintain backwards compat, in 3 you will need to explicitly
-                # set the flow you're substituting
-                target_flow_desc = meta.flow or "Classic"
-
-                if isinstance(target_flow_desc, str):
-                    if found := Flow.factory.get(target_flow_desc):
+                if isinstance(meta.flow, str):
+                    if found := Flow.factory.get(meta.flow):
                         TargetFlow = found
                     else:
                         err(
                             f"Unknown flow '{meta.flow}' specified in configuration file's 'meta' object."
                         )
                         ctx.exit(1)
-                elif isinstance(target_flow_desc, list):
-                    TargetFlow = SequentialFlow.make(target_flow_desc)
-                if meta.substituting_steps is not None and issubclass(
-                    TargetFlow, SequentialFlow
-                ):
+                elif isinstance(meta.flow, list):
+                    TargetFlow = SequentialFlow.make(meta.flow)
+                if meta.substituting_steps is not None:
                     if meta.flow is None:
-                        warn(
-                            'config_file currently has substituting_steps set with no flow, where it will fall back to Classic. Starting LibreLane 3.0.0, this will be an error. Please update your configuration to explicitly set "flow" to "Classic".'
-                        )
-                    TargetFlow = TargetFlow.Substitute(meta.substituting_steps)  # type: ignore  # Type checker is being rowdy with this one
+                        err("config_file has substituting_steps set with no flow.")
+                        ctx.exit(1)
+                    assert (
+                        TargetFlow is not None
+                    ), "run() failed to properly deduce TargetFlow -- please file an issue"
+                    if issubclass(TargetFlow, SequentialFlow):
+                        TargetFlow = TargetFlow.Substitute(meta.substituting_steps)  # type: ignore  # Type checker is being rowdy with this one
 
         if flow_name is not None:
             if found := Flow.factory.get(flow_name):

{librelane-2.4.0.dev8 → librelane-3.0.0.dev22}/librelane/common/__init__.py

@@ -55,7 +55,7 @@ from .types import (
     ScopedFile,
 )
 from .toolbox import Toolbox
-from .drc import DRC, Violation
+from .drc import DRC, Violation, BoundingBox
 from . import cli
 from .tpe import get_tpe, set_tpe
 from .ring_buffer import RingBuffer

{librelane-2.4.0.dev8 → librelane-3.0.0.dev22}/librelane/common/drc.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2023 Efabless Corporation
+# Copyright 2020-2025 Efabless Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -18,9 +18,19 @@ import shlex
 from enum import IntEnum
 from decimal import Decimal, InvalidOperation
 from dataclasses import dataclass, field, asdict
-from typing import List, Optional, Tuple, Dict
+from typing import List, Optional, Tuple, Dict, Iterable
 
-BoundingBox = Tuple[Decimal, Decimal, Decimal, Decimal]  # microns
+
+@dataclass
+class BoundingBox(Iterable[Decimal]):
+    llx: Decimal
+    lly: Decimal
+    urx: Decimal
+    ury: Decimal
+    info: Optional[str] = None
+
+    def __iter__(self):
+        return iter([self.llx, self.lly, self.urx, self.ury])
 
 
 @dataclass
@@ -54,6 +64,75 @@ class DRC:
     module: str
     violations: Dict[str, Violation]
 
+    @classmethod
+    def from_openroad(
+        Self,
+        report: io.TextIOWrapper,
+        module: str,
+    ) -> Tuple["DRC", int]:
+        class State(IntEnum):
+            vio_type = 0
+            src = 1
+            bbox = 10
+
+        re_violation = re.compile(r"violation type: (?P<type>.*)$")
+        re_src = re.compile(r"srcs: (?P<src1>\S+)( (?P<src2>\S+))?")
+        re_bbox = re.compile(
+            r"bbox = \((?P<llx>\S+), (?P<lly>\S+)\) - \((?P<urx>\S+), (?P<ury>\S+)\) on Layer (?P<layer>\S+)"
+        )
+        bbox_count = 0
+        violations: Dict[str, Violation] = {}
+        state = State.vio_type
+        vio_type = src1 = src2 = lly = llx = urx = ury = ""
+        for line in report:
+            line = line.strip()
+            if line.strip() == "":
+                continue
+            if state == State.vio_type:
+                vio_match = re_violation.match(line)
+                assert (
+                    vio_match is not None
+                ), f"Error while parsing drc report file: Could not match violation line '{line}'"
+                vio_type = vio_match.group("type")
+                state = State.src
+            elif state == State.src:
+                src_match = re_src.match(line)
+                assert (
+                    src_match is not None
+                ), f"Error while parsing drc report file: Could not match source line '{line}'"
+                src1 = src_match.group("src1")
+                src2 = src_match.group("src2")
+                state = State.bbox
+            elif state == State.bbox:
+                bbox_match = re_bbox.match(line)
+                assert (
+                    bbox_match is not None
+                ), f"Error while parsing drc report file: Could not match bbox line '{line}'"
+                llx = bbox_match.group("llx")
+                lly = bbox_match.group("lly")
+                urx = bbox_match.group("urx")
+                ury = bbox_match.group("ury")
+                layer = bbox_match.group("layer")
+                bbox_count += 1
+                bounding_box = BoundingBox(
+                    Decimal(llx),
+                    Decimal(lly),
+                    Decimal(urx),
+                    Decimal(ury),
+                    f"{src1} to {src2}",
+                )
+                violation = (layer, vio_type)
+                description = vio_type
+                if violations.get(vio_type) is not None:
+                    violations[vio_type].bounding_boxes.append(bounding_box)
+                else:
+                    violations[vio_type] = Violation(
+                        [violation], description, [bounding_box]
+                    )
+                state = State.vio_type
+
+        return (Self(module, violations), bbox_count)
+
     @classmethod
     def from_magic(
         Self,
@@ -125,7 +204,7 @@ class DRC:
                         f"invalid bounding box at line {i}: bounding box has {len(coord_list)}/4 elements"
                     )
 
-                bounding_box: BoundingBox = (
+                bounding_box = BoundingBox(
                     coord_list[0],
                     coord_list[1],
                     coord_list[2],
@@ -155,7 +234,7 @@ class DRC:
                         "Invalid syntax: 'box' command has less than 4 arguments"
                     )
                 lx, ly, ux, uy = components[0:4]
-                last_bounding_box = (
+                last_bounding_box = BoundingBox(
                     Decimal(lx) * cif_scale,
                     Decimal(ly) * cif_scale,
                     Decimal(ux) * cif_scale,
@@ -239,7 +318,9 @@ class DRC:
                                 multiplicity.text = str(len(violation.bounding_boxes))
                                 xf.write(cell, category, visited, multiplicity)
                                 with xf.element("values"):
-                                    llx, lly, urx, ury = bounding_box
                                     value = ET.Element("value")
-                                    value.text = f"polygon: ({llx},{lly};{urx},{lly};{urx},{ury};{llx},{ury})"
+                                    value.text = f"polygon: ({bounding_box.llx},{bounding_box.lly};{bounding_box.urx},{bounding_box.lly};{bounding_box.urx},{bounding_box.ury};{bounding_box.llx},{bounding_box.ury})"
+                                    xf.write(value)
+                                    value = ET.Element("value")
+                                    value.text = f"text: '{bounding_box.info}'"
                                     xf.write(value)

{librelane-2.4.0.dev8 → librelane-3.0.0.dev22}/librelane/common/toolbox.py

@@ -91,7 +91,7 @@ class Toolbox(object):
             corner.
         :param views_by_corner: The mapping from (wild cards) of corner names to
             views.
-        :param corner: An explicit override for the default corner. Must be a
+        :param timing_corner: An explicit override for the default corner. Must be a
             fully qualified IPVT corner.
         :returns: The created list
         """

{librelane-2.4.0.dev8 → librelane-3.0.0.dev22}/librelane/config/config.py

@@ -166,7 +166,11 @@ class Meta:
 
     version: int = 1
     flow: Union[None, str, List[str]] = None
-    substituting_steps: Union[None, Dict[str, Union[str, None]]] = None
+    substituting_steps: Union[
+        None,
+        Dict[str, Union[str, None]],
+        List[Tuple[str, Union[str, None]]],
+    ] = None
     step: Union[None, str] = None
     librelane_version: Union[None, str] = __version__
 

{librelane-2.4.0.dev8 → librelane-3.0.0.dev22}/librelane/config/flow.py

@@ -53,44 +53,12 @@ pdk_variables = [
         "The ground pin for the cells.",
         pdk=True,
     ),
-    Variable(
-        "WIRE_LENGTH_THRESHOLD",
-        Optional[Decimal],
-        "A value above which wire lengths generate warnings.",
-        units="µm",
-        pdk=True,
-    ),
     Variable(
         "TECH_LEFS",
         Dict[str, Path],
         "Map of corner patterns to to technology LEF files. A corner not matched here will not be supported by OpenRCX in the default flow.",
         pdk=True,
     ),
-    Variable(
-        "GPIO_PADS_LEF",
-        Optional[List[Path]],
-        "Path(s) to GPIO pad LEF file(s).",
-        pdk=True,
-    ),
-    Variable(
-        "GPIO_PADS_LEF_CORE_SIDE",
-        Optional[List[Path]],
-        "Path(s) to GPIO pad LEF file(s) as used for routing (?).",
-        pdk=True,
-    ),
-    Variable(
-        "GPIO_PADS_VERILOG",
-        Optional[List[Path]],
-        "Path(s) to GPIO pad Verilog models.",
-        pdk=True,
-    ),
-    Variable(
-        "GPIO_PAD_CELLS",
-        Optional[List[str]],
-        "A list of pad cell name prefixes.",
-        deprecated_names=[("GPIO_PADS_PREFIX", _prefix_to_wildcard)],
-        pdk=True,
-    ),
     Variable(
         "PRIMARY_GDSII_STREAMOUT_TOOL",
         str,
@@ -136,20 +104,6 @@ pdk_variables = [
         pdk=True,
     ),
     # Floorplanning
-    Variable(
-        "FP_TRACKS_INFO",
-        Path,
-        "A path to the a classic OpenROAD `.tracks` file. Used by the floorplanner to generate tracks.",
-        deprecated_names=["TRACKS_INFO_FILE"],
-        pdk=True,
-    ),
-    Variable(
-        "FP_TAPCELL_DIST",
-        Decimal,
-        "The distance between tap cell columns.",
-        units="µm",
-        pdk=True,
-    ),
     Variable(
         "FP_IO_HLAYER",
         str,
@@ -190,16 +144,18 @@ scl_variables = [
         pdk=True,
     ),
     Variable(
-        "FILL_CELL",
+        "FILL_CELLS",
         List[str],
         "A list of cell names or wildcards of fill cells to be used in fill insertion.",
         pdk=True,
+        deprecated_names=["FILL_CELL"],
     ),
     Variable(
-        "DECAP_CELL",
+        "DECAP_CELLS",
         List[str],
         "A list of cell names or wildcards of decap cells to be used in fill insertion.",
         pdk=True,
+        deprecated_names=["DECAP_CELL"],
     ),
     Variable(
         "LIB",
@@ -348,20 +304,6 @@ scl_variables = [
         "Defines a buffer port to be used by yosys during synthesis: in the format `{cell}/{input_port}/{output_port}`",
         pdk=True,
     ),
-    Variable(
-        "WELLTAP_CELL",
-        str,
-        "Defines the cell used for tap insertion.",
-        pdk=True,
-        deprecated_names=["FP_WELLTAP_CELL"],
-    ),
-    Variable(
-        "ENDCAP_CELL",
-        str,
-        "Defines so-called 'end-cap' cells- decap cells placed at either sides of a design.",
-        pdk=True,
-        deprecated_names=["FP_ENDCAP_CELL"],
-    ),
     # Placement
     Variable(
         "PLACE_SITE",
@@ -379,9 +321,23 @@ scl_variables = [
     Variable(
         "DIODE_CELL",
         Optional[str],
-        "Defines a diode cell used to fix antenna violations, in the format {name}/{port}.",
+        "Defines a diode cell used to fix antenna violations, in the format {name}/{port}. If not defined, steps should not attempt to repair the antenna effect by inserting diode cells.",
         pdk=True,
     ),
+    Variable(
+        "WELLTAP_CELL",
+        Optional[str],
+        "Defines the cell used for tap insertion. If not defined, steps should not attempt to insert welltap cells.",
+        pdk=True,
+        deprecated_names=["FP_WELLTAP_CELL"],
+    ),
+    Variable(
+        "ENDCAP_CELL",
+        Optional[str],
+        "Defines the so-called 'end-cap' cell- class of decap cells placed at either sides of a design, if available.",
+        pdk=True,
+        deprecated_names=["FP_ENDCAP_CELL"],
+    ),
 ]
 option_variables = [
     # Common
@@ -474,17 +430,46 @@ option_variables = [
         "Specifies LIB files of pre-hardened macros used in the current design, used during timing analyses (and during parasitics-based STA as a fallback). These are loaded indiscriminately for all timing corners.",
     ),
     Variable(
-        "EXTRA_GDS_FILES",
+        "EXTRA_GDS",
         Optional[List[Path]],
         "Specifies GDS files of pre-hardened macros used in the current design, used during tape-out.",
+        deprecated_names=["EXTRA_GDS_FILES"],
     ),
     Variable(
-        "FALLBACK_SDC_FILE",
+        "FALLBACK_SDC",
         Path,
         "A fallback SDC file for when a step-specific SDC file is not defined.",
-        deprecated_names=["BASE_SDC_FILE", "SDC_FILE"],
+        deprecated_names=["FALLBACK_SDC_FILE", "BASE_SDC_FILE", "SDC_FILE"],
         default=Path(os.path.join(get_script_dir(), "base.sdc")),
     ),
 ]
 
+__for_whenever_we_implement_padring = [
+    Variable(
+        "GPIO_PADS_LEF",
+        Optional[List[Path]],
+        "Path(s) to GPIO pad LEF file(s).",
+        pdk=True,
+    ),
+    Variable(
+        "GPIO_PADS_LEF_CORE_SIDE",
+        Optional[List[Path]],
+        "Path(s) to GPIO pad LEF file(s) as used for routing (?).",
+        pdk=True,
+    ),
+    Variable(
+        "GPIO_PADS_VERILOG",
+        Optional[List[Path]],
+        "Path(s) to GPIO pad Verilog models.",
+        pdk=True,
+    ),
+    Variable(
+        "GPIO_PAD_CELLS",
+        Optional[List[str]],
+        "A list of pad cell name prefixes.",
+        deprecated_names=[("GPIO_PADS_PREFIX", _prefix_to_wildcard)],
+        pdk=True,
+    ),
+]
+
 flow_common_variables = pdk_variables + scl_variables + option_variables

{librelane-2.4.0.dev8 → librelane-3.0.0.dev22}/librelane/config/pdk_compat.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Efabless Corporation
+# Copyright 2023-2025 Efabless Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@
 import os
 import re
 from glob import glob
-from typing import Any, List, Mapping, Dict
+from typing import Any, Dict, List, Mapping
 
 
 def migrate_old_config(config: Mapping[str, Any]) -> Dict[str, Any]:
@@ -214,6 +214,83 @@ def migrate_old_config(config: Mapping[str, Any]) -> Dict[str, Any]:
                 "max_ss_100C_1v60",
                 "max_ff_n40C_1v95",
             ]
+
+        # Code below adapted from OpenROAD Flow Scripts under the following license:
+        #
+        # BSD 3-Clause License
+        #
+        # Copyright (c) 2018-2023, The Regents of the University of California
+        # All rights reserved.
+        #
+        # Redistribution and use in source and binary forms, with or without
+        # modification, are permitted provided that the following conditions are met:
+
+        # * Redistributions of source code must retain the above copyright notice, this
+        #   list of conditions and the following disclaimer.
+        #
+        # * Redistributions in binary form must reproduce the above copyright notice,
+        #   this list of conditions and the following disclaimer in the documentation
+        #   and/or other materials provided with the distribution.
+        #
+        # * Neither the name of the copyright holder nor the names of its
+        #   contributors may be used to endorse or promote products derived from
+        #   this software without specific prior written permission.
+        #
+        # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+        #            new["LAYERS_RC"] = {
+        #                "*tt*": {
+        #                    "li1": {"res": 7.176e-02, "cap": 1.499e-04},
+        #                    "met1": {"res": 8.929e-04, "cap": 1.72375e-04},
+        #                    "met2": {"res": 8.929e-04, "cap": 1.36233e-04},
+        #                    "met3": {"res": 1.567e-04, "cap": 2.14962e-04},
+        #                    "met4": {"res": 1.567e-04, "cap": 1.54087e-04},
+        #                    "met5": {"res": 1.781e-05, "cap": 1.54087e-04},
+        #                },
+        #                "*ff*": {
+        #                    "li1": {"res": 0.050232, "cap": 0.00010493},
+        #                    "met1": {"res": 0.0006250299999999999, "cap": 0.0001206625},
+        #                    "met2": {"res": 0.0006250299999999999, "cap": 9.53631e-05},
+        #                    "met3": {
+        #                        "res": 0.00010968999999999999,
+        #                        "cap": 0.00015047339999999998,
+        #                    },
+        #                    "met4": {
+        #                        "res": 0.00010968999999999999,
+        #                        "cap": 0.00010786089999999998,
+        #                    },
+        #                    "met5": {"res": 1.2467e-05, "cap": 0.00010786089999999998},
+        #                },
+        #                "*ss*": {
+        #                    "li1": {"res": 0.09328800000000001, "cap": 0.00019487},
+        #                    "met1": {"res": 0.00116077, "cap": 0.00022408750000000002},
+        #                    "met2": {"res": 0.00116077, "cap": 0.0001771029},
+        #                    "met3": {"res": 0.00020370999999999999, "cap": 0.0002794506},
+        #                    "met4": {
+        #                        "res": 0.00020370999999999999,
+        #                        "cap": 0.00020031309999999998,
+        #                    },
+        #                    "met5": {"res": 2.3153e-05, "cap": 0.00020031309999999998},
+        #                },
+        #            }
+        #            new["VIAS_RC"] = {
+        #                "*": {
+        #                    "mcon": {"res": 9.249146e-3},
+        #                    "via": {"res": 4.5e-3},
+        #                    "via2": {"res": 3.368786e-3},
+        #                    "via3": {"res": 0.376635e-3},
+        #                    "via4": {"res": 0.00580e-3},
+        #                }
+        #            }
         elif new["PDK"].startswith("gf180mcu"):
             new["STA_CORNERS"] = [
                 "nom_tt_025C_5v00",

{librelane-2.4.0.dev8 → librelane-3.0.0.dev22}/librelane/config/preprocessor.py

@@ -180,7 +180,7 @@ class Expr(object):
                     eval_stack.pop()
                     eval_stack.pop()
 
-                    result = Decimal(0.0)
+                    result = Decimal("0")
                     if token.value == "**":
                         result = number1**number2
                     elif token.value == "*":

{librelane-2.4.0.dev8 → librelane-3.0.0.dev22}/librelane/config/variable.py

@@ -160,7 +160,7 @@ class Macro:
         self, df: DesignFormat
     ) -> Union[None, Path, List[Path], Dict[str, List[Path]]]:
         try:
-            return getattr(self, df.value.id)
+            return getattr(self, df.id)
         except AttributeError:
             return None
 
@@ -593,7 +593,7 @@ class Variable:
                     value=field_value,
                     explicitly_specified=explicitly_specified,
                     default=field_default,
-                    validating_type=subtype,
+                    validating_type=subtype,  # type: ignore
                     permissive_typing=permissive_typing,
                     depth=depth + 1,
                 )

{librelane-2.4.0.dev8 → librelane-3.0.0.dev22}/librelane/flows/classic.py

@@ -51,6 +51,7 @@ class Classic(SequentialFlow):
         OpenROAD.CheckMacroInstances,
         OpenROAD.STAPrePNR,
         OpenROAD.Floorplan,
+        OpenROAD.DumpRCValues,
         Odb.CheckMacroAntennaProperties,
         Odb.SetPowerConnections,
         Odb.ManualMacroPlacement,

{librelane-2.4.0.dev8 → librelane-3.0.0.dev22}/librelane/flows/flow.py

@@ -48,7 +48,7 @@ from deprecated.sphinx import deprecated
 from librelane.common.types import Path
 
 from ..config import Config, Variable, universal_flow_config_variables, AnyConfigs
-from ..state import State, DesignFormat, DesignFormatObject
+from ..state import State, DesignFormat
 from ..steps import Step, StepNotFound
 from ..logging import (
     LevelFilter,
@@ -804,14 +804,11 @@ class Flow(ABC):
         }
 
         def visitor(key, value, top_key, _, __):
-            df = DesignFormat.by_id(top_key)
+            df = DesignFormat.factory.get(top_key)
             assert df is not None
             if df not in supported_formats:
                 return
 
-            dfo = df.value
-            assert isinstance(dfo, DesignFormatObject)
-
             subdirectory, extension = supported_formats[df]
 
             target_dir = os.path.join(path, subdirectory)
@@ -837,7 +834,7 @@ class Flow(ABC):
                 return
 
             target_basename = os.path.basename(str(value))
-            target_basename = target_basename[: -len(dfo.extension)] + extension
+            target_basename = target_basename[: -len(df.extension)] + extension
             target_path = os.path.join(target_dir, target_basename)
             mkdirp(target_dir)
             shutil.copyfile(value, target_path, follow_symlinks=True)