librelane 3.0.0.dev24__py3-none-any.whl → 3.0.0.dev26__py3-none-any.whl

librelane/scripts/openroad/ioplacer.tcl

@@ -15,50 +15,51 @@ source $::env(SCRIPTS_DIR)/openroad/common/io.tcl
 read_current_odb
 
 if { [info exists ::env(CONTEXTUAL_IO_FLAG)] } {
-	read_lef $::env(placement_tmpfiles)/top_level.lef
+    read_lef $::env(placement_tmpfiles)/top_level.lef
 }
 
-if { [info exists ::env(FP_IO_HLENGTH)] } {
-	set_pin_length -hor_length $::env(FP_IO_HLENGTH)
+if { [info exists ::env(IO_PIN_H_LENGTH)] } {
+    set_pin_length -hor_length $::env(IO_PIN_H_LENGTH)
 }
 
-if { [info exists ::env(FP_IO_VLENGTH)] } {
-	set_pin_length -ver_length $::env(FP_IO_VLENGTH)
+if { [info exists ::env(IO_PIN_V_LENGTH)] } {
+    set_pin_length -ver_length $::env(IO_PIN_V_LENGTH)
 }
 
-if { $::env(FP_IO_HEXTEND) != "0"} {
-	set_pin_length_extension -hor_extension $::env(FP_IO_HEXTEND)
+if { $::env(IO_PIN_H_EXTENSION) != "0"} {
+    set_pin_length_extension -hor_extension $::env(IO_PIN_H_EXTENSION)
 }
 
-if { $::env(FP_IO_VEXTEND) != "0"} {
-	set_pin_length_extension -ver_extension $::env(FP_IO_VEXTEND)
+if { $::env(IO_PIN_V_EXTENSION) != "0"} {
+    set_pin_length_extension -ver_extension $::env(IO_PIN_V_EXTENSION)
 }
 
-if {$::env(FP_IO_VTHICKNESS_MULT) != "" && $::env(FP_IO_HTHICKNESS_MULT) != ""} {
-	set_pin_thick_multiplier -hor_multiplier $::env(FP_IO_HTHICKNESS_MULT) \
-		-ver_multiplier $::env(FP_IO_VTHICKNESS_MULT)
+if {$::env(IO_PIN_V_THICKNESS_MULT) != "" && $::env(IO_PIN_H_THICKNESS_MULT) != ""} {
+    set_pin_thick_multiplier\
+        -hor_multiplier $::env(IO_PIN_H_THICKNESS_MULT) \
+        -ver_multiplier $::env(IO_PIN_V_THICKNESS_MULT)
 }
 
 set arg_list [list]
-if { $::env(FP_PPL_MODE) == "random_equidistant" } {
-	lappend arg_list -random
+if { $::env(IO_PIN_PLACEMENT_MODE) == "random_equidistant" } {
+    lappend arg_list -random
 }
 
-if { [info exists ::env(FP_IO_MIN_DISTANCE)] } {
-	lappend arg_list -min_distance $::env(FP_IO_MIN_DISTANCE)
+if { [info exists ::env(IO_PIN_MIN_DISTANCE)] } {
+    lappend arg_list -min_distance $::env(IO_PIN_MIN_DISTANCE)
 }
 
-if { $::env(FP_PPL_MODE) == "annealing" } {
-	lappend arg_list -annealing
+if { $::env(IO_PIN_PLACEMENT_MODE) == "annealing" } {
+    lappend arg_list -annealing
 }
 
 set HMETAL $::env(FP_IO_HLAYER)
 set VMETAL $::env(FP_IO_VLAYER)
 
 log_cmd place_pins {*}$arg_list \
-	-random_seed 42 \
-	-hor_layers $HMETAL \
-	-ver_layers $VMETAL
+    -random_seed 42 \
+    -hor_layers $HMETAL \
+    -ver_layers $VMETAL
 
 write_views
 

librelane/scripts/openroad/pdn.tcl

@@ -21,7 +21,7 @@ source $::env(SCRIPTS_DIR)/openroad/common/set_power_nets.tcl
 read_pdn_cfg
 
 set arg_list [list]
-if { $::env(FP_PDN_SKIPTRIM) } {
+if { $::env(PDN_SKIPTRIM) } {
     lappend arg_list -skip_trim
 }
 # run PDNGEN

librelane/state/state.py

@@ -13,7 +13,9 @@
 # limitations under the License.
 from __future__ import annotations
 
+import io
 import os
+import csv
 import sys
 import json
 import shutil
@@ -209,14 +211,20 @@ class State(GenericImmutableDict[str, StateElement]):
         self._walk(self, path, visitor)
         metrics_csv_path = os.path.join(path, "metrics.csv")
         with open(metrics_csv_path, "w", encoding="utf8") as f:
-            f.write("Metric,Value\n")
-            for metric in self.metrics:
-                f.write(f"{metric},{self.metrics[metric]}\n")
+            self.metrics_to_csv(f)
 
         metrics_json_path = os.path.join(path, "metrics.json")
         with open(metrics_json_path, "w", encoding="utf8") as f:
             f.write(self.metrics.dumps())
 
+    def metrics_to_csv(
+        self, fp: io.TextIOWrapper, metrics_object: Optional[Dict[str, Any]] = None
+    ):
+        w = csv.writer(fp)
+        w.writerow(("Metric", "Value"))
+        for entry in (metrics_object or self.metrics).items():
+            w.writerow(entry)
+
     def validate(self):
         """
         Ensures that all paths exist in a State.

librelane/steps/__main__.py

@@ -15,7 +15,6 @@ import os
 import shlex
 import shutil
 import datetime
-import functools
 import subprocess
 from functools import partial
 from typing import IO, Any, Dict, Optional, Sequence, Union
@@ -239,7 +238,7 @@ def eject(ctx, output, state_in, config, id):
             found_stdin_data = found_stdin.read()
         raise Stop()
 
-    step.run_subprocess = functools.partial(
+    step.run_subprocess = partial(
         step.run_subprocess,
         _popen_callable=popen_substitute,
     )

librelane/steps/common_variables.py

@@ -18,204 +18,253 @@ from ..config import Variable
 
 io_layer_variables = [
     Variable(
-        "FP_IO_VEXTEND",
+        "IO_PIN_V_EXTENSION",
         Decimal,
         "Extends the vertical io pins outside of the die by the specified units.",
         default=0,
         units="µm",
+        deprecated_names=["FP_IO_VEXTEND"],
     ),
     Variable(
-        "FP_IO_HEXTEND",
+        "IO_PIN_H_EXTENSION",
         Decimal,
         "Extends the horizontal io pins outside of the die by the specified units.",
         default=0,
         units="µm",
+        deprecated_names=["FP_IO_HEXTEND"],
     ),
     Variable(
-        "FP_IO_VTHICKNESS_MULT",
+        "IO_PIN_V_THICKNESS_MULT",
         Decimal,
         "A multiplier for vertical pin thickness. Base thickness is the pins layer min width.",
         default=2,
+        deprecated_names=["FP_IO_VTHICKNESS_MULT"],
     ),
     Variable(
-        "FP_IO_HTHICKNESS_MULT",
+        "IO_PIN_H_THICKNESS_MULT",
         Decimal,
         "A multiplier for horizontal pin thickness. Base thickness is the pins layer min width.",
         default=2,
+        deprecated_names=["FP_IO_HTHICKNESS_MULT"],
+    ),
+    Variable(
+        "IO_PIN_V_LENGTH",
+        Optional[Decimal],
+        """
+        The length of the pins with a north or south orientation. If unspecified by a PDK, OpenROAD will use whichever is higher of the following two values:
+            * The pin width
+            * The minimum value satisfying the minimum area constraint given the pin width
+        """,
+        units="µm",
+        pdk=True,
+        deprecated_names=["FP_IO_VLENGTH"],
+    ),
+    Variable(
+        "IO_PIN_H_LENGTH",
+        Optional[Decimal],
+        """
+        The length of the pins with an east or west orientation. If unspecified by a PDK, OpenROAD will use whichever is higher of the following two values:
+            * The pin width
+            * The minimum value satisfying the minimum area constraint given the pin width
+        """,
+        units="µm",
+        pdk=True,
+        deprecated_names=["FP_IO_HLENGTH"],
     ),
 ]
 
 pdn_variables = [
     Variable(
-        "FP_PDN_SKIPTRIM",
+        "PDN_SKIPTRIM",
         bool,
         "Enables `-skip_trim` option during pdngen which skips the metal trim step, which attempts to remove metal stubs.",
         default=False,
+        deprecated_names=["FP_PDN_SKIPTRIM"],
     ),
     Variable(
-        "FP_PDN_CORE_RING",
+        "PDN_CORE_RING",
         bool,
         "Enables adding a core ring around the design. More details on the control variables in the PDK config documentation.",
         default=False,
+        deprecated_names=["FP_PDN_CORE_RING"],
     ),
     Variable(
-        "FP_PDN_ENABLE_RAILS",
+        "PDN_ENABLE_RAILS",
         bool,
         "Enables the creation of rails in the power grid.",
         default=True,
+        deprecated_names=["FP_PDN_ENABLE_RAILS"],
     ),
     Variable(
-        "FP_PDN_HORIZONTAL_HALO",
+        "PDN_HORIZONTAL_HALO",
         Decimal,
         "Sets the horizontal halo around the macros during power grid insertion.",
         default=10,
         units="µm",
+        deprecated_names=["FP_PDN_HORIZONTAL_HALO"],
     ),
     Variable(
-        "FP_PDN_VERTICAL_HALO",
+        "PDN_VERTICAL_HALO",
         Decimal,
         "Sets the vertical halo around the macros during power grid insertion.",
         default=10,
         units="µm",
+        deprecated_names=["FP_PDN_VERTICAL_HALO"],
     ),
     Variable(
-        "FP_PDN_MULTILAYER",
+        "PDN_MULTILAYER",
         bool,
         "Controls the layers used in the power grid. If set to false, only the lower layer will be used, which is useful when hardening a macro for integrating into a larger top-level design.",
         default=True,
-        deprecated_names=["DESIGN_IS_CORE"],
+        deprecated_names=["FP_PDN_MULTILAYER", "DESIGN_IS_CORE"],
     ),
     Variable(
-        "FP_PDN_RAIL_OFFSET",
+        "PDN_RAIL_OFFSET",
         Decimal,
         "The offset for the power distribution network rails for first metal layer.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_RAIL_OFFSET"],
     ),
     Variable(
-        "FP_PDN_VWIDTH",
+        "PDN_VWIDTH",
         Decimal,
         "The strap width for the vertical layer in generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_VWIDTH"],
     ),
     Variable(
-        "FP_PDN_HWIDTH",
+        "PDN_HWIDTH",
         Decimal,
         "The strap width for the horizontal layer in generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_HWIDTH"],
     ),
     Variable(
-        "FP_PDN_VSPACING",
+        "PDN_VSPACING",
         Decimal,
         "Intra-spacing (within a set) of vertical straps in generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_VSPACING"],
     ),
     Variable(
-        "FP_PDN_HSPACING",
+        "PDN_HSPACING",
         Decimal,
         "Intra-spacing (within a set) of horizontal straps in generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_HSPACING"],
     ),
     Variable(
-        "FP_PDN_VPITCH",
+        "PDN_VPITCH",
         Decimal,
         "Inter-distance (between sets) of vertical power straps in generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_VPITCH"],
     ),
     Variable(
-        "FP_PDN_HPITCH",
+        "PDN_HPITCH",
         Decimal,
         "Inter-distance (between sets) of horizontal power straps in generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_HPITCH"],
     ),
     Variable(
-        "FP_PDN_VOFFSET",
+        "PDN_VOFFSET",
         Decimal,
         "Initial offset for sets of vertical power straps.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_VOFFSET"],
     ),
     Variable(
-        "FP_PDN_HOFFSET",
+        "PDN_HOFFSET",
         Decimal,
         "Initial offset for sets of horizontal power straps.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_HOFFSET"],
     ),
     Variable(
-        "FP_PDN_CORE_RING_VWIDTH",
+        "PDN_CORE_RING_VWIDTH",
         Decimal,
         "The width for the vertical layer in the core ring of generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_CORE_RING_VWIDTH"],
     ),
     Variable(
-        "FP_PDN_CORE_RING_HWIDTH",
+        "PDN_CORE_RING_HWIDTH",
         Decimal,
         "The width for the horizontal layer in the core ring of generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_CORE_RING_HWIDTH"],
     ),
     Variable(
-        "FP_PDN_CORE_RING_VSPACING",
+        "PDN_CORE_RING_VSPACING",
         Decimal,
         "The spacing for the vertical layer in the core ring of generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_CORE_RING_VSPACING"],
     ),
     Variable(
-        "FP_PDN_CORE_RING_HSPACING",
+        "PDN_CORE_RING_HSPACING",
         Decimal,
         "The spacing for the horizontal layer in the core ring of generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_CORE_RING_HSPACING"],
     ),
     Variable(
-        "FP_PDN_CORE_RING_VOFFSET",
+        "PDN_CORE_RING_VOFFSET",
         Decimal,
         "The offset for the vertical layer in the core ring of generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_CORE_RING_VOFFSET"],
     ),
     Variable(
-        "FP_PDN_CORE_RING_HOFFSET",
+        "PDN_CORE_RING_HOFFSET",
         Decimal,
         "The offset for the horizontal layer in the core ring of generated power distribution networks.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_CORE_RING_HOFFSET"],
     ),
     Variable(
-        "FP_PDN_RAIL_LAYER",
+        "PDN_RAIL_LAYER",
         str,
         "Defines the metal layer used for PDN rails.",
-        deprecated_names=["FP_PDN_RAILS_LAYER"],
+        deprecated_names=["FP_PDN_RAIL_LAYER", "FP_PDN_RAILS_LAYER"],
         pdk=True,
     ),
     Variable(
-        "FP_PDN_RAIL_WIDTH",
+        "PDN_RAIL_WIDTH",
         Decimal,
         "Defines the width of PDN rails on the `FP_PDN_RAILS_LAYER` layer.",
         units="µm",
         pdk=True,
+        deprecated_names=["FP_PDN_RAIL_WIDTH"],
     ),
     Variable(
-        "FP_PDN_HORIZONTAL_LAYER",
+        "PDN_HORIZONTAL_LAYER",
         str,
         "Defines the horizontal PDN layer.",
-        deprecated_names=["FP_PDN_UPPER_LAYER"],
+        deprecated_names=["FP_PDN_HORIZONTAL_LAYER", "FP_PDN_UPPER_LAYER"],
         pdk=True,
     ),
     Variable(
-        "FP_PDN_VERTICAL_LAYER",
+        "PDN_VERTICAL_LAYER",
         str,
         "Defines the vertical PDN layer.",
-        deprecated_names=["FP_PDN_LOWER_LAYER"],
+        deprecated_names=["FP_PDN_VERTICAL_LAYER", "FP_PDN_LOWER_LAYER"],
         pdk=True,
     ),
 ]

librelane/steps/magic.py

@@ -14,7 +14,6 @@
 import os
 import re
 import shutil
-import functools
 import subprocess
 from signal import SIGKILL
 from decimal import Decimal
@@ -34,7 +33,8 @@ from .tclstep import TclStep
 from ..state import DesignFormat, State
 
 from ..config import Variable
-from ..common import get_script_dir, DRC as DRCObject, Path, mkdirp
+from ..common import get_script_dir, DRC as DRCObject, Path, mkdirp, count_occurences
+from ..logging import warn
 
 
 DesignFormat(
@@ -480,6 +480,12 @@ class SpiceExtraction(MagicStep):
             "Extracts a SPICE netlist based on black-boxed standard cells and macros (basically, anything with a LEF) rather than transistors. An error will be thrown if both this and `MAGIC_EXT_USE_GDS` is set to ``True``.",
             default=False,
         ),
+        Variable(
+            "MAGIC_FEEDBACK_CONVERSION_THRESHOLD",
+            int,
+            "If Magic provides more feedback items than this threshold, conversion to KLayout databases is skipped (as something has gone horribly wrong.)",
+            default=10000,
+        ),
     ]
 
     def get_script_path(self):
@@ -497,22 +503,29 @@ class SpiceExtraction(MagicStep):
 
         views_updates, metrics_updates = super().run(state_in, env=env, **kwargs)
 
-        cif_scale = Decimal(open(os.path.join(self.step_dir, "cif_scale.txt")).read())
         feedback_path = os.path.join(self.step_dir, "feedback.txt")
+        with open(feedback_path, encoding="utf8") as f:
+            illegal_overlap_count = count_occurences(f, "Illegal overlap")
+
+        metrics_updates["magic__illegal_overlap__count"] = illegal_overlap_count
+        threshold = self.config["MAGIC_FEEDBACK_CONVERSION_THRESHOLD"]
+        if illegal_overlap_count > threshold:
+            warn(
+                f"Not converting the feedback to the KLayout database format: {illegal_overlap_count} > MAGIC_FEEDBACK_CONVERSION_THRESHOLD ({threshold}). You may manually increase the threshold, but it might take forever."
+            )
+            return views_updates, metrics_updates
+
+        cif_scale = Decimal(open(os.path.join(self.step_dir, "cif_scale.txt")).read())
         try:
             se_feedback, _ = DRCObject.from_magic_feedback(
                 open(feedback_path, encoding="utf8"),
                 cif_scale,
                 self.config["DESIGN_NAME"],
             )
-            illegal_overlap_count = functools.reduce(
-                lambda a, b: a + len(b.bounding_boxes),
-                [
-                    v
-                    for v in se_feedback.violations.values()
-                    if "Illegal overlap" in v.description
-                ],
-                0,
+            illegal_overlap_count = sum(
+                len(v.bounding_boxes)
+                for v in se_feedback.violations.values()
+                if "Illegal overlap" in v.description
             )
             with open(os.path.join(self.step_dir, "feedback.xml"), "wb") as f:
                 se_feedback.to_klayout_xml(f)
@@ -521,9 +534,6 @@ class SpiceExtraction(MagicStep):
             self.warn(
                 f"Failed to convert SPICE extraction feedback to KLayout database format: {e}"
             )
-            metrics_updates["magic__illegal_overlap__count"] = (
-                open(feedback_path, encoding="utf8").read().count("Illegal overlap")
-            )
         return views_updates, metrics_updates
 
 

librelane/steps/odb.py

@@ -17,7 +17,6 @@ import json
 import shutil
 from math import inf
 from decimal import Decimal
-from functools import reduce
 from abc import abstractmethod
 from dataclasses import dataclass
 from typing import Dict, List, Literal, Optional, Tuple
@@ -418,9 +417,7 @@ class ManualMacroPlacement(OdbpyStep):
             )
             shutil.copyfile(cfg_ref, cfg_file)
         elif macros := self.config.get("MACROS"):
-            instance_count = reduce(
-                lambda x, y: x + len(y.instances), macros.values(), 0
-            )
+            instance_count = sum(len(m.instances) for m in macros.values())
             if instance_count >= 1:
                 with open(cfg_file, "w") as f:
                     for module, macro in macros.items():
@@ -618,31 +615,10 @@ class CustomIOPlacement(OdbpyStep):
 
     config_vars = io_layer_variables + [
         Variable(
-            "FP_IO_VLENGTH",
-            Optional[Decimal],
-            """
-            The length of the pins with a north or south orientation. If unspecified by a PDK, the script will use whichever is higher of the following two values:
-                * The pin width
-                * The minimum value satisfying the minimum area constraint given the pin width
-            """,
-            units="µm",
-            pdk=True,
-        ),
-        Variable(
-            "FP_IO_HLENGTH",
-            Optional[Decimal],
-            """
-            The length of the pins with an east or west orientation. If unspecified by a PDK, the script will use whichever is higher of the following two values:
-                * The pin width
-                * The minimum value satisfying the minimum area constraint given the pin width
-            """,
-            units="µm",
-            pdk=True,
-        ),
-        Variable(
-            "FP_PIN_ORDER_CFG",
+            "IO_PIN_ORDER_CFG",
             Optional[Path],
-            "Path to the configuration file. If set to `None`, this step is skipped.",
+            "Path to a custom pin configuration file.",
+            deprecated_names=["FP_PIN_ORDER_CFG"],
         ),
         Variable(
             "ERRORS_ON_UNMATCHED_IO",
@@ -660,28 +636,28 @@ class CustomIOPlacement(OdbpyStep):
 
     def get_command(self) -> List[str]:
         length_args = []
-        if self.config["FP_IO_VLENGTH"] is not None:
-            length_args += ["--ver-length", self.config["FP_IO_VLENGTH"]]
-        if self.config["FP_IO_HLENGTH"] is not None:
-            length_args += ["--hor-length", self.config["FP_IO_HLENGTH"]]
+        if self.config["IO_PIN_V_LENGTH"] is not None:
+            length_args += ["--ver-length", self.config["IO_PIN_V_LENGTH"]]
+        if self.config["IO_PIN_H_LENGTH"] is not None:
+            length_args += ["--hor-length", self.config["IO_PIN_H_LENGTH"]]
 
         return (
             super().get_command()
             + [
                 "--config",
-                self.config["FP_PIN_ORDER_CFG"],
+                self.config["IO_PIN_ORDER_CFG"],
                 "--hor-layer",
                 self.config["FP_IO_HLAYER"],
                 "--ver-layer",
                 self.config["FP_IO_VLAYER"],
                 "--hor-width-mult",
-                str(self.config["FP_IO_VTHICKNESS_MULT"]),
+                str(self.config["IO_PIN_V_THICKNESS_MULT"]),
                 "--ver-width-mult",
-                str(self.config["FP_IO_HTHICKNESS_MULT"]),
+                str(self.config["IO_PIN_H_THICKNESS_MULT"]),
                 "--hor-extension",
-                str(self.config["FP_IO_HEXTEND"]),
+                str(self.config["IO_PIN_H_EXTENSION"]),
                 "--ver-extension",
-                str(self.config["FP_IO_VEXTEND"]),
+                str(self.config["IO_PIN_V_EXTENSION"]),
                 "--unmatched-error",
                 self.config["ERRORS_ON_UNMATCHED_IO"],
             ]
@@ -689,8 +665,8 @@ class CustomIOPlacement(OdbpyStep):
         )
 
     def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
-        if self.config["FP_PIN_ORDER_CFG"] is None:
-            info(f"No custom floorplan file configured, skipping '{self.id}'…")
+        if self.config["IO_PIN_ORDER_CFG"] is None:
+            info(f"No custom I/O placement file configured, skipping '{self.id}'…")
             return {}, {}
         return super().run(state_in, **kwargs)