librelane 2.4.0.dev2__py3-none-any.whl → 2.4.7__py3-none-any.whl

librelane/scripts/odbpy/eco_diode.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+# Copyright 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.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import sys
+from reader import click_odb, click, odb
+import grt as GRT
+
+
+@click.command()
+@click_odb
+def cli(reader):
+    grt = reader.design.getGlobalRouter()
+    dpl = reader.design.getOpendp()
+
+    insts_to_temporarily_lock_then_unlock_later = []
+    for inst in reader.block.getInsts():
+        if inst.getPlacementStatus() != "LOCKED":
+            insts_to_temporarily_lock_then_unlock_later.append(
+                (inst, inst.getPlacementStatus())
+            )
+            inst.setPlacementStatus("LOCKED")
+
+    reader._grt_setup(grt)
+
+    diode_master, diode_pin = reader.config["DIODE_CELL"].split("/")
+
+    # print(grt)
+    grt_inc = GRT.IncrementalGRoute(grt, reader.block)
+    i = 0
+    diodes = reader.config["INSERT_ECO_DIODES"] or []
+    for target_info in diodes:
+        target_name, target_pin = target_info["target"].split("/")
+        name_escaped = reader.escape_verilog_name(target_name)
+
+        target = reader.block.findInst(name_escaped)
+        if target is None:
+            print(
+                f"[ERROR] Instance '{target_name}' not found.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        master = reader.db.findMaster(diode_master)
+        if master is None:
+            print(
+                f"[ERROR] Cell kind '{diode_master}' not found.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        target_iterm = target.findITerm(target_pin)
+        if target_iterm is None:
+            print(
+                f"[ERROR] Pin '{target_pin}' not found for instance {target_name}.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        if target_iterm.getIoType() not in ["INPUT", "INOUT"]:
+            print(
+                f"[ERROR] Pin {target_info['target']} is an OUTPUT pin.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        net = target_iterm.getNet()
+        if net is None:
+            print(
+                f"[ERROR] Pin {target_info['target']} has no nets connected.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        eco_diode_name = f"eco_diode_{i}"
+        while reader.block.findInst(eco_diode_name) is not None:
+            i += 1
+            eco_diode_name = f"eco_diode_{i}"
+
+        eco_diode = odb.dbInst.create(
+            reader.block,
+            master,
+            eco_diode_name,
+        )
+
+        diode_iterm = eco_diode.findITerm(diode_pin)
+        if diode_iterm is None:
+            print(
+                f"[ERROR] Pin '{diode_pin}' on ECO diode not found- invalid DIODE_CELL definition.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        sys.stdout.flush()
+
+        if target_info["placement"] is not None:
+            x, y = target_info["placement"]
+            x = reader.block.micronsToDbu(float(x))
+            y = reader.block.micronsToDbu(float(y))
+        else:
+            x, y = target.getLocation()
+
+        eco_diode.setOrient("R0")
+        eco_diode.setLocation(x, y)
+        eco_diode.setPlacementStatus("PLACED")
+
+        diode_iterm.connect(net)
+        grt.addDirtyNet(net)
+
+    site = reader.rows[0].getSite()
+    max_disp_x = int(
+        reader.design.micronToDBU(reader.config["PL_MAX_DISPLACEMENT_X"])
+        / site.getWidth()
+    )
+    max_disp_y = int(
+        reader.design.micronToDBU(reader.config["PL_MAX_DISPLACEMENT_Y"])
+        / site.getHeight()
+    )
+    dpl.detailedPlacement(max_disp_x, max_disp_y)
+
+    grt_inc.updateRoutes(True)
+
+    for inst, previous_status in insts_to_temporarily_lock_then_unlock_later:
+        inst.setPlacementStatus(previous_status)
+
+    reader.design.writeDef("out.def")
+
+
+if __name__ == "__main__":
+    cli()

librelane/scripts/odbpy/ioplace_parser/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2025 The American University in Cairo
+# Copyright 2025 LibreLane Contributors
 #
 # Adapted from ioplace_parser
 #

librelane/scripts/odbpy/ioplace_parser/parse.py

@@ -1,4 +1,4 @@
-# Copyright 2025 The American University in Cairo
+# Copyright 2025 LibreLane Contributors
 #
 # Adapted from ioplace_parser
 #

librelane/scripts/odbpy/power_utils.py

@@ -17,7 +17,6 @@ import utl
 
 import re
 import json
-import functools
 from dataclasses import dataclass
 from typing import Dict, List, Optional
 
@@ -49,11 +48,14 @@ class Design(object):
     def get_verilog_net_name_by_bit(self, top_module: str, target_bit: int):
         yosys_design_object = self.yosys_dict["modules"][top_module]
         if top_module not in self.verilog_net_names_by_bit_by_module:
-            self.verilog_net_names_by_bit_by_module[top_module] = functools.reduce(
-                lambda a, b: {**a, **{bit: b[0] for bit in b[1]["bits"]}},
-                yosys_design_object["netnames"].items(),
-                {},
-            )
+            # check git history for a version of this loop that is drunk on power
+            netname_by_bit = {}
+
+            for netname, info in yosys_design_object["netnames"].items():
+                for bit in info["bits"]:
+                    netname_by_bit[bit] = netname
+
+            self.verilog_net_names_by_bit_by_module[top_module] = netname_by_bit
         return self.verilog_net_names_by_bit_by_module[top_module][target_bit]
 
     def get_pins(self, module_name: str) -> Dict[str, odb.dbMTerm]:

librelane/scripts/odbpy/reader.py

@@ -20,7 +20,7 @@ import sys
 import json
 import locale
 import inspect
-import functools
+from functools import wraps
 from decimal import Decimal
 from fnmatch import fnmatch
 from typing import Callable, Dict
@@ -131,16 +131,9 @@ class OdbReader(object):
         dpl.reportLegalizationStats()
         dpl.optimizeMirroring()
 
-    def _grt(self):
-        """
-        The ``._grt()`` method is EXPERIMENTAL and SHOULD NOT BE USED YET.
-
-        Use a composite step with ``OpenROAD.GlobalRouting``.
-        """
-        if self.config is None:
-            raise RuntimeError("Attempted to call grt without config file")
+    def _grt_setup(self, grt):
+        grt.setAdjustment(float(self.config["GRT_ADJUSTMENT"]))
 
-        grt = self.design.getGlobalRouter()
         routing_layers = [l for l in self.layers.values() if l.getRoutingLevel() >= 1]
         for layer, adj in zip(routing_layers, self.config["GRT_LAYER_ADJUSTMENTS"]):
             grt.addLayerAdjustment(
@@ -170,21 +163,32 @@ class OdbReader(object):
                 raise RuntimeError(f"Unknown layer name '{max_clk_name}'")
             max_clk_idx = self.layers[max_clk_name].getRoutingLevel()
 
-        grt.setMinRoutingLayer(min_layer_idx)
-        grt.setMaxRoutingLayer(max_layer_idx)
         grt.setMinLayerForClock(min_clk_idx)
         grt.setMaxLayerForClock(max_clk_idx)
         grt.setMacroExtension(self.config["GRT_MACRO_EXTENSION"])
         grt.setOverflowIterations(self.config["GRT_OVERFLOW_ITERS"])
         grt.setAllowCongestion(self.config["GRT_ALLOW_CONGESTION"])
         grt.setVerbose(True)
+        grt.initFastRoute(min_layer_idx, max_layer_idx)
+
+    def _grt(self):
+        """
+        The ``._grt()`` method is EXPERIMENTAL and SHOULD NOT BE USED YET.
+
+        Use a composite step with ``OpenROAD.GlobalRouting``.
+        """
+        if self.config is None:
+            raise RuntimeError("Attempted to call grt without config file")
+
+        grt = self.design.getGlobalRouter()
+        self._grt_setup(grt)
         grt.globalRoute(
             True
         )  # The first variable updates guides- not sure why the default is False
 
 
 def click_odb(function):
-    @functools.wraps(function)
+    @wraps(function)
     def wrapper(input_db, input_lefs, config_path, **kwargs):
         reader = OdbReader(input_db, config_path=config_path)
 

librelane/scripts/openroad/common/io.tcl

@@ -316,6 +316,70 @@ proc read_current_odb {args} {
     set_dont_use_cells
 }
 
+proc _populate_cells_by_class {} {
+    if { [info exists ::_cells_by_class(physical)] } {
+        return
+    }
+
+    set ::_cells_by_class(physical) [list]
+    set ::_cells_by_class(non_timing) [list]
+    set _comment_ {
+        We naïvely assume anything not in these classes is not a cell with a
+        logical function. This may not be comprehensive, but is good enough.
+
+        CORE just means a macro used in the core area (i.e. a standard cell.)
+
+        Thing is, it has a lot of subclasses for physical cells:
+
+        `FEEDTHRU`,`SPACER`,`ANTENNACELL`,`WELLTAP`
+
+        Only `TIEHIGH`, `TIELOW` are for logical cells. Thus, the inclusion
+        list allows them as well. `BLOCKS` are macros, which we cannot discern
+        whether they have a logical function or not, so we include them
+        regardless.
+
+        We do make one exception for `ANTENNACELL`s. These are not counted as
+        logical cells but they are not exempt from the so-called SDF-friendly
+        netlist as they do affect timing ever so slightly.
+    }
+    set logical_classes {
+        BLOCK
+        BUMP
+        CORE
+        CORE_TIEHIGH
+        CORE_TIELOW
+        COVER
+        PAD
+        PAD_AREAIO
+        PAD_INOUT
+        PAD_INPUT
+        PAD_OUTPUT
+        PAD_POWER
+        PAD_SPACER
+    }
+
+    foreach lib $::libs {
+        foreach master [$lib getMasters] {
+            if { [lsearch -exact $logical_classes [$master getType]] == -1 } {
+                lappend ::_cells_by_class(physical) [$master getName]
+                if { "[$master getType]" != "CORE_ANTENNACELL" } {
+                    lappend ::_cells_by_class(non_timing) [$master getName]
+                }
+            }
+        }
+    }
+}
+
+proc get_timing_excluded_cells {args} {
+    _populate_cells_by_class
+    return $::_cells_by_class(non_timing)
+}
+
+proc get_physical_cells {args} {
+    _populate_cells_by_class
+    return $::_cells_by_class(physical)
+}
+
 proc write_views {args} {
     # This script will attempt to write views based on existing "SAVE_"
     # environment variables. If the SAVE_ variable exists, the script will
@@ -349,7 +413,7 @@ proc write_views {args} {
     }
 
     if { [info exists ::env(SAVE_POWERED_NETLIST_SDF_FRIENDLY)] } {
-        set exclude_cells "[join $::env(FILL_CELL)] [join $::env(DECAP_CELL)] [join $::env(WELLTAP_CELL)] [join $::env(ENDCAP_CELL)]"
+        set exclude_cells "[get_timing_excluded_cells]"
         puts "Writing nofill powered netlist to '$::env(SAVE_POWERED_NETLIST_SDF_FRIENDLY)'…"
         puts "Excluding $exclude_cells"
         write_verilog -include_pwr_gnd \
@@ -358,7 +422,7 @@ proc write_views {args} {
     }
 
     if { [info exists ::env(SAVE_POWERED_NETLIST_NO_PHYSICAL_CELLS)] } {
-        set exclude_cells "[join [lindex [split $::env(DIODE_CELL) "/"] 0]] [join $::env(FILL_CELL)] [join $::env(DECAP_CELL)] [join $::env(WELLTAP_CELL)] [join $::env(ENDCAP_CELL)]"
+        set exclude_cells "[get_physical_cells]"
         puts "Writing nofilldiode powered netlist to '$::env(SAVE_POWERED_NETLIST_NO_PHYSICAL_CELLS)'…"
         puts "Excluding $exclude_cells"
         write_verilog -include_pwr_gnd \

librelane/scripts/openroad/gui.tcl

@@ -12,4 +12,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 source $::env(SCRIPTS_DIR)/openroad/common/io.tcl
-read_current_odb
+
+puts "Reading OpenROAD database at '$::env(CURRENT_ODB)'…"
+if { [ catch {read_db $::env(CURRENT_ODB)} errmsg ]} {
+    puts stderr $errmsg
+    exit 1
+}
+
+set_global_vars
+
+define_corners $::env(DEFAULT_CORNER)
+
+foreach lib $::env(_PNR_LIBS) {
+    puts "Reading library file at '$lib'…"
+    read_liberty $lib
+}
+
+read_current_sdc
+
+if { [info exists ::env(_CURRENT_SPEF_BY_CORNER)] } {
+    set corner_name $::env(_CURRENT_CORNER_NAME)
+    puts "Reading top-level design parasitics for the '$corner_name' corner at '$::env(_CURRENT_SPEF_BY_CORNER)'…"
+    read_spef -corner $corner_name $::env(_CURRENT_SPEF_BY_CORNER)
+}

librelane/state/design_format.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from enum import Enum
-from dataclasses import dataclass
 from typing import Dict, Optional
+from dataclasses import dataclass, replace
 
 
 @dataclass
@@ -44,10 +44,16 @@ class DesignFormatObject:
     folder_override: Optional[str] = None
     multiple: bool = False
 
+    _instance_optional: bool = False
+
     @property
     def folder(self) -> str:
         return self.folder_override or self.id
 
+    @property
+    def optional(self) -> bool:
+        return self._instance_optional
+
 
 class DesignFormat(Enum):
     """
@@ -174,6 +180,15 @@ class DesignFormat(Enum):
     def by_id(id: str) -> Optional["DesignFormat"]:
         return _designformat_by_id.get(id)
 
+    def mkOptional(self) -> "DesignFormat":
+        # HACK: Create ephemeral DesignFormat copy until 3.0.0 lets us do this
+        # a bit more appropriately.
+        clone = object.__new__(DesignFormat)
+        clone._name_ = self._name_
+        clone._value_ = replace(self._value_)
+        clone._value_._instance_optional = True
+        return clone
+
 
 _designformat_by_id: Dict[str, "DesignFormat"] = {
     format.value.id: format for format in DesignFormat

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
@@ -214,14 +216,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/__init__.py

@@ -48,7 +48,7 @@ from . import openroad as OpenROAD
 from .openroad import OpenROADStep
 
 from . import odb as Odb
-from .odb import OdbpyStep
+from .odb import OdbpyStep, ECOBuffer, ECODiode
 
 from . import magic as Magic
 from .magic import MagicStep

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
@@ -48,8 +47,9 @@ def load_step_from_inputs(
         if Found := Step.factory.get(id):
             Target = Found
         else:
-            err(
-                f"No step registered with id '{id}'. Ensure all relevant plugins are installed."
+            err(f"No step registered with id '{id}'.")
+            info(
+                f"If the step '{id}' is part of a plugin, make sure the plugin's parent directory is in the PYTHONPATH environment variable."
             )
             ctx.exit(-1)
 
@@ -239,7 +239,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/checker.py

@@ -79,22 +79,21 @@ class MetricChecker(Step):
     deferred: ClassVar[bool] = True
     error_on_var: Optional[Variable] = None
 
-    @classmethod
-    def get_help_md(Self, **kwargs):  # pragma: no cover
-        threshold_string = Self.get_threshold_description(None)
+    def __init_subclass__(cls):
+        threshold_string = cls.get_threshold_description(None)
         if threshold_string is None:
-            threshold_string = str(Self.get_threshold(None))
+            threshold_string = str(cls.get_threshold(None))
         dynamic_docstring = "Raises"
-        if Self.deferred:
+        if cls.deferred:
             dynamic_docstring += " a deferred error"
         else:
             dynamic_docstring += " an immediate error"
-        dynamic_docstring += f" if {Self.metric_description} (metric: ``{Self.metric_name}``) are >= {threshold_string}."
+        dynamic_docstring += f" if {cls.metric_description} (metric: ``{cls.metric_name}``) are >= {threshold_string}."
         dynamic_docstring += (
             " Doesn't raise an error depending on error_on_var if defined."
         )
-
-        return super().get_help_md(docstring_override=dynamic_docstring, **kwargs)
+        cls.__doc__ = dynamic_docstring
+        return super().__init_subclass__()
 
     def get_threshold(self: Optional["MetricChecker"]) -> Optional[Decimal]:
         return Decimal(0)

librelane/steps/klayout.py

@@ -268,8 +268,9 @@ class XOR(KLayoutStep):
         Variable(
             "KLAYOUT_XOR_TILE_SIZE",
             Optional[int],
-            "A tile size for the XOR process in µm.",
+            "The tile size to parallelize the XOR process with.",
             pdk=True,
+            units="µm",
         ),
     ]
 
@@ -327,6 +328,15 @@ class XOR(KLayoutStep):
 
 @Step.factory.register()
 class DRC(KLayoutStep):
+    """
+    Runs DRC using KLayout.
+
+    Unlike most steps, the KLayout scripts vary quite wildly by PDK. If a PDK
+    is not supported by this step, it will simply be skipped.
+
+    Currently, only sky130A and sky130B are supported.
+    """
+
     id = "KLayout.DRC"
     name = "Design Rule Check (KLayout)"
 

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
 
 
 class MagicOutputProcessor(OutputProcessor):
@@ -464,6 +464,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):
@@ -481,22 +487,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)
@@ -505,9 +518,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/misc.py

@@ -53,6 +53,11 @@ class LoadBaseSDC(Step):
 
 @Step.factory.register()
 class ReportManufacturability(Step):
+    """
+    Logs a simple "manufacturability report", i.e., the status of DRC, LVS, and
+    antenna violations.
+    """
+
     id = "Misc.ReportManufacturability"
     name = "Report Manufacturability"
     long_name = "Report Manufacturability (DRC, LVS, Antenna)"