librelane 2.4.0.dev2__py3-none-any.whl → 2.4.0.dev4__py3-none-any.whl

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/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/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/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/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/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/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/odb.py

@@ -19,28 +19,27 @@ 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
 
+from ..common import Path, get_script_dir, aggregate_metrics
+from ..config import Instance, Macro, Variable
+from ..logging import info, verbose
+from ..state import DesignFormat, State
 
-from .common_variables import io_layer_variables
-from .openroad_alerts import (
-    OpenROADAlert,
-    OpenROADOutputProcessor,
-)
 from .openroad import DetailedPlacement, GlobalRouting
-from .tclstep import TclStep
+from .openroad_alerts import OpenROADAlert, OpenROADOutputProcessor
+from .common_variables import io_layer_variables, dpl_variables, grt_variables
 from .step import (
-    ViewsUpdate,
+    CompositeStep,
+    DefaultOutputProcessor,
     MetricsUpdate,
     Step,
+    StepError,
     StepException,
-    CompositeStep,
-    DefaultOutputProcessor,
+    ViewsUpdate,
 )
-from ..logging import info, verbose
-from ..config import Variable, Macro, Instance
-from ..state import State, DesignFormat
-from ..common import Path, get_script_dir
+from .tclstep import TclStep
 
 inf_rx = re.compile(r"\b(-?)inf\b")
 
@@ -51,6 +50,8 @@ class OdbpyStep(Step):
 
     output_processors = [OpenROADOutputProcessor, DefaultOutputProcessor]
 
+    alerts: Optional[List[OpenROADAlert]] = None
+
     def on_alert(self, alert: OpenROADAlert) -> OpenROADAlert:
         if alert.code in [
             "ORD-0039",  # .openroad ignored with -python
@@ -63,7 +64,9 @@ class OdbpyStep(Step):
             self.warn(str(alert), extra={"key": alert.code})
         return alert
 
-    def run(self, state_in, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
+    def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
+        self.alerts = None
+
         kwargs, env = self.extract_env(kwargs)
 
         automatic_outputs = set(self.outputs).intersection(
@@ -86,15 +89,35 @@ class OdbpyStep(Step):
         env["PYTHONPATH"] = (
             f'{os.path.join(get_script_dir(), "odbpy")}:{env.get("PYTHONPATH")}'
         )
+        check = False
+        if "check" in kwargs:
+            check = kwargs.pop("check")
 
         subprocess_result = self.run_subprocess(
             command,
             env=env,
+            check=check,
             **kwargs,
         )
+        generated_metrics = subprocess_result["generated_metrics"]
 
+        # 1. Parse warnings and errors
+        self.alerts = subprocess_result.get("openroad_alerts") or []
+        if subprocess_result["returncode"] != 0:
+            error_strings = [
+                str(alert) for alert in self.alerts if alert.cls == "error"
+            ]
+            if len(error_strings):
+                error_string = "\n".join(error_strings)
+                raise StepError(
+                    f"{self.id} failed with the following errors:\n{error_string}"
+                )
+            else:
+                raise StepException(
+                    f"{self.id} failed unexpectedly. Please check the logs and file an issue."
+                )
+        # 2. Metrics
         metrics_path = os.path.join(self.step_dir, "or_metrics_out.json")
-        metrics_updates: MetricsUpdate = subprocess_result["generated_metrics"]
         if os.path.exists(metrics_path):
             or_metrics_out = json.loads(open(metrics_path).read(), parse_float=Decimal)
             for key, value in or_metrics_out.items():
@@ -102,9 +125,11 @@ class OdbpyStep(Step):
                     or_metrics_out[key] = inf
                 elif value == "-Infinity":
                     or_metrics_out[key] = -inf
-            metrics_updates.update(or_metrics_out)
+            generated_metrics.update(or_metrics_out)
 
-        return views_updates, metrics_updates
+        metric_updates_with_aggregates = aggregate_metrics(generated_metrics)
+
+        return views_updates, metric_updates_with_aggregates
 
     def get_command(self) -> List[str]:
         metrics_path = os.path.join(self.step_dir, "or_metrics_out.json")
@@ -180,7 +205,7 @@ class CheckMacroAntennaProperties(OdbpyStep):
             args += ["--cell-name", name]
         return super().get_command() + args
 
-    def run(self, state_in, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
+    def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
         if not self.get_cells():
             info("No cells provided, skipping…")
             return {}, {}
@@ -244,7 +269,7 @@ class ApplyDEFTemplate(OdbpyStep):
             args.append("--copy-def-power")
         return super().get_command() + args
 
-    def run(self, state_in, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
+    def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
         if self.config["FP_DEF_TEMPLATE"] is None:
             info("No DEF template provided, skipping…")
             return {}, {}
@@ -339,7 +364,7 @@ class WriteVerilogHeader(OdbpyStep):
 
         return command
 
-    def run(self, state_in, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
+    def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
         views_updates, metrics_updates = super().run(state_in, **kwargs)
         views_updates[DesignFormat.VERILOG_HEADER] = Path(
             os.path.join(self.step_dir, f"{self.config['DESIGN_NAME']}.vh")
@@ -528,7 +553,7 @@ class AddRoutingObstructions(OdbpyStep):
                 command.append(obstruction)
         return command
 
-    def run(self, state_in, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
+    def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
         if self.config[self.get_obstruction_variable().name] is None:
             info(
                 f"'{self.get_obstruction_variable().name}' is not defined. Skipping '{self.id}'…"
@@ -659,7 +684,7 @@ class CustomIOPlacement(OdbpyStep):
             + length_args
         )
 
-    def run(self, state_in, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
+    def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
         if self.config["FP_PIN_ORDER_CFG"] is None:
             info("No custom floorplan file configured, skipping…")
             return {}, {}
@@ -895,7 +920,7 @@ class CellFrequencyTables(OdbpyStep):
     def get_buffer_list_script(self):
         return os.path.join(get_script_dir(), "openroad", "buffer_list.tcl")
 
-    def run(self, state_in, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
+    def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
         kwargs, env = self.extract_env(kwargs)
 
         env_copy = env.copy()
@@ -948,8 +973,119 @@ class ManualGlobalPlacement(OdbpyStep):
         assert self.config_path is not None, "get_command called before start()"
         return super().get_command() + ["--step-config", self.config_path]
 
-    def run(self, state_in, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
+    def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
         if self.config["MANUAL_GLOBAL_PLACEMENTS"] is None:
             info("'MANUAL_GLOBAL_PLACEMENTS' not set, skipping…")
             return {}, {}
         return super().run(state_in, **kwargs)
+
+
+@dataclass
+class ECOBuffer:
+    """
+    :param target: The driver to insert an ECO buffer after or sink to insert an
+        ECO buffer before, in the format instance_name/pin_name.
+    :param buffer: The kind of buffer cell to use.
+    :param placement: The coarse placement for this buffer (to be legalized.)
+        If unset, depending on whether the target is a driver or a sink:
+
+        - Driver: The placement will be the average of the driver and all sinks.
+
+        - Sink: The placement will be the average of the sink and all drivers.
+    """
+
+    target: str
+    buffer: str
+    placement: Optional[Tuple[Decimal, Decimal]] = None
+
+
+@Step.factory.register()
+class InsertECOBuffers(OdbpyStep):
+    """
+    Experimental step to insert ECO buffers on either drivers or sinks after
+    global or detailed routing. The placement is legalized and global routing is
+    incrementally re-run for affected nets. Useful for manually fixing some hold
+    violations.
+
+    If run after detailed routing, detailed routing must be re-run as affected
+    nets that are altered are removed and require re-routing.
+
+    INOUT and FEEDTHRU ports are not supported.
+    """
+
+    id = "Odb.InsertECOBuffers"
+    name = "Insert ECO Buffers"
+
+    config_vars = (
+        dpl_variables
+        + grt_variables
+        + [
+            Variable(
+                "INSERT_ECO_BUFFERS",
+                Optional[List[ECOBuffer]],
+                "List of buffers to insert",
+            )
+        ]
+    )
+
+    def get_script_path(self):
+        return os.path.join(get_script_dir(), "odbpy", "eco_buffer.py")
+
+    def get_command(self) -> List[str]:
+        assert self.config_path is not None, "get_command called before start()"
+        return super().get_command() + ["--step-config", self.config_path]
+
+
+@dataclass
+class ECODiode:
+    """
+    :param target: The sink whose net gets a diode connected, in the format
+        instance_name/pin_name.
+    :param placement: The coarse placement for this diode (to be legalized.)
+        If unset, the diode is placed at the same location as the target
+        instance, with legalization later moving it to a valid location.
+    """
+
+    target: str
+    placement: Optional[Tuple[Decimal, Decimal]] = None
+
+
+@Step.factory.register()
+class InsertECODiodes(OdbpyStep):
+    """
+    Experimental step to create and attach ECO diodes to the nets of sinks after
+    global or detailed routing. The placement is legalized and global routing is
+    incrementally re-run for affected nets. Useful for manually fixing some
+    antenna violations.
+
+    If run after detailed routing, detailed routing must be re-run as affected
+    nets that are altered are removed and require re-routing.
+    """
+
+    id = "Odb.InsertECODiodes"
+    name = "Insert ECO Diodes"
+
+    config_vars = (
+        grt_variables
+        + dpl_variables
+        + [
+            Variable(
+                "INSERT_ECO_DIODES",
+                Optional[List[ECODiode]],
+                "List of sinks to insert diodes for.",
+            )
+        ]
+    )
+
+    def get_script_path(self):
+        return os.path.join(get_script_dir(), "odbpy", "eco_diode.py")
+
+    def get_command(self) -> List[str]:
+        assert self.config_path is not None, "get_command called before start()"
+        return super().get_command() + ["--step-config", self.config_path]
+
+    def run(self, state_in: State, **kwargs):
+        if self.config["DIODE_CELL"] is None:
+            info(f"'DIODE_CELL' not set. Skipping '{self.id}'…")
+            return {}, {}
+        return super().run(state_in, **kwargs)

librelane/steps/openroad.py

@@ -185,6 +185,8 @@ class OpenROADStep(TclStep):
 
     output_processors = [OpenROADOutputProcessor, DefaultOutputProcessor]
 
+    alerts: Optional[List[OpenROADAlert]] = None
+
     config_vars = [
         Variable(
             "PDN_CONNECT_MACROS_TO_GRID",
@@ -264,6 +266,7 @@ class OpenROADStep(TclStep):
         2. After the `super()` call: Processes the `or_metrics_out.json` file and
         updates the State's `metrics` property with any new metrics in that object.
         """
+        self.alerts = None
         kwargs, env = self.extract_env(kwargs)
         env = self.prepare_env(env, state_in)
 
@@ -293,9 +296,11 @@ class OpenROADStep(TclStep):
             views_updates[output] = path
 
         # 1. Parse warnings and errors
-        alerts = subprocess_result["openroad_alerts"]
+        self.alerts = subprocess_result.get("openroad_alerts") or []
         if subprocess_result["returncode"] != 0:
-            error_strings = [str(alert) for alert in alerts if alert.cls == "error"]
+            error_strings = [
+                str(alert) for alert in self.alerts if alert.cls == "error"
+            ]
             if len(error_strings):
                 error_string = "\n".join(error_strings)
                 raise StepError(

librelane/steps/pyosys.py

@@ -14,8 +14,10 @@
 import os
 import re
 import io
+import sys
 import json
 import fnmatch
+import shutil
 import subprocess
 from decimal import Decimal
 from abc import abstractmethod
@@ -207,7 +209,11 @@ class PyosysStep(Step):
 
     def get_command(self, state_in: State) -> List[str]:
         script_path = self.get_script_path()
-        cmd = ["yosys", "-y", script_path]
+        # HACK: Get Colab working
+        yosys_bin = "yosys"
+        if "google.colab" in sys.modules:
+            yosys_bin = shutil.which("yosys") or "yosys"
+        cmd = [yosys_bin, "-y", script_path]
         if self.config["YOSYS_LOG_LEVEL"] != "ALL":
             cmd += ["-Q"]
         if self.config["YOSYS_LOG_LEVEL"] == "WARNING":
@@ -220,6 +226,11 @@ class PyosysStep(Step):
 
     def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
         cmd = self.get_command(state_in)
+        # HACK: Get Colab working
+        if "google.colab" in sys.modules:
+            kwargs, env = self.extract_env(kwargs)
+            env.pop("PATH", "")
+            kwargs["env"] = env
         subprocess_result = super().run_subprocess(cmd, **kwargs)
         return {}, subprocess_result["generated_metrics"]
 

{librelane-2.4.0.dev2.dist-info → librelane-2.4.0.dev4.dist-info}/METADATA

@@ -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.dist-info → librelane-2.4.0.dev4.dist-info}/RECORD

@@ -23,7 +23,7 @@ librelane/config/flow.py,sha256=qCGaUOj12j57gORzoE10m7_WG-n600llnFDMlZagUF4,1666
 librelane/config/pdk_compat.py,sha256=rznq5xIny9M0PmddhPOGtCIrSdv98ysAoYgkpyM0gUA,8450
 librelane/config/preprocessor.py,sha256=I239Y01dC2o5eb1UtcSbLdybVrZgqGyDr7ecT234I4Y,14913
 librelane/config/removals.py,sha256=lJ0xpkCqnZAdA_ug4yq0NDjRBFuw4XsdORwymbEVGyQ,2907
-librelane/config/variable.py,sha256=NbR4h1Y8h4pFr6ZLUPVTUzpWB9nmlgbD-zb1Z2Ct-ww,26057
+librelane/config/variable.py,sha256=tqH7po203Q7usX9jdVoyng2fdKPzDO36UmbCPZcIcsA,26232
 librelane/container.py,sha256=3KHxs3dUSVUZVYsS6fsA7dD3Q4QEQEzRxgXZZh9dzi0,7554
 librelane/env_info.py,sha256=vAE9AZ_vDFLt7Srtg4ZywPzE6vgVhCrIvg8PP25-BJ8,10460
 librelane/examples/spm/config.yaml,sha256=YKBm0lsY3AJZNcxAh1sQ1QMmJeVCpOpil6dw_RgQh4c,633
@@ -82,10 +82,11 @@ librelane/scripts/odbpy/apply_def_template.py,sha256=Tn6y65biu0bAQ6XilYxq5jn3a_K
 librelane/scripts/odbpy/cell_frequency.py,sha256=NfGgM8wxIvjM1C_GHUghZPOh8gpdasLOWR4qBdHHLFE,3105
 librelane/scripts/odbpy/check_antenna_properties.py,sha256=dMD-RcoA7plcAu9IIqa2e-8XCO0EMcKG-6P39D3Gpic,3942
 librelane/scripts/odbpy/contextualize.py,sha256=G8EEgmK6ISikXD2-Pw-RTs1JxLWPnuppwL7oPfAsb84,4020
-librelane/scripts/odbpy/defutil.py,sha256=vOVLEP1WOs2N1JjIoV0mAABWptJAWIzJYIa0JECg8Vc,17987
+librelane/scripts/odbpy/defutil.py,sha256=g0UaAQRt8hXb9nfI6SbMp_Hx__0o1POw33_fS6xyibU,17849
 librelane/scripts/odbpy/diodes.py,sha256=ZS_1niaTcwvaTTNjJcth4Qepcwxa6aV6E9WM_KiMtTI,11811
 librelane/scripts/odbpy/disconnected_pins.py,sha256=hS_Iletg7N6K6yN_ccvWxZ3nWNZp4ecUJM-oY0kkEfA,11139
-librelane/scripts/odbpy/exception_codes.py,sha256=VXReNio2d9uxU4cXL1PpRxWhhK2_OSs5DeCpVqTDYJE,648
+librelane/scripts/odbpy/eco_buffer.py,sha256=QOL2J0UJQiVvuGFbpdyAj-RRsPfEL-rT_qro3Rp0KeE,6256
+librelane/scripts/odbpy/eco_diode.py,sha256=2LN7fHh9uO9JP3PYIxIwUiP1lyeqdTNF2ADTcY_Bu-g,4281
 librelane/scripts/odbpy/filter_unannotated.py,sha256=Gvcaj_WNr6TPiHk-36nkMu4betNHZo1g2lD3UcA9hDQ,2950
 librelane/scripts/odbpy/io_place.py,sha256=LSJIJQDLSOpENyQOg_kVTIbh1AbYLiHIXx0siduo-lg,15589
 librelane/scripts/odbpy/ioplace_parser/__init__.py,sha256=TMKTIWwGJfdSr7dJcsoisUuKlbTKJdHV6-0kB77v2P8,887
@@ -95,7 +96,7 @@ librelane/scripts/odbpy/lefutil.py,sha256=XhfWSGHdn96yZWYQAPisgJM0iuY3xw4SW7jmMT
 librelane/scripts/odbpy/placers.py,sha256=mgy_-GYeLDPMG41YAopMTtJyCHP6ucJRk7cJzI9PLRQ,4572
 librelane/scripts/odbpy/power_utils.py,sha256=al12uMiv8G0yQZOPKXNHYQ1dm2KGlu9xigSuYLEAo_A,14627
 librelane/scripts/odbpy/random_place.py,sha256=TEsV4LtXQTP8OJvnBh09Siu9fKkwG9UpIkCkQpdXAgU,1649
-librelane/scripts/odbpy/reader.py,sha256=uRmcBtD2pN4d9BKfbSjeTyqR2gSoV0SO30VuUSkm-Dk,8449
+librelane/scripts/odbpy/reader.py,sha256=5-hpG3TgmKwJtnbEDQoAPejeDx1QyRBRbIMULMkBesM,8539
 librelane/scripts/odbpy/remove_buffers.py,sha256=f-kGZIPnMtu4gnl2r2CDkng8U8vUMJKJWNV_akOpc38,5460
 librelane/scripts/odbpy/snap_to_grid.py,sha256=lULRWlcYXvrTBUpemUPlpO2dBnbFeriuG-DlI4KnViE,1743
 librelane/scripts/odbpy/wire_lengths.py,sha256=pSPhVnLlvcvmgEh89G8nu8DRaZVP66r-4ieVoV3zrm4,2737
@@ -106,7 +107,7 @@ librelane/scripts/openroad/buffer_list.tcl,sha256=sXygy1KRSUS4dZi1UOpBkGGOuXRVLM
 librelane/scripts/openroad/common/dpl.tcl,sha256=Nqq5e5OwRoyk8mHfVa5uw3DGKDGMEFrx6odpxanc_Ns,912
 librelane/scripts/openroad/common/dpl_cell_pad.tcl,sha256=KWVuj8u1-y3ZUiQr48TAsFv1GSzOCVnAjdqfBjtoQxQ,1066
 librelane/scripts/openroad/common/grt.tcl,sha256=DCKe5D7INCBctitbRdgZNRsBrI9Qo5v7Ag7DF45W4_U,1137
-librelane/scripts/openroad/common/io.tcl,sha256=MEePZdAjuBTkWhgFBshrszGo3R-OSNABcrGS62dOq1A,16576
+librelane/scripts/openroad/common/io.tcl,sha256=cPJ4O2nBKrGKON7lO7ZX1j_TpcxQFCw3gH858yTWg8Q,18289
 librelane/scripts/openroad/common/pdn_cfg.tcl,sha256=KnQAxzlL_261Kp4M02cQ6usZHIRNBj56SAZNn1CqrZc,4552
 librelane/scripts/openroad/common/resizer.tcl,sha256=3p59NDcXgEkUzg_43dcUYr2KkD__fkADdqCZ3uWsUU4,3478
 librelane/scripts/openroad/common/set_global_connections.tcl,sha256=zGMz0Hu57ZVdLhz4djJASyre0qOi-dszylo6HD8ClUM,2899
@@ -145,7 +146,7 @@ librelane/state/__init__.py,sha256=rLUdAkeB278r8pB2Jpv-ccmmmP32FR90wANIFHXdA0w,9
 librelane/state/__main__.py,sha256=Ici4Ejg1ICUZNSYZRguC3BfEk_wFxsmE0ag0Vv8iY1I,1679
 librelane/state/design_format.py,sha256=9mWBbHrhzludtv3dKB6P4UQncBVTMMtoj69kNgRvh5o,5306
 librelane/state/state.py,sha256=J05gAeSVDiF76ITuw4WJZ7WkMyG4oTjt_7kpsI3E3PE,11957
-librelane/steps/__init__.py,sha256=8jTPCsrzJWjNctKUSXOjxYqqeMQjYkAKslcIXS3GDzg,1647
+librelane/steps/__init__.py,sha256=j3JYrdnWM74dYuEvE931oSrQI7FUz-hKWr8Mts8C0wg,1668
 librelane/steps/__main__.py,sha256=GviXtDLISKJCufKxK3oFPOSMF1GyShZbG5RXpVCYFkk,13376
 librelane/steps/checker.py,sha256=vul1D0cT03144qKK5QAKswClKKICK7kNB4PB6xXykvc,21353
 librelane/steps/common_variables.py,sha256=qT0VeIstFsDbe8VGAyqXrXxQw69OZ08haM6u1IbdFiE,10429
@@ -154,15 +155,15 @@ librelane/steps/klayout.py,sha256=g7jYz-1cLwgfPTiMJIdAQ9zmkrwNtJLPoRg6PqOUv6Y,16
 librelane/steps/magic.py,sha256=4o_WarBAQdTTuekP72uovjvqW5wsaDCpMB3LtAhC_IY,20051
 librelane/steps/misc.py,sha256=Xk_a6JJPljkk8pemu-NtlzDRs-8S7vuRKZKj4pnCRlE,5690
 librelane/steps/netgen.py,sha256=R9sDWv-9wKMdi2rkuLQdOc4uLlbYhXcKKd6WsZsnLt0,8953
-librelane/steps/odb.py,sha256=BNvw_SoXanMpeshzZyRvYW44059xj2o1FWf1OSeFzps,33337
-librelane/steps/openroad.py,sha256=pit4e2UmAE6pr3SvheHrrM0JXybA5c6QoYtX9fFaDas,85709
+librelane/steps/odb.py,sha256=_WhAFEVbFioSGsVrGbXQVqcXYAnE22gLA4eF1v028EQ,38030
+librelane/steps/openroad.py,sha256=0uHbFYO3wT9rFkovxMgr4rMzaMpA9DvG8sWLM4L3jn8,85836
 librelane/steps/openroad_alerts.py,sha256=IJyB4piBDCKXhkJswHGMYCRDwbdQsR0GZlrGGDhmW6Q,3364
-librelane/steps/pyosys.py,sha256=bBKCIiKxbAQXrEgR1gdg2el-IpuZoUzLOwR62-ilwQg,22326
+librelane/steps/pyosys.py,sha256=mnbPR267XzJvDhtXW4cdTAB3IqvksUZt4ch5xQHgdY0,22705
 librelane/steps/step.py,sha256=YkUWbxx2dOz0QR90jM5NC7neFkWO1RW5zJc0I_XxRyc,54975
 librelane/steps/tclstep.py,sha256=0PMWJ6C3dKnlQf9mA9rZntgxUBCiByE9csHcEcM1iq0,10027
 librelane/steps/verilator.py,sha256=MWx2TpLqYyea9_jSeLG9c2S5ujvYERQZRFNaMhfHxZE,7916
 librelane/steps/yosys.py,sha256=GX6rTiQG-ZhDxfB9SxrPQ9Sab3WC84p0OUtqiL1Nubk,12533
-librelane-2.4.0.dev2.dist-info/METADATA,sha256=JlRl6zQcZGwcjn6ZgcLHZivozmfzMWx0EqDzvFvuY-g,6600
-librelane-2.4.0.dev2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-librelane-2.4.0.dev2.dist-info/entry_points.txt,sha256=GTBvXykNMMFsNKiJFgtEw7P1wb_VZIqVM35EFSpyZQE,263
-librelane-2.4.0.dev2.dist-info/RECORD,,
+librelane-2.4.0.dev4.dist-info/METADATA,sha256=EjKTd191ptXMgWO4Qd-SrS08v70GdDtJORd-kJS38Z0,6600
+librelane-2.4.0.dev4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+librelane-2.4.0.dev4.dist-info/entry_points.txt,sha256=GTBvXykNMMFsNKiJFgtEw7P1wb_VZIqVM35EFSpyZQE,263
+librelane-2.4.0.dev4.dist-info/RECORD,,

librelane/scripts/odbpy/exception_codes.py

@@ -1,17 +0,0 @@
-# Copyright 2023 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.
-
-METAL_LAYER_ERROR = 10
-FORMAT_ERROR = 11
-NOT_FOUND_ERROR = 12