librelane 3.0.0.dev34__tar.gz → 3.0.0.dev37__tar.gz

{librelane-3.0.0.dev34 → librelane-3.0.0.dev37}/PKG-INFO

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

{librelane-3.0.0.dev34 → librelane-3.0.0.dev37}/librelane/flows/cli.py

@@ -1,3 +1,7 @@
+# Copyright 2025 LibreLane Contributors
+#
+# Adapted from OpenLane 2
+#
 # Copyright 2023 Efabless Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,6 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import os
+import sys
 from functools import partial, wraps
 from concurrent.futures import ThreadPoolExecutor
 from typing import Optional, Union
@@ -21,12 +26,15 @@ from click import (
     Parameter,
     echo,
 )
+from click.formatting import join_options
 from cloup import (
     option,
     argument,
     option_group,
     Choice,
-    Path,
+    Argument,
+    Option as CloupOption,
+    Path as CloupPath,
 )
 from cloup.constraints import (
     mutually_exclusive,
@@ -39,6 +47,70 @@ from ..logging import set_log_level, verbose, err, options, LogLevels
 from ..state import State, InvalidState
 
 
+class Option(CloupOption):
+    """
+    A slight modification of cloup.Option that consumes the environment
+    variable(s) in envvar upon use.
+    """
+
+    def resolve_envvar_value(self, ctx: Context) -> Optional[str]:
+        if self.envvar is None:
+            return None
+        evs = self.envvar
+        if isinstance(evs, str):
+            evs = [evs]
+        for envvar in self.envvar:
+            rv = os.environ.pop(envvar, None)
+            if rv:
+                return rv
+        return None
+
+
+class Path(CloupPath):
+    """
+    A modification of cloup.Path that rejects paths starting with a tilde (~)
+    as too ambiguous. This is because of user confusion.
+    """
+
+    def convert(
+        self,
+        value: Union[str, os.PathLike],
+        param: Optional[Parameter],
+        ctx: Optional[Context],
+    ):
+        value = str(value)
+        assert param is not None
+        assert ctx is not None
+
+        is_cmd = False
+        if sys.platform == "win32":
+            import psutil
+
+            is_cmd = psutil.Process(os.getppid()).name().lower().endswith("cmd.exe")
+        if not is_cmd and value.startswith("~"):
+            usage, _ = join_options(param.opts)
+            if isinstance(param, Argument):
+                usage = ""
+            buffer = f"'{value}' starts with a tilde, which is ambiguous.\n"
+            buffer += "  * If you meant your home directory, make sure your POSIX shell is able to expand the tilde:\n"
+            buffer += f"    * GOOD: {ctx.command_path} {usage} {value}   …\n"
+            if usage != "":
+                buffer += f"    * BAD:  {ctx.command_path} {usage}={value}   …\n"
+            buffer += f'    * BAD:  {ctx.command_path} {usage} "{value}" …\n'
+            env_vars = []
+            if param.envvar is not None:
+                if isinstance(param.envvar, str):
+                    env_vars = [param.envvar]
+                else:
+                    env_vars = list(param.envvar)
+            for var in env_vars:
+                buffer += f"    * GOOD: {var}={value}   {ctx.command_path} …\n"
+                buffer += f'    * BAD:  {var}="{value}" {ctx.command_path} …\n'
+            buffer += '  * If you want a relative file or directory that starts with a literal "~", use an absolute path.\n'
+            self.fail(buffer, param, ctx)
+        return super().convert(value, param, ctx)
+
+
 def set_log_level_cb(
     ctx: Context,
     param: Parameter,
@@ -181,7 +253,7 @@ def cloup_flow_opts(
         Ciel is used by default for this CLI or not.
     :returns: The wrapper
     """
-    o = partial(option, show_default=True)
+    o = partial(option, cls=CloupOption, show_default=True)
 
     def decorate(f):
         if config_options:
@@ -355,21 +427,23 @@ def cloup_flow_opts(
                         dir_okay=True,
                     ),
                     is_eager=True,
-                    default=os.environ.pop("PDK_ROOT", None),
+                    envvar=["PDK_ROOT"],
                     help="Override Ciel PDK root folder. Required if Ciel is not installed, but a default value can also be set via the environment variable PDK_ROOT.",
                 ),
                 o(
                     "-p",
                     "--pdk",
                     type=str,
-                    default=os.environ.pop("PDK", "sky130A"),
+                    envvar=["PDK"],
+                    default="sky130A",
                     help="The process design kit to use.",
                 ),
                 o(
                     "-s",
                     "--scl",
                     type=str,
-                    default=os.environ.pop("STD_CELL_LIBRARY", None),
+                    envvar=["STD_CELL_LIBRARY"],
+                    # no default, default is obtained dynamically from PDK
                     help="The standard cell library to use. If None, the PDK's default standard cell library is used.",
                 ),
             )(f)

{librelane-3.0.0.dev34 → librelane-3.0.0.dev37}/librelane/scripts/openroad/cts.tcl

@@ -63,28 +63,27 @@ proc get_buflist {} {
 set arg_list [list]
 lappend arg_list -buf_list [get_buflist]
 lappend arg_list -root_buf $::env(CTS_ROOT_BUFFER)
-lappend arg_list -sink_clustering_size $::env(CTS_SINK_CLUSTERING_SIZE)
-lappend arg_list -sink_clustering_max_diameter $::env(CTS_SINK_CLUSTERING_MAX_DIAMETER)
-lappend arg_list -sink_clustering_enable
+
+append_if_exists_argument arg_list CTS_SINK_CLUSTERING_SIZE -sink_clustering_size
+append_if_exists_argument arg_list CTS_SINK_CLUSTERING_MAX_DIAMETER -sink_clustering_max_diameter
+append_if_flag arg_list CTS_SINK_CLUSTERING_ENABLE -sink_clustering_enable
+append_if_exists_argument arg_list CTS_MACRO_CLUSTERING_SIZE -macro_clustering_size
+append_if_exists_argument arg_list CTS_MACRO_CLUSTERING_MAX_DIAMETER -macro_clustering_max_diameter
+append_if_flag arg_list CTS_DISABLE_POST_PROCESSING -post_cts_disable
+append_if_flag arg_list CTS_OBSTRUCTION_AWARE -obstruction_aware
+append_if_flag arg_list CTS_BALANCE_LEVELS -balance_levels
 
 if { $::env(CTS_DISTANCE_BETWEEN_BUFFERS) != 0 } {
     lappend arg_list -distance_between_buffers $::env(CTS_DISTANCE_BETWEEN_BUFFERS)
 }
-if { $::env(CTS_DISABLE_POST_PROCESSING) } {
-    lappend arg_list -post_cts_disable
-}
-if { [info exists ::env(CTS_OBSTRUCTION_AWARE)] && $::env(CTS_OBSTRUCTION_AWARE) } {
-    lappend arg_list -obstruction_aware
-}
+
 if { [info exists ::env(CTS_SINK_BUFFER_MAX_CAP_DERATE_PCT)] } {
     lappend arg_list -sink_buffer_max_cap_derate [expr $::env(CTS_SINK_BUFFER_MAX_CAP_DERATE_PCT) / 100.0]
 }
+
 if { [info exists ::env(CTS_DELAY_BUFFER_DERATE_PCT)] } {
     lappend arg_list -delay_buffer_derate [expr $::env(CTS_DELAY_BUFFER_DERATE_PCT) / 100]
 }
-if { [info exists ::env(CTS_BALANCE_LEVELS)] && $::env(CTS_BALANCE_LEVELS) } {
-    lappend arg_list -balance_levels
-}
 
 log_cmd clock_tree_synthesis {*}$arg_list
 

{librelane-3.0.0.dev34 → librelane-3.0.0.dev37}/librelane/steps/openroad.py

@@ -2265,17 +2265,33 @@ class CTS(OpenROADStep):
                 "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_ENABLE",
+                bool,
+                "Enables pre-clustering of sinks to create one level of sub-tree before building the H-tree. "
+                + "Each cluster is driven by a buffer which becomes the end point of the H-tree structure.",
+                default=True,
+            ),
             Variable(
                 "CTS_SINK_CLUSTERING_SIZE",
-                int,
+                Optional[int],
                 "Specifies the maximum number of sinks per cluster.",
-                default=25,
             ),
             Variable(
                 "CTS_SINK_CLUSTERING_MAX_DIAMETER",
-                Decimal,
-                "Specifies maximum diameter of the sink cluster.",
-                default=50,
+                Optional[Decimal],
+                "Specifies the maximum diameter of the sink cluster.",
+                units="µm",
+            ),
+            Variable(
+                "CTS_MACRO_CLUSTERING_SIZE",
+                Optional[int],
+                "Specifies the maximum number of sinks per cluster for the macro tree.",
+            ),
+            Variable(
+                "CTS_MACRO_CLUSTERING_MAX_DIAMETER",
+                Optional[Decimal],
+                "Specifies the maximum diameter of the sink cluster for the macro tree.",
                 units="µm",
             ),
             Variable(

{librelane-3.0.0.dev34 → librelane-3.0.0.dev37}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "librelane"
-version = "3.0.0.dev34"
+version = "3.0.0.dev37"
 description = "An infrastructure for implementing chip design flows"
 # Technically, maintainer. We cannot use the maintainers field until
 # poetry-core>=2.0.0 which requires Python version 3.9+. This field does