librelane 2.4.0.dev2__tar.gz → 2.4.0.dev4__tar.gz

{librelane-2.4.0.dev2 → librelane-2.4.0.dev4}/PKG-INFO

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

{librelane-2.4.0.dev2 → librelane-2.4.0.dev4}/librelane/config/variable.py

@@ -238,7 +238,7 @@ def some_of(t: Type[Any]) -> Type[Any]:
     return new_union  # type: ignore
 
 
-def repr_type(t: Type[Any]) -> str:  # pragma: no cover
+def repr_type(t: Type[Any], for_document: bool = False) -> str:  # pragma: no cover
     optional = is_optional(t)
     some = some_of(t)
 
@@ -247,18 +247,25 @@ def repr_type(t: Type[Any]) -> str:  # pragma: no cover
     else:
         type_string = str(some)
 
+    if is_dataclass(t):
+        type_string = (
+            f"{{class}}`{some.__qualname__} <{some.__module__}.{some.__qualname__}>`"
+        )
+
+    separator = "｜<br />" if for_document else "｜"
+
     if inspect.isclass(some) and issubclass(some, Enum):
-        type_string = "｜".join([str(e.name) for e in some])
+        type_string = separator.join([str(e.name) for e in some])
         type_string = f"`{type_string}`"
     else:
         origin, args = get_origin(some), get_args(some)
         if origin is not None:
             if origin == Union:
                 arg_strings = [repr_type(arg) for arg in args]
-                type_string = "｜".join(arg_strings)
+                type_string = separator.join(arg_strings)
                 type_string = f"({type_string})"
             elif origin == Literal:
-                return "｜".join([repr(arg) for arg in args])
+                return separator.join([repr(arg) for arg in args])
             else:
                 arg_strings = [repr_type(arg) for arg in args]
                 type_string = f"{type_string}[{', '.join(arg_strings)}]"
@@ -377,9 +384,7 @@ class Variable:
             for easier wrapping by web browsers/PDF renderers/what have you
         :returns: A pretty Markdown string representation of the Variable's type.
         """
-        if for_document:
-            return repr_type(self.type).replace("｜", "｜<br />")
-        return repr_type(self.type)
+        return repr_type(self.type, for_document=for_document)
 
     def desc_repr_md(self) -> str:  # pragma: no cover
         """

{librelane-2.4.0.dev2 → librelane-2.4.0.dev4}/librelane/scripts/odbpy/defutil.py

@@ -21,7 +21,6 @@ from decimal import Decimal
 
 from reader import click_odb, click
 from typing import Tuple, List
-from exception_codes import METAL_LAYER_ERROR, FORMAT_ERROR, NOT_FOUND_ERROR
 
 
 @click.group()
@@ -481,7 +480,7 @@ def parse_obstructions(obstructions) -> List[Tuple[str, List[int]]]:
                 f"[ERROR] Incorrectly formatted input {obs}.\n Format: layer llx lly urx ury, ...",
                 file=sys.stderr,
             )
-            sys.exit(FORMAT_ERROR)
+            sys.exit(1)
         else:
             layer = m.group("layer")
             bbox = [Decimal(x) for x in m.group("bbox").split()]
@@ -505,8 +504,8 @@ def add_obstructions(reader, input_lefs, obstructions):
         layer = obs[0]
         odb_layer = reader.tech.findLayer(layer)
         if odb_layer is None:
-            print(f"[ERROR] layer {layer} doesn't exist.", file=sys.stderr)
-            sys.exit(METAL_LAYER_ERROR)
+            print(f"[ERROR] Layer '{layer}' not found.", file=sys.stderr)
+            sys.exit(1)
         bbox = obs[1]
         dbu = reader.tech.getDbUnitsPerMicron()
         bbox = [int(x * dbu) for x in bbox]
@@ -550,8 +549,8 @@ def remove_obstructions(reader, input_lefs, obstructions):
         bbox = [int(x * dbu) for x in bbox]  # To dbus
         found = False
         if reader.tech.findLayer(layer) is None:
-            print(f"[ERROR] layer {layer} doesn't exist.", file=sys.stderr)
-            sys.exit(METAL_LAYER_ERROR)
+            print(f"[ERROR] Layer '{layer}' not found.", file=sys.stderr)
+            sys.exit(1)
         for odb_obstruction in existing_obstructions:
             odb_layer, odb_bbox, odb_obj = odb_obstruction
             if (odb_layer, odb_bbox) == (layer, bbox):
@@ -565,7 +564,7 @@ def remove_obstructions(reader, input_lefs, obstructions):
                 f"[ERROR] Obstruction on {layer} at {bbox} (DBU) not found.",
                 file=sys.stderr,
             )
-            sys.exit(NOT_FOUND_ERROR)
+            sys.exit(1)
 
 
 cli.add_command(remove_obstructions)

librelane-2.4.0.dev4/librelane/scripts/odbpy/eco_buffer.py

@@ -0,0 +1,181 @@
+#!/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
+
+
+def average_location(instances):
+    locations = [instance.getLocation() for instance in instances]
+    x_sum = sum(loc[0] for loc in locations)
+    y_sum = sum(loc[1] for loc in locations)
+    return (x_sum // len(locations), y_sum // len(locations))
+
+
+@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)
+
+    grt_inc = GRT.IncrementalGRoute(grt, reader.block)
+    i = 0
+
+    for target_info in reader.config["INSERT_ECO_BUFFERS"]:
+        target_name, target_pin = target_info["target"].split("/")
+        name_escaped = reader.escape_verilog_name(target_name)
+        buffer_master = target_info["buffer"]
+
+        master = reader.db.findMaster(buffer_master)
+        if master is None:
+            print(
+                f"[ERROR] Buffer type '{buffer_master}' not found.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        target = reader.block.findInst(name_escaped)
+        if target is None:
+            print(f"[ERROR] Instance '{target_name}' 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)
+
+        net = target_iterm.getNet()
+        if net is None:
+            print(
+                f"[ERROR] Net not found on pin '{target_pin}' of instance '{target_name}'.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        new_buf_name = f"eco_buffer_{i}"
+        new_net_name = f"eco_buffer_{i}_net"
+        while (
+            reader.block.findInst(new_buf_name) is not None
+            or reader.block.findNet(new_net_name) is not None
+        ):
+            i += 1
+            new_buf_name = f"eco_buffer_{i}"
+            new_net_name = f"eco_buffer_{i}_net"
+
+        # Prepare buffer cell, net
+        eco_buffer = odb.dbInst.create(reader.block, master, new_buf_name)
+        eco_net = odb.dbNet.create(reader.block, new_net_name)
+        buffer_iterms = eco_buffer.getITerms()
+        buffer_a = None
+        for iterm in buffer_iterms:
+            if iterm.isInputSignal():
+                buffer_a = iterm
+                break  # Exit loop once input is found
+        if buffer_a is None:
+            print(
+                f"[ERROR] Buffer {buffer_master} has no input signals.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        buffer_x = None
+        for iterm in buffer_iterms:
+            if iterm.isOutputSignal():
+                buffer_x = iterm
+                break  # Exit loop once output is found
+        if buffer_x is None:
+            print(
+                f"[ERROR] Buffer {buffer_master} has no output signals.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        location_instances = [target]
+        net_iterms = net.getITerms()
+        if target_iterm.getIoType() == "INPUT":
+            driver_iterms = [
+                iterm for iterm in net_iterms if iterm.getIoType() in ["OUTPUT"]
+            ]
+            drivers = [iterm.getInst() for iterm in driver_iterms]
+            location_instances.extend(drivers)
+
+            target_iterm.disconnect()
+            buffer_a.connect(net)
+            buffer_x.connect(eco_net)
+            target_iterm.connect(eco_net)
+        elif target_iterm.getIoType() == "OUTPUT":
+            sink_iterms = [
+                iterm for iterm in net_iterms if iterm.getIoType() in ["INPUT", "INOUT"]
+            ]
+            sinks = [iterm.getInst() for iterm in sink_iterms]
+            location_instances.extend(sinks)
+
+            target_iterm.disconnect()
+            target_iterm.connect(eco_net)
+            buffer_a.connect(eco_net)
+            buffer_x.connect(net)
+        else:
+            print(
+                f"[ERROR] {target_name}/{target_pin} is neither an INPUT or an OUTPUT and is unsupported by this script. To buffer an INOUT port, buffer its drivers instead.",
+                file=sys.stderr,
+            )
+            exit(-1)
+
+        if target_info.get("placement") is not None:
+            eco_x, eco_y = target_info["placement"]
+            eco_x = reader.block.micronsToDbu(float(eco_x))
+            eco_y = reader.block.micronsToDbu(float(eco_y))
+            eco_loc = (eco_x, eco_y)
+        else:
+            eco_loc = average_location(location_instances)
+
+        eco_buffer.setOrient("R0")
+        eco_buffer.setLocation(*eco_loc)
+        eco_buffer.setPlacementStatus("PLACED")
+        grt.addDirtyNet(net)
+        grt.addDirtyNet(eco_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)
+
+
+if __name__ == "__main__":
+    cli()

librelane-2.4.0.dev4/librelane/scripts/odbpy/eco_diode.py

@@ -0,0 +1,139 @@
+#!/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
+    for target_info in reader.config["INSERT_ECO_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-2.4.0.dev2 → librelane-2.4.0.dev4}/librelane/scripts/odbpy/reader.py

@@ -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,14 +163,25 @@ 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

{librelane-2.4.0.dev2 → librelane-2.4.0.dev4}/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-2.4.0.dev2 → librelane-2.4.0.dev4}/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