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

librelane/steps/odb.py

@@ -17,30 +17,28 @@ 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
 
+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 +49,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 +63,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 +88,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 +124,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")
@@ -152,6 +176,10 @@ class OdbpyStep(Step):
 
 @Step.factory.register()
 class CheckMacroAntennaProperties(OdbpyStep):
+    """
+    Prints warnings if the LEF views of macros are missing antenna information.
+    """
+
     id = "Odb.CheckMacroAntennaProperties"
     name = "Check Antenna Properties of Macros Pins in Their LEF Views"
     inputs = OdbpyStep.inputs
@@ -180,7 +208,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 {}, {}
@@ -189,6 +217,10 @@ class CheckMacroAntennaProperties(OdbpyStep):
 
 @Step.factory.register()
 class CheckDesignAntennaProperties(CheckMacroAntennaProperties):
+    """
+    Prints warnings if the LEF view of the design is missing antenna information.
+    """
+
     id = "Odb.CheckDesignAntennaProperties"
     name = "Check Antenna Properties of Pins in The Generated Design LEF view"
     inputs = CheckMacroAntennaProperties.inputs + [DesignFormat.LEF]
@@ -244,7 +276,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 +371,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")
@@ -389,9 +421,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():
@@ -497,6 +527,11 @@ class ReportDisconnectedPins(OdbpyStep):
 
 @Step.factory.register()
 class AddRoutingObstructions(OdbpyStep):
+    """
+    Adds obstructions on metal layers which prevent shapes from being created in
+    the designated areas.
+    """
+
     id = "Odb.AddRoutingObstructions"
     name = "Add Obstructions"
     config_vars = [
@@ -528,7 +563,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}'…"
@@ -539,6 +574,11 @@ class AddRoutingObstructions(OdbpyStep):
 
 @Step.factory.register()
 class RemoveRoutingObstructions(AddRoutingObstructions):
+    """
+    Removes any routing obstructions previously placed by
+    <#Odb.AddRoutingObstructions>`_.
+    """
+
     id = "Odb.RemoveRoutingObstructions"
     name = "Remove Obstructions"
 
@@ -548,6 +588,15 @@ class RemoveRoutingObstructions(AddRoutingObstructions):
 
 @Step.factory.register()
 class AddPDNObstructions(AddRoutingObstructions):
+    """
+    Adds obstructions on metal layers which prevent shapes from being created in
+    the designated areas.
+
+    A soft-duplicate of <#Odb.AddRoutingObstructions>`_ , though this one uses
+    a different variable name so the obstructions can be restricted for PDN
+    steps only.
+    """
+
     id = "Odb.AddPDNObstructions"
     name = "Add PDN obstructions"
 
@@ -565,6 +614,11 @@ class AddPDNObstructions(AddRoutingObstructions):
 
 @Step.factory.register()
 class RemovePDNObstructions(RemoveRoutingObstructions):
+    """
+    Removes any PDN obstructions previously placed by
+    <#Odb.RemovePDNObstructions>`_.
+    """
+
     id = "Odb.RemovePDNObstructions"
     name = "Remove PDN obstructions"
 
@@ -659,7 +713,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 +949,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 +1002,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

@@ -1,3 +1,7 @@
+# Copyright 2025 LibreLane Contributors
+#
+# Adapted from OpenLane
+#
 # Copyright 2023 Efabless Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,8 +19,6 @@ import io
 import os
 import re
 import json
-import tempfile
-import functools
 import subprocess
 from enum import Enum
 from math import inf
@@ -185,6 +187,8 @@ class OpenROADStep(TclStep):
 
     output_processors = [OpenROADOutputProcessor, DefaultOutputProcessor]
 
+    alerts: Optional[List[OpenROADAlert]] = None
+
     config_vars = [
         Variable(
             "PDN_CONNECT_MACROS_TO_GRID",
@@ -264,6 +268,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 +298,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(
@@ -773,7 +780,10 @@ class STAPostPNR(STAPrePNR):
         ),
     ]
 
-    inputs = STAPrePNR.inputs + [DesignFormat.SPEF, DesignFormat.ODB]
+    inputs = STAPrePNR.inputs + [
+        DesignFormat.SPEF,
+        DesignFormat.ODB.mkOptional(),
+    ]
     outputs = STAPrePNR.outputs + [DesignFormat.LIB]
 
     def prepare_env(self, env: dict, state: State) -> dict:
@@ -846,19 +856,21 @@ class STAPostPNR(STAPrePNR):
     ) -> MetricsUpdate:
         current_env["_LIB_SAVE_DIR"] = corner_dir
         metrics_updates = super().run_corner(state_in, current_env, corner, corner_dir)
-        try:
-            filter_unannotated_metrics = self.filter_unannotated_report(
-                corner=corner,
-                checks_report=os.path.join(corner_dir, "checks.rpt"),
-                corner_dir=corner_dir,
-                env=current_env,
-                odb_design=str(state_in[DesignFormat.ODB]),
-            )
-        except subprocess.CalledProcessError as e:
-            self.err(
-                f"Failed filtering unannotated nets for the {corner} timing corner."
-            )
-            raise e
+        filter_unannotated_metrics = {}
+        if odb := state_in[DesignFormat.ODB]:
+            try:
+                filter_unannotated_metrics = self.filter_unannotated_report(
+                    corner=corner,
+                    checks_report=os.path.join(corner_dir, "checks.rpt"),
+                    corner_dir=corner_dir,
+                    env=current_env,
+                    odb_design=str(odb),
+                )
+            except subprocess.CalledProcessError as e:
+                self.err(
+                    f"Failed filtering unannotated nets for the {corner} timing corner."
+                )
+                raise e
         return {**metrics_updates, **filter_unannotated_metrics}
 
     def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
@@ -1039,11 +1051,6 @@ class IOPlacement(OpenROADStep):
                 Optional[Path],
                 "Path to a custom pin configuration file.",
             ),
-            Variable(
-                "FP_DEF_TEMPLATE",
-                Optional[Path],
-                "Points to the DEF file to be used as a template.",
-            ),
             Variable(
                 "FP_IO_VLENGTH",
                 Optional[Decimal],
@@ -1134,9 +1141,7 @@ def get_psm_error_count(rpt: io.TextIOWrapper) -> int:
 
     sio.seek(0)
     violations = yaml.load(sio, Loader=yaml.SafeLoader) or []
-    return functools.reduce(
-        lambda acc, current: acc + len(current["srcs"]), violations, 0
-    )
+    return sum(len(violation["srcs"]) for violation in violations)
 
 
 @Step.factory.register()
@@ -1317,11 +1322,6 @@ class GlobalPlacementSkipIO(_GlobalPlacement):
             default="matching",
             deprecated_names=[("FP_IO_MODE", _migrate_ppl_mode)],
         ),
-        Variable(
-            "FP_DEF_TEMPLATE",
-            Optional[Path],
-            "Points to the DEF file to be used as a template.",
-        ),
     ]
 
     def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
@@ -2127,7 +2127,7 @@ class RepairDesignPostGPL(ResizerStep):
         Variable(
             "DESIGN_REPAIR_BUFFER_OUTPUT_PORTS",
             bool,
-            "Specifies whether or not to insert buffers on input ports when design repairs are run.",
+            "Specifies whether or not to insert buffers on output ports when design repairs are run.",
             default=True,
             deprecated_names=["PL_RESIZER_BUFFER_OUTPUT_PORTS"],
         ),
@@ -2404,30 +2404,47 @@ class DEFtoODB(OpenROADStep):
 
 
 @Step.factory.register()
-class OpenGUI(Step):
+class OpenGUI(OpenSTAStep):
     """
     Opens the ODB view in the OpenROAD GUI. Useful to inspect some parameters,
-    such as routing density and whatnot.
+    such as routing density, timing paths, clock tree and whatnot.
+    The LIBs are loaded by default and the SPEFs if available.
     """
 
     id = "OpenROAD.OpenGUI"
     name = "Open In GUI"
 
-    inputs = [DesignFormat.ODB]
+    inputs = [
+        DesignFormat.ODB,
+        DesignFormat.SPEF.mkOptional(),
+    ]
     outputs = []
 
+    def get_script_path(self) -> str:
+        return os.path.join(get_script_dir(), "openroad", "gui.tcl")
+
+    def get_command(self) -> List[str]:
+        return [
+            "openroad",
+            "-no_splash",
+            "-gui",
+            self.get_script_path(),
+        ]
+
     def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
-        with tempfile.NamedTemporaryFile("a+", suffix=".tcl") as f:
-            f.write(f"read_db \"{state_in['odb']}\"")
-            f.flush()
-
-            subprocess.check_call(
-                [
-                    "openroad",
-                    "-no_splash",
-                    "-gui",
-                    f.name,
-                ]
-            )
+        kwargs, env = self.extract_env(kwargs)
+
+        corner_name, file_list = self._get_corner_files(prioritize_nl=True)
+        file_list.set_env(env)
+        env["_CURRENT_CORNER_NAME"] = corner_name
+
+        env = self.prepare_env(env, state_in)
+
+        command = self.get_command()
+        self.run_subprocess(
+            command,
+            env=env,
+            **kwargs,
+        )
 
         return {}, {}

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"]
 
@@ -291,6 +302,12 @@ class VerilogStep(PyosysStep):
 
 @Step.factory.register()
 class JsonHeader(VerilogStep):
+    """
+    Extracts a high-level hierarchical view of the circuit in JSON format,
+    including power connections. The power connections are used in later steps
+    to ensure macros and cells are connected as desired.
+    """
+
     id = "Yosys.JsonHeader"
     name = "Generate JSON Header"
     long_name = "Generate JSON Header"