librelane 2.4.0.dev9__py3-none-any.whl → 3.0.0.dev23__py3-none-any.whl

librelane/steps/openroad.py

@@ -21,66 +21,56 @@ import re
 import json
 import functools
 import subprocess
-from enum import Enum
-from math import inf
-from glob import glob
-from decimal import Decimal
-from base64 import b64encode
+import textwrap
+import pathlib
 from abc import abstractmethod
-from dataclasses import dataclass
+from base64 import b64encode
 from concurrent.futures import Future, ThreadPoolExecutor
-from typing import (
-    Any,
-    List,
-    Dict,
-    Literal,
-    Set,
-    Tuple,
-    Optional,
-    Union,
-)
-
+from dataclasses import dataclass
+from decimal import Decimal
+from enum import Enum
+from glob import glob
+from math import inf
+from typing import Any, Dict, List, Literal, Optional, Set, Tuple, Union
 
-import yaml
 import rich
 import rich.table
+import yaml
 
+from ..common import (
+    Path,
+    Filter,
+    TclUtils,
+    DRC as DRCObject,
+    _get_process_limit,
+    aggregate_metrics,
+    get_script_dir,
+    mkdirp,
+    process_list_file,
+)
+from ..config import Macro, Variable
+from ..config.flow import option_variables
+from ..logging import console, debug, info, options, verbose
+from ..state import DesignFormat, State
+from .common_variables import (
+    dpl_variables,
+    grt_variables,
+    io_layer_variables,
+    pdn_variables,
+    routing_layer_variables,
+    rsz_variables,
+)
+from .openroad_alerts import OpenROADAlert, OpenROADOutputProcessor
 from .step import (
     CompositeStep,
     DefaultOutputProcessor,
-    StepError,
-    ViewsUpdate,
     MetricsUpdate,
     Step,
+    StepError,
     StepException,
-)
-from .openroad_alerts import (
-    OpenROADAlert,
-    OpenROADOutputProcessor,
+    ViewsUpdate,
 )
 from .tclstep import TclStep
-from .common_variables import (
-    io_layer_variables,
-    pdn_variables,
-    rsz_variables,
-    dpl_variables,
-    grt_variables,
-    routing_layer_variables,
-)
-
-from ..config import Variable, Macro
-from ..config.flow import option_variables
-from ..state import State, DesignFormat
-from ..logging import debug, info, verbose, console, options
-from ..common import (
-    Path,
-    TclUtils,
-    get_script_dir,
-    mkdirp,
-    aggregate_metrics,
-    process_list_file,
-    _get_process_limit,
-)
 
 EXAMPLE_INPUT = """
 li1 X 0.23 0.46
@@ -130,6 +120,22 @@ def pdn_macro_migrator(x):
         return [x.strip()]
 
 
+DesignFormat(
+    "odb",
+    "odb",
+    "OpenDB Database",
+    alts=["ODB"],
+).register()
+
+DesignFormat(
+    "openroad_lef",
+    "openroad.lef",
+    "Library Exchange Format Generated by OpenROAD",
+    alts=["OPENROAD_LEF"],
+    folder_override="lef",
+).register()
+
+
 @Step.factory.register()
 class CheckSDCFiles(Step):
     """
@@ -159,7 +165,7 @@ class CheckSDCFiles(Step):
 
     def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
         default_sdc_file = [
-            var for var in option_variables if var.name == "FALLBACK_SDC_FILE"
+            var for var in option_variables if var.name == "FALLBACK_SDC"
         ][0]
         assert default_sdc_file is not None
 
@@ -191,6 +197,38 @@ class OpenROADStep(TclStep):
     alerts: Optional[List[OpenROADAlert]] = None
 
     config_vars = [
+        Variable(
+            "PNR_CORNERS",
+            Optional[List[str]],
+            "A list of fully-qualified IPVT corners to use during PnR. If unspecified, the value for `STA_CORNERS` from the PDK will be used.",
+            pdk=True,
+        ),
+        Variable(
+            "SET_RC_VERBOSE",
+            bool,
+            "If set to true, set_rc commands are echoed. Quite noisy, but may be useful for debugging.",
+            default=False,
+        ),
+        Variable(
+            "LAYERS_RC",
+            Optional[Dict[str, Dict[str, Dict[str, Decimal]]]],
+            "Used during PNR steps, Specific custom resistance and capacitance values for metal layers."
+            + " For each IPVT corner, a mapping for each metal layer is provided."
+            + " Each mapping describes custom resistance and capacitance values."
+            + " Usage of wildcards for specifying IPVT corners is allowed."
+            + " Units are resistance and capacitance per unit length as defined in the first lib file.",
+            pdk=True,
+        ),
+        Variable(
+            "VIAS_R",
+            Optional[Dict[str, Dict[str, Dict[str, Decimal]]]],
+            "Used during PNR steps, Specific custom resistance values for via layers."
+            + " For each IPVT corner, a mapping for each via layer is provided."
+            + " Each mapping describes custom resistance values."
+            + " Usage of wildcards for specifying IPVT corners is allowed."
+            + " Via resistance is per cut/via with units asdefined in the first lib file.",
+            pdk=True,
+        ),
         Variable(
             "PDN_CONNECT_MACROS_TO_GRID",
             bool,
@@ -221,6 +259,12 @@ class OpenROADStep(TclStep):
             Optional[Path],
             "Points to the DEF file to be used as a template.",
         ),
+        Variable(
+            "DEDUPLICATE_CORNERS",
+            bool,
+            "Cull duplicate IPVT corners during PNR, i.e. corners that share the same set of lib files and values for LAYERS_RC and VIAS_R as another corner are not considered outside of STA.",
+            default=False,
+        ),
     ]
 
     @abstractmethod
@@ -246,7 +290,7 @@ class OpenROADStep(TclStep):
         lib_list = self.toolbox.filter_views(self.config, self.config["LIB"])
         lib_list += self.toolbox.get_macro_views(self.config, DesignFormat.LIB)
 
-        env["_SDC_IN"] = self.config["PNR_SDC_FILE"] or self.config["FALLBACK_SDC_FILE"]
+        env["_SDC_IN"] = self.config["PNR_SDC_FILE"] or self.config["FALLBACK_SDC"]
         env["_PNR_LIBS"] = TclStep.value_to_tcl(lib_list)
         env["_MACRO_LIBS"] = TclStep.value_to_tcl(
             self.toolbox.get_macro_views(self.config, DesignFormat.LIB)
@@ -262,9 +306,8 @@ class OpenROADStep(TclStep):
         """
         The `run()` override for the OpenROADStep class handles two things:
 
-        1. Before the `super()` call: It creates a version of the lib file
-        minus cells that are known bad (i.e. those that fail DRC) and pass it on
-        in the environment variable `_PNR_LIBS`.
+        1. Before the `super()` call: Process _LIB_CORNER_<i> for liberty/corner
+        pairs.
 
         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.
@@ -273,16 +316,111 @@ class OpenROADStep(TclStep):
         kwargs, env = self.extract_env(kwargs)
         env = self.prepare_env(env, state_in)
 
+        corners: List[str] = self.config["PNR_CORNERS"] or [
+            self.config["DEFAULT_CORNER"]
+        ]
+
+        @dataclass
+        class IPVTCorner:
+            name: str
+            libs: List[Path]
+            layers_rc: Optional[Dict[str, Dict[str, Decimal]]]
+            vias_r: Optional[Dict[str, Dict[str, Decimal]]]
+
+            def __eq__(self, other):
+                if not isinstance(other, IPVTCorner):
+                    return False
+                return (
+                    self.libs == other.libs
+                    and self.layers_rc == other.layers_rc
+                    and self.vias_r == other.vias_r
+                )
+
+            def __hash__(self):
+                return hash(
+                    (
+                        frozenset([str(lib) for lib in self.libs]),
+                        TclStep.value_to_tcl(self.layers_rc),
+                        TclStep.value_to_tcl(self.vias_r),
+                    )
+                )
+
+        if "corners" in kwargs:
+            corners = kwargs.pop("corners")
+            debug(f"Corners Override {corners}")
+
+        count = 0
+        ipvt_corners = {}
+        for corner in corners:
+            _, libs, _, _ = self.toolbox.get_timing_files_categorized(
+                self.config, corner
+            )
+            ipvt_corners[corner] = IPVTCorner(corner, libs, None, None)
+            # debug(f"Liberty files for '{corner}' added: {libs}")
+            count += 1
+
         check = False
         if "check" in kwargs:
             check = kwargs.pop("check")
 
+        layers_rc = self.config["LAYERS_RC"]
+        if layers_rc is not None:
+            for corner_wildcard, metal_layers in layers_rc.items():
+                for corner in Filter([corner_wildcard]).filter(corners):
+                    ipvt_corners[corner].layers_rc = metal_layers
+
+        vias_r = self.config["VIAS_R"]
+        if vias_r is not None:
+            for corner_wildcard, metal_layers in vias_r.items():
+                for corner in Filter(corner_wildcard).filter(corners):
+                    ipvt_corners[corner].vias_r = metal_layers
+
+        filtered_ipvt_corners_names_sorted = corners
+        if self.config["DEDUPLICATE_CORNERS"]:
+            filtered_ipvt_corners = {
+                k: v
+                for k, v in ipvt_corners.items()
+                if k in [corner.name for corner in set(ipvt_corners.values())]
+            }
+            filtered_ipvt_corners_names_sorted = [
+                x for _, x in sorted(zip(corners, filtered_ipvt_corners.keys()))
+            ]
+        count = 0
+        for corner_name in filtered_ipvt_corners_names_sorted:
+            vias_r = ipvt_corners[corner_name].vias_r
+            if vias_r is not None:
+                for via, rc in vias_r.items():
+                    res = rc["res"]
+                    env[f"_VIA_R_{count}"] = TclStep.value_to_tcl(
+                        [corner_name, via, res]
+                    )
+                    count += 1
+        count = 0
+        for corner_name in filtered_ipvt_corners_names_sorted:
+            layers_rc = ipvt_corners[corner_name].layers_rc
+            if layers_rc is not None:
+                for layer, rc in layers_rc.items():
+                    res = rc["res"]
+                    cap = rc["cap"]
+                    env[f"_LAYER_RC_{count}"] = TclStep.value_to_tcl(
+                        [corner_name, layer, res, cap]
+                    )
+                    count += 1
+
+        count = 0
+        for corner_name in filtered_ipvt_corners_names_sorted:
+            env[f"_LIB_CORNER_{count}"] = TclStep.value_to_tcl(
+                [corner_name] + ipvt_corners[corner_name].libs
+            )
+            count += 1
+
         command = self.get_command()
 
         subprocess_result = self.run_subprocess(
             command,
             env=env,
             check=check,
+            cwd=self.step_dir,
             **kwargs,
         )
 
@@ -290,10 +428,10 @@ class OpenROADStep(TclStep):
 
         views_updates: ViewsUpdate = {}
         for output in self.outputs:
-            if output.value.multiple:
+            if output.multiple:
                 # Too step-specific.
                 continue
-            path = Path(env[f"SAVE_{output.name}"])
+            path = Path(env[f"SAVE_{output.id.upper()}"])
             if not path.exists():
                 continue
             views_updates[output] = path
@@ -332,7 +470,7 @@ class OpenROADStep(TclStep):
         metrics_path = os.path.join(self.step_dir, "or_metrics_out.json")
         return [
             "openroad",
-            "-exit",
+            ("-gui" if os.getenv("_OPENROAD_GUI", "0") == "1" else "-exit"),
             "-no_splash",
             "-metrics",
             metrics_path,
@@ -420,7 +558,7 @@ class OpenSTAStep(OpenROADStep):
 
         name = timing_corner
         current_corner_spef = None
-        input_spef_dict = state_in[DesignFormat.SPEF]
+        input_spef_dict = state_in.get(DesignFormat.SPEF)
         if input_spef_dict is not None:
             if not isinstance(input_spef_dict, dict):
                 raise StepException(
@@ -737,7 +875,7 @@ class STAPrePNR(MultiCornerSTA):
     def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
         views_updates, metrics_updates = super().run(state_in, **kwargs)
 
-        sdf_dict = state_in[DesignFormat.SDF] or {}
+        sdf_dict = state_in.get(DesignFormat.SDF, {})
         if not isinstance(sdf_dict, dict):
             raise StepException(
                 "Malformed input state: incoming value for SDF is not a dictionary."
@@ -876,7 +1014,7 @@ class STAPostPNR(STAPrePNR):
 
     def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
         views_updates, metrics_updates = super().run(state_in, **kwargs)
-        lib_dict = state_in[DesignFormat.LIB] or {}
+        lib_dict = state_in.get(DesignFormat.LIB, {})
         if not isinstance(lib_dict, dict):
             raise StepException(
                 "Malformed input state: value for LIB is not a dictionary."
@@ -907,6 +1045,19 @@ class Floorplan(OpenROADStep):
     inputs = [DesignFormat.NETLIST]
 
     config_vars = OpenROADStep.config_vars + [
+        Variable(
+            "FP_FLIP_SITES",
+            Optional[List[str]],
+            "Flip these sites vertically. Useful in niche alignment scenarios where single-height cells have ground at the south side and double-height cells have power at the south side, causing a short. In that situation, flipping the sites for single-height cells resolves the issue.",
+            pdk=True,
+        ),
+        Variable(
+            "FP_TRACKS_INFO",
+            Path,
+            "A path to the a classic OpenROAD `.tracks` file. Used by the floorplanner to generate tracks.",
+            deprecated_names=["TRACKS_INFO_FILE"],
+            pdk=True,
+        ),
         Variable(
             "FP_SIZING",
             Literal["absolute", "relative"],
@@ -1101,7 +1252,7 @@ class IOPlacement(OpenROADStep):
 @Step.factory.register()
 class TapEndcapInsertion(OpenROADStep):
     """
-    Places well TAP cells across a floorplan, as well as end-cap cells at the
+    Places welltap cells across a floorplan, as well as endcap cells at the
     edges of the floorplan.
     """
 
@@ -1109,10 +1260,17 @@ class TapEndcapInsertion(OpenROADStep):
     name = "Tap/Decap Insertion"
 
     config_vars = OpenROADStep.config_vars + [
+        Variable(
+            "FP_TAPCELL_DIST",
+            Optional[Decimal],
+            "The distance between tap cell columns. Must be specified if WELLTAP_CELL is specified.",
+            units="µm",
+            pdk=True,
+        ),
         Variable(
             "FP_MACRO_HORIZONTAL_HALO",
             Decimal,
-            "Specify the horizontal halo size around macros while cutting rows.",
+            "Specify the horizontal halo size around macros.",
             default=10,
             units="µm",
             deprecated_names=["FP_TAP_HORIZONTAL_HALO"],
@@ -1120,7 +1278,7 @@ class TapEndcapInsertion(OpenROADStep):
         Variable(
             "FP_MACRO_VERTICAL_HALO",
             Decimal,
-            "Specify the vertical halo size around macros while cutting rows.",
+            "Specify the vertical halo size around macros.",
             default=10,
             units="µm",
             deprecated_names=["FP_TAP_VERTICAL_HALO"],
@@ -1130,6 +1288,30 @@ class TapEndcapInsertion(OpenROADStep):
     def get_script_path(self):
         return os.path.join(get_script_dir(), "openroad", "tapcell.tcl")
 
+    def run(self, state_in, **kwargs):
+        if (
+            self.config["WELLTAP_CELL"] is not None
+            and self.config["FP_TAPCELL_DIST"] is None
+        ):
+            raise StepException("FP_TAPCELL_DIST must be set if WELLTAP_CELL is set.")
+        return super().run(state_in, **kwargs)
+
+
+@Step.factory.register()
+class UnplaceAll(OpenROADStep):
+    """
+    Sets placement status of *all* instances to NONE.
+
+    Useful in flows where a preliminary placement is needed as a pre-requisite
+    to something else but that placement must be discarded.
+    """
+
+    id = "OpenROAD.UnplaceAll"
+    name = "Unplace All"
+
+    def get_script_path(self):
+        return os.path.join(get_script_dir(), "openroad", "ungpl.tcl")
+
 
 def get_psm_error_count(rpt: io.TextIOWrapper) -> int:
     sio = io.StringIO()
@@ -1141,9 +1323,9 @@ def get_psm_error_count(rpt: io.TextIOWrapper) -> int:
             vio_type = line[len(VIO_TYPE_PFX) :].strip()
             sio.write(f"- type: {vio_type}\n")
         elif "bbox = " in line:
-            sio.write(line.replace("bbox = ", "- bbox ="))
+            sio.write(f"    {textwrap.dedent(line.replace('bbox = ', '- bbox ='))}")
         else:
-            sio.write(line)
+            sio.write(f"  {textwrap.dedent(line)}")
 
     sio.seek(0)
     violations = yaml.load(sio, Loader=yaml.SafeLoader) or []
@@ -1212,7 +1394,7 @@ class _GlobalPlacement(OpenROADStep):
                 "The desired placement density of cells. If not specified, the value will be equal to (`FP_CORE_UTIL` + 5 * `GPL_CELL_PADDING` + 10).",
                 units="%",
                 deprecated_names=[
-                    ("PL_TARGET_DENSITY", lambda d: Decimal(d) * Decimal(100.0))
+                    ("PL_TARGET_DENSITY", lambda d: Decimal(d) * Decimal("100"))
                 ],
             ),
             Variable(
@@ -1248,11 +1430,16 @@ class _GlobalPlacement(OpenROADStep):
             ),
             Variable(
                 "GPL_CELL_PADDING",
-                Decimal,
+                int,
                 "Cell padding value (in sites) for global placement. The number will be integer divided by 2 and placed on both sides.",
                 units="sites",
                 pdk=True,
             ),
+            Variable(
+                "PL_KEEP_RESIZE_BELOW_OVERFLOW",
+                Optional[Decimal],
+                "Only applicable when PL_TIME_DRIVEN is enabled. When the overflow is below the set value, timing-driven iterations will retain the resizer changes instead of reverting them. Allowed values are 0 to 1. If not set, a nonzero default value from OpenROAD will be used",
+            ),
         ]
     )
 
@@ -1311,7 +1498,7 @@ class GlobalPlacement(_GlobalPlacement):
 @Step.factory.register()
 class GlobalPlacementSkipIO(_GlobalPlacement):
     """
-    Performs global placement without taking I/O into consideration.
+    Performs preliminary global placement as a basis for pin placement.
 
     This is useful for flows where the:
     * Cells are placed
@@ -1330,6 +1517,11 @@ class GlobalPlacementSkipIO(_GlobalPlacement):
             default="matching",
             deprecated_names=[("FP_IO_MODE", _migrate_ppl_mode)],
         ),
+        Variable(
+            "FP_PIN_ORDER_CFG",
+            Optional[Path],
+            "Path to a custom pin configuration file.",
+        ),
         Variable(
             "FP_DEF_TEMPLATE",
             Optional[Path],
@@ -1341,39 +1533,18 @@ class GlobalPlacementSkipIO(_GlobalPlacement):
         kwargs, env = self.extract_env(kwargs)
         if self.config["FP_DEF_TEMPLATE"] is not None:
             info(
-                f"I/O pins were loaded from {self.config['FP_DEF_TEMPLATE']}. Skipping the first global placement iteration…"
+                f"I/O pins were loaded from {self.config['FP_DEF_TEMPLATE']}. Returning state unaltered…"
+            )
+            return {}, {}
+        if self.config["FP_PIN_ORDER_CFG"] is not None:
+            info(
+                f"I/O pins to be placed from {self.config['FP_PIN_ORDER_CFG']}. Returning state unaltered…"
             )
             return {}, {}
         env["__PL_SKIP_IO"] = "1"
         return super().run(state_in, env=env, **kwargs)
 
 
-@Step.factory.register()
-class BasicMacroPlacement(OpenROADStep):
-    id = "OpenROAD.BasicMacroPlacement"
-    name = "Basic Macro Placement"
-
-    config_vars = OpenROADStep.config_vars + [
-        Variable(
-            "PL_MACRO_HALO",
-            str,
-            "Macro placement halo. Format: `{Horizontal} {Vertical}`.",
-            default="0 0",
-            units="µm",
-        ),
-        Variable(
-            "PL_MACRO_CHANNEL",
-            str,
-            "Channel widths between macros. Format: `{Horizontal} {Vertical}`.",
-            default="0 0",
-            units="µm",
-        ),
-    ]
-
-    def get_script_path(self):
-        raise NotImplementedError()
-
-
 @Step.factory.register()
 class DetailedPlacement(OpenROADStep):
     """
@@ -1584,6 +1755,13 @@ class RepairAntennas(CompositeStep):
 
     Steps = [_DiodeInsertion, CheckAntennas]
 
+    def run(self, state_in: State, **kwargs) -> Tuple[ViewsUpdate, MetricsUpdate]:
+        if self.config["DIODE_CELL"] is None:
+            info(f"'DIODE_CELL' not set. Skipping '{self.id}'…")
+            return {}, {}
+
+        return super().run(state_in, **kwargs)
+
 
 @Step.factory.register()
 class DetailedRouting(OpenROADStep):
@@ -1626,6 +1804,30 @@ class DetailedRouting(OpenROADStep):
             "Specifies the maximum number of optimization iterations during Detailed Routing in TritonRoute.",
             default=64,
         ),
+        Variable(
+            "DRT_SAVE_SNAPSHOTS",
+            bool,
+            "This is an experimental variable. Saves an odb snapshot of the layout each routing iteration. This generates multiple odb files increasing disk usage.",
+            default=False,
+        ),
+        Variable(
+            "DRT_ANTENNA_REPAIR_ITERS",
+            int,
+            "The maximum number of iterations to run antenna repair. Set to a positive integer to attempt to repair antennas and then re-run DRT as appropriate.",
+            default=0,
+        ),
+        Variable(
+            "DRT_ANTENNA_MARGIN",
+            int,
+            "The margin to over fix antenna violations.",
+            default=10,
+            units="%",
+        ),
+        Variable(
+            "DRT_SAVE_DRC_REPORT_ITERS",
+            Optional[int],
+            "Write a DRC report every N iterations. If DRT_SAVE_SNAPSHOTS is enabled, there is an implicit default value of 1.",
+        ),
     ]
 
     def get_script_path(self):
@@ -1635,7 +1837,21 @@ class DetailedRouting(OpenROADStep):
         kwargs, env = self.extract_env(kwargs)
         env["DRT_THREADS"] = env.get("DRT_THREADS", str(_get_process_limit()))
         info(f"Running TritonRoute with {env['DRT_THREADS']} threads…")
-        return super().run(state_in, env=env, **kwargs)
+        views_updates, metrics_updates = super().run(state_in, env=env, **kwargs)
+
+        drc_paths = list(pathlib.Path(self.step_dir).rglob("*.drc*"))
+        for path in drc_paths:
+            drc, _ = DRCObject.from_openroad(
+                open(path, encoding="utf8"), self.config["DESIGN_NAME"]
+            )
+
+            drc.to_klayout_xml(open(pathlib.Path(str(path) + ".xml"), "wb"))
+        #        if violation_count > 0:
+        #            self.warn(
+        #                f"DRC errors found after routing. View the report file at {report_path}.\nView KLayout xml file at {klayout_db_path}"
+        #            )
+
+        return views_updates, metrics_updates
 
 
 @Step.factory.register()
@@ -1793,7 +2009,7 @@ class RCX(OpenROADStep):
         views_updates: ViewsUpdate = {}
         metrics_updates: MetricsUpdate = {}
 
-        spef_dict = state_in[DesignFormat.SPEF] or {}
+        spef_dict = state_in.get(DesignFormat.SPEF, {})
         if not isinstance(spef_dict, dict):
             raise StepException(
                 "Malformed input state: value for SPEF is not a dictionary."
@@ -1930,7 +2146,7 @@ class CutRows(OpenROADStep):
         Variable(
             "FP_MACRO_HORIZONTAL_HALO",
             Decimal,
-            "Specify the horizontal halo size around macros while cutting rows.",
+            "Specify the horizontal halo size around macros.",
             default=10,
             units="µm",
             deprecated_names=["FP_TAP_HORIZONTAL_HALO"],
@@ -1938,18 +2154,24 @@ class CutRows(OpenROADStep):
         Variable(
             "FP_MACRO_VERTICAL_HALO",
             Decimal,
-            "Specify the vertical halo size around macros while cutting rows.",
+            "Specify the vertical halo size around macros.",
             default=10,
             units="µm",
             deprecated_names=["FP_TAP_VERTICAL_HALO"],
         ),
+        Variable(
+            "FP_PRUNE_THRESHOLD",
+            Optional[Decimal],
+            'If specified, all rows smaller in width than this value will be removed. This helps avoid "islets" of cells that are hard to route and connect to PDNs.',
+            pdk=True,
+            units="µm",
+        ),
     ]
 
     def get_script_path(self):
         return os.path.join(get_script_dir(), "openroad", "cut_rows.tcl")
 
 
-@Step.factory.register()
 class WriteViews(OpenROADStep):
     """
     Write various layout views of an ODB design
@@ -1958,8 +2180,8 @@ class WriteViews(OpenROADStep):
     id = "OpenROAD.WriteViews"
     name = "OpenROAD Write Views"
     outputs = OpenROADStep.outputs + [
-        DesignFormat.POWERED_NETLIST_SDF_FRIENDLY,
-        DesignFormat.POWERED_NETLIST_NO_PHYSICAL_CELLS,
+        DesignFormat.SDF_FRIENDLY_POWERED_NETLIST,
+        DesignFormat.LOGICAL_POWERED_NETLIST,
         DesignFormat.OPENROAD_LEF,
     ]
 
@@ -1989,33 +2211,16 @@ class ResizerStep(OpenROADStep):
         **kwargs,
     ) -> Tuple[ViewsUpdate, MetricsUpdate]:
         kwargs, env = self.extract_env(kwargs)
-
-        corners_key: str = "RSZ_CORNERS"
-
-        if "corners_key" in kwargs:
-            corners_key = kwargs.pop("corners_key")
-
-        corners = self.config[corners_key] or self.config["STA_CORNERS"]
-        lib_set_set = set()
-        count = 0
-        for corner in corners:
-            _, libs, _, _ = self.toolbox.get_timing_files_categorized(
-                self.config, corner
-            )
-            lib_set = frozenset(libs)
-            if lib_set in lib_set_set:
-                debug(f"Liberty files for '{corner}' already accounted for- skipped")
-                continue
-            lib_set_set.add(lib_set)
-            env[f"RSZ_CORNER_{count}"] = TclStep.value_to_tcl([corner] + libs)
-            debug(f"Liberty files for '{corner}' added: {libs}")
-            count += 1
-
-        return super().run(state_in, env=env, **kwargs)
+        return super().run(
+            state_in,
+            corners=self.config["RSZ_CORNERS"] or self.config["STA_CORNERS"],
+            env=env,
+            **kwargs,
+        )
 
 
 @Step.factory.register()
-class CTS(ResizerStep):
+class CTS(OpenROADStep):
     """
     Creates a `Clock tree <https://en.wikipedia.org/wiki/Clock_signal#Distribution>`_
     for an ODB file with detailed-placed cells, using reasonably accurate resistance
@@ -2030,6 +2235,32 @@ class CTS(ResizerStep):
         OpenROADStep.config_vars
         + dpl_variables
         + [
+            # sink_buffer_max_cap_derate
+            Variable(
+                "CTS_BALANCE_LEVELS",
+                Optional[bool],
+                "Attempts to keep a similar number of levels in the clock tree across non-register cells (e.g., clock-gate or inverter).",
+            ),
+            Variable(
+                "CTS_SINK_BUFFER_MAX_CAP_DERATE_PCT",
+                Optional[Decimal],
+                "Controls automatic buffer selection. To favor strong(weak) drive strength buffers use a small(large) value."
+                + "The value of 100 means no derating of max cap limit",
+                units="%",
+            ),
+            Variable(
+                "CTS_DELAY_BUFFER_DERATE_PCT",
+                Optional[Decimal],
+                "This option balances latencies between macro cells and registers by inserting delay buffers"
+                + "The value of 100 means all needed delay buffers are inserted",
+                units="%",
+            ),
+            Variable(
+                "CTS_OBSTRUCTION_AWARE",
+                Optional[bool],
+                "Enables obstruction-aware buffering such that clock buffers are not placed on top of blockages or hard macros. "
+                + "This option may reduce legalizer displacement, leading to better latency, skew or timing QoR.",
+            ),
             Variable(
                 "CTS_SINK_CLUSTERING_SIZE",
                 int,
@@ -2066,7 +2297,7 @@ class CTS(ResizerStep):
             Variable(
                 "CTS_CORNERS",
                 Optional[List[str]],
-                "A list of fully-qualified IPVT corners to use during clock tree synthesis. If unspecified, the value for `STA_CORNERS` from the PDK will be used.",
+                "Clock tree synthesis step-specific override for PNR_CORNERS.",
             ),
             Variable(
                 "CTS_ROOT_BUFFER",
@@ -2077,7 +2308,7 @@ class CTS(ResizerStep):
             Variable(
                 "CTS_CLK_BUFFERS",
                 List[str],
-                "Defines the list of clock buffers to be used in CTS.",
+                "Defines the list of clock buffer names or buffer name wildcards to be used in CTS.",
                 deprecated_names=["CTS_CLK_BUFFER_LIST"],
                 pdk=True,
             ),
@@ -2114,7 +2345,10 @@ class CTS(ResizerStep):
                 return {}, {}
 
         views_updates, metrics_updates = super().run(
-            state_in, corners_key="CTS_CORNERS", env=env, **kwargs
+            state_in,
+            corners=self.config["CTS_CORNERS"] or self.config["STA_CORNERS"],
+            env=env,
+            **kwargs,
         )
 
         return views_updates, metrics_updates
@@ -2301,10 +2535,47 @@ class ResizerTimingPostCTS(ResizerStep):
             default=False,
         ),
         Variable(
-            "PL_RESIZER_GATE_CLONING",
+            "PL_RESIZER_SETUP_GATE_CLONING",
             bool,
             "Enables gate cloning when attempting to fix setup violations",
             default=True,
+            deprecated_names=["PL_RESIZER_GATE_CLONING"],
+        ),
+        Variable(
+            "PL_RESIZER_SETUP_BUFFERING",
+            bool,
+            "Rebuffering and load splitting during setup fixing.",
+            default=True,
+        ),
+        Variable(
+            "PL_RESIZER_SETUP_BUFFER_REMOVAL",
+            bool,
+            "Buffer removal transform during setup fixing.",
+            default=True,
+        ),
+        Variable(
+            "PL_RESIZER_SETUP_REPAIR_TNS_PCT",
+            Optional[Decimal],
+            "Percentage of violating endpoints to repair during setup fixing.",
+            units="%",
+        ),
+        Variable(
+            "PL_RESIZER_SETUP_MAX_UTIL_PCT",
+            Optional[Decimal],
+            "Defines the percentage of core area used during setup fixing.",
+            units="%",
+        ),
+        Variable(
+            "PL_RESIZER_HOLD_REPAIR_TNS_PCT",
+            Optional[Decimal],
+            "Percentage of violating endpoints to repair during hold fixing.",
+            units="%",
+        ),
+        Variable(
+            "PL_RESIZER_HOLD_MAX_UTIL_PCT",
+            Optional[Decimal],
+            "Defines the percentage of core area used during hold fixing.",
+            units="%",
         ),
         Variable(
             "PL_RESIZER_FIX_HOLD_FIRST",
@@ -2374,10 +2645,11 @@ class ResizerTimingPostGRT(ResizerStep):
             deprecated_names=["GLB_RESIZER_ALLOW_SETUP_VIOS"],
         ),
         Variable(
-            "GRT_RESIZER_GATE_CLONING",
+            "GRT_RESIZER_SETUP_GATE_CLONING",
             bool,
             "Enables gate cloning when attempting to fix setup violations",
             default=True,
+            deprecated_names=["GRT_RESIZER_GATE_CLONING"],
         ),
         Variable(
             "GRT_RESIZER_RUN_GRT",
@@ -2385,6 +2657,42 @@ class ResizerTimingPostGRT(ResizerStep):
             "Gates running global routing after resizer steps. May be useful to disable for designs where global routing takes non-trivial time.",
             default=True,
         ),
+        Variable(
+            "GRT_RESIZER_SETUP_BUFFERING",
+            bool,
+            "Rebuffering and load splitting during setup fixing.",
+            default=True,
+        ),
+        Variable(
+            "GRT_RESIZER_SETUP_BUFFER_REMOVAL",
+            bool,
+            "Buffer removal transform during setup fixing.",
+            default=True,
+        ),
+        Variable(
+            "GRT_RESIZER_SETUP_REPAIR_TNS_PCT",
+            Optional[Decimal],
+            "Percentage of violating endpoints to repair during setup fixing.",
+            units="%",
+        ),
+        Variable(
+            "GRT_RESIZER_SETUP_MAX_UTIL_PCT",
+            Optional[Decimal],
+            "Defines the percentage of core area used during setup fixing.",
+            units="%",
+        ),
+        Variable(
+            "GRT_RESIZER_HOLD_REPAIR_TNS_PCT",
+            Optional[Decimal],
+            "Percentage of violating endpoints to repair during hold fixing.",
+            units="%",
+        ),
+        Variable(
+            "GRT_RESIZER_HOLD_MAX_UTIL_PCT",
+            Optional[Decimal],
+            "Defines the percentage of core area used during hold fixing.",
+            units="%",
+        ),
         Variable(
             "GRT_RESIZER_FIX_HOLD_FIRST",
             bool,
@@ -2461,3 +2769,22 @@ class OpenGUI(OpenSTAStep):
         )
 
         return {}, {}
+
+
+@Step.factory.register()
+class DumpRCValues(OpenROADStep):
+    """
+    Creates three reports:
+
+    * Initial Database Layer RC Values (from Tech LEF)
+    * Modified Database Layer RC Values
+    * Modified Resizer Layer RC Values
+    """
+
+    id = "OpenROAD.DumpRCValues"
+    name = "Dump RC Values"
+
+    inputs = [DesignFormat.DEF]
+
+    def get_script_path(self) -> str:
+        return os.path.join(get_script_dir(), "openroad", "dump_rc.tcl")