librelane 2.4.0__py3-none-any.whl

librelane/flows/synth_explore.py

@@ -0,0 +1,173 @@
+# 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.
+from __future__ import annotations
+from decimal import Decimal
+import os
+
+import rich
+import rich.table
+from concurrent.futures import Future
+from typing import Dict, List, Optional, Tuple
+
+from .flow import Flow
+from ..state import State
+from ..config import Config
+from ..logging import success
+from ..logging import options, console
+from ..steps import Step, Yosys, OpenROAD, StepError
+
+
+# "Synthesis Exploration" is a non-seqeuential flow that tries all synthesis
+# strategies and shows which ones yield the best area XOR delay
+@Flow.factory.register()
+class SynthesisExploration(Flow):
+    """
+    Synthesis Exploration is a feature that tries multiple synthesis strategies
+    (in the form of different scripts for the ABC utility) to try and find which
+    strategy is better by either minimizing area or maximizing slack (and thus
+    frequency.)
+
+    The output is represented in a tabulated format, e.g.: ::
+
+      ┏━━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┓
+      ┃                ┃       ┃               ┃ Worst Setup      ┃ Total Negative   ┃
+      ┃ SYNTH_STRATEGY ┃ Gates ┃ Area (µm²)    ┃ Slack (ns)       ┃ Setup Slack (ns) ┃
+      ┡━━━━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━┩
+      │ AREA 0         │ 8781  │ 97141.916800  │ 6.288794         │ 0.0              │
+      │ AREA 1         │ 8692  │ 96447.500800  │ 6.434102         │ 0.0              │
+      │ AREA 2         │ 8681  │ 96339.897600  │ 6.276806         │ 0.0              │
+      │ AREA 3         │ 11793 │ 111084.038400 │ 7.011374         │ 0.0              │
+      │ DELAY 0        │ 8969  │ 101418.518400 │ 6.511191         │ 0.0              │
+      │ DELAY 1        │ 8997  │ 101275.881600 │ 6.656564         │ 0.0              │
+      │ DELAY 2        │ 9013  │ 101177.036800 │ 6.691765         │ 0.0              │
+      │ DELAY 3        │ 8733  │ 99190.131200  │ 6.414865         │ 0.0              │
+      │ DELAY 4        │ 8739  │ 101011.878400 │ 6.274565         │ 0.0              │
+      └────────────────┴───────┴───────────────┴──────────────────┴──────────────────┘
+
+    You can then update your config file with the best ``SYNTH_STRATEGY`` for your
+    use-case so it can be used with other flows.
+    """
+
+    Steps = [
+        Yosys.Synthesis,
+        OpenROAD.CheckSDCFiles,
+        OpenROAD.STAPrePNR,
+    ]
+
+    def run(
+        self,
+        initial_state: State,
+        **kwargs,
+    ) -> Tuple[State, List[Step]]:
+        step_list: List[Step] = []
+
+        self.progress_bar.set_max_stage_count(1)
+
+        synth_futures: List[Tuple[Config, Future[State]]] = []
+        self.progress_bar.start_stage("Synthesis Exploration")
+
+        options.set_condensed_mode(True)
+
+        for strategy in [
+            "AREA 0",
+            "AREA 1",
+            "AREA 2",
+            "AREA 3",
+            "DELAY 0",
+            "DELAY 1",
+            "DELAY 2",
+            "DELAY 3",
+            "DELAY 4",
+        ]:
+            config = self.config.copy(SYNTH_STRATEGY=strategy)
+
+            synth_step = Yosys.Synthesis(
+                config,
+                id=f"synthesis-{strategy}",
+                state_in=initial_state,
+            )
+            synth_future = self.start_step_async(synth_step)
+            step_list.append(synth_step)
+
+            sdc_step = OpenROAD.CheckSDCFiles(
+                config,
+                id=f"sdc-{strategy}",
+                state_in=synth_future,
+            )
+            sdc_future = self.start_step_async(sdc_step)
+            step_list.append(sdc_step)
+
+            sta_step = OpenROAD.STAPrePNR(
+                config,
+                state_in=sdc_future,
+                id=f"sta-{strategy}",
+            )
+
+            step_list.append(sta_step)
+            sta_future = self.start_step_async(sta_step)
+
+            synth_futures.append((config, sta_future))
+
+        results: Dict[str, Optional[Tuple[Decimal, Decimal, Decimal, Decimal]]] = {}
+        for config, future in synth_futures:
+            strategy = config["SYNTH_STRATEGY"]
+            results[strategy] = None
+            try:
+                state = future.result()
+                results[strategy] = (
+                    state.metrics["design__instance__count"],
+                    state.metrics["design__instance__area"],
+                    state.metrics["timing__setup__ws"],
+                    state.metrics["timing__setup__tns"],
+                )
+            except StepError:
+                pass  # None == failure
+        self.progress_bar.end_stage()
+        options.set_condensed_mode(False)
+
+        successful_results = {k: v for k, v in results.items() if v is not None}
+        min_gates = min(map(lambda x: x[0], successful_results.values()))
+        min_area = min(map(lambda x: x[1], successful_results.values()))
+        max_slack = max(map(lambda x: x[2], successful_results.values()))
+        max_tns = max(map(lambda x: x[3], successful_results.values()))
+
+        table = rich.table.Table()
+        table.add_column("SYNTH_STRATEGY")
+        table.add_column("Gates")
+        table.add_column("Area (µm²)")
+        table.add_column("Worst Setup Slack (ns)")
+        table.add_column("Total -ve Setup Slack (ns)")
+        for key, result in results.items():
+            gates_s = "[red]Failed"
+            area_s = "[red]Failed"
+            slack_s = "[red]Failed"
+            tns_s = "[red]Failed"
+            if result is not None:
+                gates, area, slack, tns = result
+                gates_s = f"{'[green]' if gates == min_gates else ''}{gates}"
+                area_s = f"{'[green]' if area == min_area else ''}{area}"
+                slack_s = f"{'[green]' if slack == max_slack else ''}{slack}"
+                tns_s = f"{'[green]' if tns == max_tns else ''}{tns}"
+            table.add_row(key, gates_s, area_s, slack_s, tns_s)
+
+        console.print(table)
+        assert self.run_dir is not None
+        file_console = rich.console.Console(
+            file=open(os.path.join(self.run_dir, "summary.rpt"), "w", encoding="utf8"),
+            width=160,
+        )
+        file_console.print(table)
+
+        success("Flow complete.")
+        return (initial_state, step_list)

librelane/help/__main__.py

@@ -0,0 +1,39 @@
+# Copyright 2025 LibreLane Contributors
+#
+# 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.
+from ..common.cli import formatter_settings
+from ..flows import Flow
+from ..steps import Step
+from ..logging import console
+
+import cloup
+
+
+@cloup.command(formatter_settings=formatter_settings)
+@cloup.argument("step_or_flow")
+@cloup.pass_context
+def cli(ctx, step_or_flow):
+    """
+    Displays rich help for the step or flow in question.
+    """
+    if TargetFlow := Flow.factory.get(step_or_flow):
+        TargetFlow.display_help()
+    elif TargetStep := Step.factory.get(step_or_flow):
+        TargetStep.display_help()
+    else:
+        console.log(f"Unknown Flow or Step '{step_or_flow}'.")
+        ctx.exit(-1)
+
+
+if __name__ == "__main__":
+    cli()

librelane/logging/__init__.py

@@ -0,0 +1,40 @@
+# 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.
+"""
+The Logging Module
+------------------
+
+As the name implies, this handles LibreLane's logging using the ``logging``
+module and the ``rich`` library.
+"""
+
+from .logger import (
+    LogLevels,
+    LevelFilter,
+    options,
+    console,
+    set_log_level,
+    reset_log_level,
+    get_log_level,
+    register_additional_handler,
+    deregister_additional_handler,
+    verbose,
+    debug,
+    info,
+    rule,
+    success,
+    warn,
+    err,
+    subprocess,
+)

librelane/logging/logger.py

@@ -0,0 +1,323 @@
+# 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.
+import click
+import atexit
+import logging
+from enum import IntEnum
+from typing import ClassVar, Iterable, Union
+
+import rich.console
+import rich.logging
+from rich.text import Text
+from rich.style import Style, StyleType
+
+
+class LogLevels(IntEnum):
+    ALL = 0
+    DEBUG = 10
+    SUBPROCESS = 12
+    VERBOSE = 15
+    INFO = 20
+    WARNING = 30
+    ERROR = 40
+    CRITICAL = 50
+
+
+console = rich.console.Console()
+atexit.register(lambda: rich.console.Console().show_cursor())
+__event_logger: logging.Logger = logging.getLogger("__librelane__")
+
+
+class options:
+    _condensed_mode: ClassVar[bool] = False
+    _show_progress_bar: ClassVar[bool] = True
+
+    @classmethod
+    def get_condensed_mode(Self) -> bool:
+        return Self._condensed_mode
+
+    @classmethod
+    def set_condensed_mode(Self, condensed: bool):
+        Self._condensed_mode = condensed
+
+    @classmethod
+    def get_show_progress_bar(Self) -> bool:
+        return Self._show_progress_bar
+
+    @classmethod
+    def set_show_progress_bar(Self, show: bool):
+        Self._show_progress_bar = show
+
+
+class NullFormatter(logging.Formatter):
+    def format(self, record):
+        return record.getMessage()
+
+
+class LevelFormatter(logging.Formatter):
+    def format(self, record):
+        message = record.getMessage()
+        if record.levelname == "WARNING":
+            message = f"[yellow]{message}"
+        elif record.levelname == "ERROR":
+            message = f"[red]{message}"
+        elif record.levelname == "CRITICAL":
+            message = f"[red][bold]{message}"
+        else:
+            message = f"{message}"
+        return message
+
+
+class RichHandler(rich.logging.RichHandler):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+    def get_level_text(self, record: logging.LogRecord) -> Text:
+        if not options.get_condensed_mode():
+            return super().get_level_text(record)
+        level_name = record.levelname
+        style: StyleType
+        if level_name == "WARNING":
+            style = Style(color="yellow", bold=True)
+        else:
+            style = f"logging.level.{level_name.lower()}"
+        level_text = Text.styled(
+            f"[{level_name[0]}]",
+            style,
+        )
+        return level_text
+
+
+class KeywordFilter(logging.Filter):
+    def __init__(self, matching_values: dict) -> None:
+        super().__init__()
+        self.matching_values = matching_values.copy()
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        for key, value in self.matching_values.items():
+            if value is None:
+                if hasattr(record, key) and getattr(record, key) is not None:
+                    return False
+            else:
+                if not hasattr(record, key) or getattr(record, key) != value:
+                    return False
+        return True
+
+
+class LevelFilter(logging.Filter):
+    def __init__(self, levels: Iterable[str], invert: bool = False) -> None:
+        self.levels = levels
+        self.invert = invert
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        if options.get_condensed_mode():
+            if record.levelname == "SUBPROCESS":
+                return False
+        if self.invert:
+            return record.levelname not in self.levels
+        else:
+            return record.levelname in self.levels
+
+
+def initialize_logger():
+    global __event_logger, console
+
+    for level in LogLevels:
+        logging.addLevelName(level.value, level.name)
+
+    subprocess_handler = RichHandler(
+        console=console,
+        show_time=False,
+        omit_repeated_times=False,
+        show_level=False,
+        show_path=False,
+        enable_link_path=False,
+        tracebacks_word_wrap=False,
+        keywords=[],
+        markup=False,
+    )
+    subprocess_handler.addFilter(LevelFilter(["SUBPROCESS"]))
+
+    rich_handler = RichHandler(
+        console=console,
+        rich_tracebacks=True,
+        omit_repeated_times=False,
+        markup=True,
+        tracebacks_suppress=[
+            click,
+        ],
+        show_level=True,
+        keywords=[],
+    )
+    rich_handler.setFormatter(LevelFormatter("%(message)s", datefmt="[%X]"))
+    rich_handler.addFilter(LevelFilter(["SUBPROCESS"], invert=True))
+
+    logger = logging.getLogger("__librelane__")
+    logger.setLevel(LogLevels.SUBPROCESS)
+
+    logger.handlers.clear()
+
+    logger.addHandler(subprocess_handler)
+    logger.addHandler(rich_handler)
+
+
+initialize_logger()
+
+
+def register_additional_handler(handler: logging.Handler):
+    """
+    Adds a new handler to the default LibreLane logger.
+
+    :param handler: The new handler. Must be of type ``logging.Handler``
+        or its subclasses.
+    """
+    __event_logger.addHandler(handler)
+
+
+def deregister_additional_handler(handler: logging.Handler):
+    """
+    Removes a registered handler from the default LibreLane logger.
+
+    :param handler: The handler. If not registered, the behavior
+        of this function is undefined.
+    """
+    __event_logger.removeHandler(handler)
+
+
+def set_log_level(lv: Union[str, int]):
+    """
+    Sets the log level of the default LibreLane logger.
+
+    :param lv: Either the name or number of the desired log level.
+    """
+    __event_logger.setLevel(lv)
+
+
+def reset_log_level():
+    """
+    Sets the log level of the default LibreLane logger back to the
+    default log level.
+    """
+    set_log_level("SUBPROCESS")
+
+
+def get_log_level() -> int:
+    """
+    Obtains the numeric log level of the LibreLane logger.
+    """
+    return __event_logger.getEffectiveLevel()
+
+
+def debug(*args, **kwargs):
+    """
+    Logs to the LibreLane logger with the log level DEBUG.
+
+    :param msg: The message to log
+    """
+    if kwargs.get("stacklevel") is None:
+        kwargs["stacklevel"] = 2
+    __event_logger.debug(*args, **kwargs)
+
+
+def verbose(*args, **kwargs):
+    """
+    Logs to the LibreLane logger with the log level VERBOSE.
+    """
+    if kwargs.get("stacklevel") is None:
+        kwargs["stacklevel"] = 2
+    __event_logger.log(
+        LogLevels.VERBOSE,
+        *args,
+        **kwargs,
+    )
+
+
+def info(msg: object, /, **kwargs):
+    """
+    Logs to the LibreLane logger with the log level INFO.
+
+    :param msg: The message to log
+    """
+    if kwargs.get("stacklevel") is None:
+        kwargs["stacklevel"] = 2
+    __event_logger.info(msg, **kwargs)
+
+
+def subprocess(msg: object, /, **kwargs):
+    """
+    Logs to the LibreLane logger with the log level SUBPROCESS.
+
+    :param msg: The message to log
+    """
+    if kwargs.get("stacklevel") is None:
+        kwargs["stacklevel"] = 2
+    __event_logger.log(LogLevels.SUBPROCESS, msg, **kwargs)
+
+
+def rule(title: str = "", /, **kwargs):  # pragma: no cover
+    """
+    Prints a horizontal line on the terminal enclosing the first argument
+    if the log level is <= INFO.
+
+    Kwargs are passed to https://rich.readthedocs.io/en/stable/reference/console.html#rich.console.Console.rule
+
+    :param title: A title string to enclose in the console rule
+    """
+    console.rule(title)
+
+
+def success(msg: object, /, **kwargs):
+    """
+    Logs to the LibreLane logger with the log level INFO.
+
+    :param msg: The message to log
+    """
+    if kwargs.get("stacklevel") is None:
+        kwargs["stacklevel"] = 2
+    __event_logger.info(f"{msg}", **kwargs)
+
+
+def warn(msg: object, /, **kwargs):
+    """
+    Logs to the LibreLane logger with the log level WARNING.
+
+    :param msg: The message to log
+    """
+    if kwargs.get("stacklevel") is None:
+        kwargs["stacklevel"] = 2
+    __event_logger.warning(f"{msg}", **kwargs)
+
+
+def err(msg: object, /, **kwargs):
+    """
+    Logs to the LibreLane logger with the log level ERROR.
+
+    :param msg: The message to log
+    """
+    if kwargs.get("stacklevel") is None:
+        kwargs["stacklevel"] = 2
+    __event_logger.error(f"{msg}", **kwargs)
+
+
+if __name__ == "__main__":
+    initialize_logger()
+    debug("Debug")
+    verbose("Verbose")
+    subprocess("Subprocess")
+    rule("Rule")
+    info("Info")
+    success("Success")
+    warn("Warn")
+    err("Err")
+    print("\n")

librelane/open_pdks_rev

@@ -0,0 +1 @@
+0fe599b2afb6708d281543108caf8310912f54af

librelane/plugins.py

@@ -0,0 +1,21 @@
+# 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.
+import pkgutil
+import importlib
+
+discovered_plugins = {
+    name: importlib.import_module(name)
+    for finder, name, ispkg in pkgutil.iter_modules()
+    if name.startswith("librelane_plugin_") or name.startswith("openlane_plugin_")
+}

librelane/scripts/base.sdc

@@ -0,0 +1,80 @@
+set clock_port __VIRTUAL_CLK__
+if { [info exists ::env(CLOCK_PORT)] } {
+    set port_count [llength $::env(CLOCK_PORT)]
+
+    if { $port_count == "0" } {
+        puts "\[WARNING] No CLOCK_PORT found. A dummy clock will be used."
+    } elseif { $port_count != "1" } {
+        puts "\[WARNING] Multi-clock files are not currently supported by the base SDC file. Only the first clock will be constrained."
+    }
+
+    if { $port_count > "0" } {
+        set ::clock_port [lindex $::env(CLOCK_PORT) 0]
+    }
+}
+set port_args [get_ports $clock_port]
+puts "\[INFO] Using clock $clock_port…"
+create_clock {*}$port_args -name $clock_port -period $::env(CLOCK_PERIOD)
+
+set input_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_DELAY_CONSTRAINT) / 100]
+set output_delay_value [expr $::env(CLOCK_PERIOD) * $::env(IO_DELAY_CONSTRAINT) / 100]
+puts "\[INFO] Setting output delay to: $output_delay_value"
+puts "\[INFO] Setting input delay to: $input_delay_value"
+
+set_max_fanout $::env(MAX_FANOUT_CONSTRAINT) [current_design]
+if { [info exists ::env(MAX_TRANSITION_CONSTRAINT)] } {
+    set_max_transition $::env(MAX_TRANSITION_CONSTRAINT) [current_design]
+}
+if { [info exists ::env(MAX_CAPACITANCE_CONSTRAINT)] } {
+    set_max_capacitance $::env(MAX_CAPACITANCE_CONSTRAINT) [current_design]
+} 
+
+set clk_input [get_port $clock_port]
+set clk_indx [lsearch [all_inputs] $clk_input]
+set all_inputs_wo_clk [lreplace [all_inputs] $clk_indx $clk_indx ""]
+
+#set rst_input [get_port resetn]
+#set rst_indx [lsearch [all_inputs] $rst_input]
+#set all_inputs_wo_clk_rst [lreplace $all_inputs_wo_clk $rst_indx $rst_indx ""]
+set all_inputs_wo_clk_rst $all_inputs_wo_clk
+
+# correct resetn
+set clocks [get_clocks $clock_port]
+
+set_input_delay $input_delay_value -clock $clocks $all_inputs_wo_clk_rst
+set_output_delay $output_delay_value -clock $clocks [all_outputs]
+
+if { ![info exists ::env(SYNTH_CLK_DRIVING_CELL)] } {
+    set ::env(SYNTH_CLK_DRIVING_CELL) $::env(SYNTH_DRIVING_CELL)
+}
+
+set_driving_cell \
+    -lib_cell [lindex [split $::env(SYNTH_DRIVING_CELL) "/"] 0] \
+    -pin [lindex [split $::env(SYNTH_DRIVING_CELL) "/"] 1] \
+    $all_inputs_wo_clk_rst
+
+set_driving_cell \
+    -lib_cell [lindex [split $::env(SYNTH_CLK_DRIVING_CELL) "/"] 0] \
+    -pin [lindex [split $::env(SYNTH_CLK_DRIVING_CELL) "/"] 1] \
+    $clk_input
+
+set cap_load [expr $::env(OUTPUT_CAP_LOAD) / 1000.0]
+puts "\[INFO] Setting load to: $cap_load"
+set_load $cap_load [all_outputs]
+
+puts "\[INFO] Setting clock uncertainty to: $::env(CLOCK_UNCERTAINTY_CONSTRAINT)"
+set_clock_uncertainty $::env(CLOCK_UNCERTAINTY_CONSTRAINT) $clocks
+
+puts "\[INFO] Setting clock transition to: $::env(CLOCK_TRANSITION_CONSTRAINT)"
+set_clock_transition $::env(CLOCK_TRANSITION_CONSTRAINT) $clocks
+
+puts "\[INFO] Setting timing derate to: $::env(TIME_DERATING_CONSTRAINT)%"
+set_timing_derate -early [expr 1-[expr $::env(TIME_DERATING_CONSTRAINT) / 100]]
+set_timing_derate -late [expr 1+[expr $::env(TIME_DERATING_CONSTRAINT) / 100]]
+
+if { [info exists ::env(OPENLANE_SDC_IDEAL_CLOCKS)] && $::env(OPENLANE_SDC_IDEAL_CLOCKS) } {
+    unset_propagated_clock [all_clocks]
+} else {
+    set_propagated_clock [all_clocks]
+}
+

librelane/scripts/klayout/Readme.md

@@ -0,0 +1,2 @@
+## Reference
+https://www.klayout.org/downloads/pymod/doc-qt5/code/index.html