librelane 2.4.0__py3-none-any.whl

librelane/scripts/odbpy/io_place.py

@@ -0,0 +1,482 @@
+# Copyright 2020-2022 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 functools import partial
+import odb
+
+import os
+import re
+import sys
+import math
+import click
+import random
+from decimal import Decimal
+
+from reader import click_odb
+import ioplace_parser
+
+
+def grid_to_tracks(origin, count, step):
+    tracks = []
+    pos = origin
+    for _ in range(count):
+        tracks.append(pos)
+        pos += step
+    assert len(tracks) > 0
+    tracks.sort()
+
+    return tracks
+
+
+def equally_spaced_sequence(side, side_pin_placement, possible_locations):
+    virtual_pin_count = 0
+    actual_pin_count = len(side_pin_placement)
+    total_pin_count = actual_pin_count + virtual_pin_count
+    for i in range(len(side_pin_placement)):
+        if isinstance(
+            side_pin_placement[i], int
+        ):  # This is an int value indicating virtual pins
+            virtual_pin_count = virtual_pin_count + side_pin_placement[i]
+            actual_pin_count = (
+                actual_pin_count - 1
+            )  # Decrement actual pin count, this value was only there to indicate virtual pin count
+            total_pin_count = actual_pin_count + virtual_pin_count
+    result = []
+    tracks = len(possible_locations)
+
+    if total_pin_count > tracks:
+        print(
+            f"[ERROR] The {side} side of the floorplan doesn't have enough slots for all the pins: {total_pin_count} pins/{tracks} slots.",
+            file=sys.stderr,
+        )
+        print(
+            "[INFO] Try re-assigning pins to other sides or making the floorplan larger.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    elif total_pin_count == tracks:
+        return possible_locations, side_pin_placement  # All positions.
+    elif total_pin_count == 0:
+        return result, side_pin_placement
+
+    # From this point, pin_count always < tracks.
+    tracks_per_pin = math.floor(tracks / total_pin_count)  # >=1
+    # O| | | O| | | O| | |
+    # tracks_per_pin = 3
+    # notice the last two tracks are unused
+    # thus:
+    used_tracks = tracks_per_pin * (total_pin_count - 1) + 1
+    unused_tracks = tracks - used_tracks
+
+    # Place the pins at those tracks...
+    current_track = unused_tracks // 2  # So that the tracks used are centered
+    starting_track_index = current_track
+    if virtual_pin_count == 0:  # No virtual pins
+        for _ in range(0, total_pin_count):
+            result.append(possible_locations[current_track])
+            current_track += tracks_per_pin
+    else:  # There are virtual pins
+        for i in range(len(side_pin_placement)):
+            if not isinstance(side_pin_placement[i], int):  # We have an actual pin
+                result.append(possible_locations[current_track])
+                current_track += tracks_per_pin
+            else:  # Virtual Pins, so just leave their needed spaces
+                current_track += tracks_per_pin * side_pin_placement[i]
+        side_pin_placement = [
+            pin for pin in side_pin_placement if not isinstance(pin, int)
+        ]  # Remove the virtual pins from the side_pin_placement list
+
+    print(f"Placement details for the {side} side")
+    print("Virtual pin count: ", virtual_pin_count)
+    print("Actual pin count: ", actual_pin_count)
+    print("Total pin count: ", total_pin_count)
+    print("Tracks count: ", len(possible_locations))
+    print("Tracks per pin: ", tracks_per_pin)
+    print("Used tracks count: ", used_tracks)
+    print("Unused track count: ", unused_tracks)
+    print("Starting track index: ", starting_track_index)
+
+    VISUALIZE_PLACEMENT = False
+    if VISUALIZE_PLACEMENT:
+        print("Placement Map:")
+        print("[", end="")
+        used_track_indices = []
+        for i, location in enumerate(possible_locations):
+            if location in result:
+                print(f"\033[91m{location}\033[0m, ", end="")
+                used_track_indices.append(i)
+            else:
+                print(f"{location}, ", end="")
+        print("]")
+        print(f"Indices of used tracks: {used_track_indices}")
+        print("---")
+
+    return result, side_pin_placement
+
+
+identifiers = re.compile(r"\b[A-Za-z_][A-Za-z_0-9]*\b")
+standalone_numbers = re.compile(r"\b\d+\b")
+trash = re.compile(r"^[^\w\d]+$")
+
+
+def sorter(bterm, order: ioplace_parser.Order):
+    text: str = bterm.getName()
+    keys = []
+    priority_keys = []
+    # tokenize and add to key
+    while trash.match(text) is None:
+        if match := identifiers.search(text):
+            bus = match[0]
+            start, end = match.span(0)
+            if order == ioplace_parser.Order.busMajor:
+                priority_keys.append(bus)
+            else:
+                keys.append(bus)
+            text = text[:start] + text[end + 1 :]
+        elif match := standalone_numbers.search(text):
+            index = int(match[0])
+            if order == ioplace_parser.Order.bitMajor:
+                priority_keys.append(index)
+            else:
+                keys.append(index)
+            text = text[: match.pos] + text[match.endpos + 1 :]
+        else:
+            break
+    return [priority_keys, keys]
+
+
+@click.command()
+@click.option(
+    "-u",
+    "--unmatched-error",
+    type=click.Choice(["none", "unmatched_design", "unmatched_cfg", "both"]),
+    default=True,
+    help="Treat unmatched pins as error",
+)
+@click.option(
+    "-c",
+    "--config",
+    required=True,
+    type=click.Path(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+        resolve_path=True,
+    ),
+    help="Input configuration file",
+)
+@click.option(
+    "-v",
+    "--ver-length",
+    default=None,
+    type=float,
+    help="Length for pins with N/S orientations in microns.",
+)
+@click.option(
+    "-h",
+    "--hor-length",
+    default=None,
+    type=float,
+    help="Length for pins with E/S orientations in microns.",
+)
+@click.option(
+    "-V",
+    "--ver-layer",
+    required=True,
+    help="Name of metal layer to place vertical pins on.",
+)
+@click.option(
+    "-H",
+    "--hor-layer",
+    required=True,
+    help="Name of metal layer to place horizontal pins on.",
+)
+@click.option(
+    "--hor-extension",
+    default=0,
+    type=float,
+    help="Extension for vertical pins in microns.",
+)
+@click.option(
+    "--ver-extension",
+    default=0,
+    type=float,
+    help="Extension for horizontal pins in microns.",
+)
+@click.option(
+    "--ver-width-mult", default=2, type=float, help="Multiplier for vertical pins."
+)
+@click.option(
+    "--hor-width-mult", default=2, type=float, help="Multiplier for horizontal pins."
+)
+@click_odb
+def io_place(
+    reader,
+    config,
+    ver_layer,
+    hor_layer,
+    ver_width_mult,
+    hor_width_mult,
+    hor_length,
+    ver_length,
+    hor_extension,
+    ver_extension,
+    unmatched_error,
+):
+    """
+    Places the IOs in an input def with an optional config file that supports regexes.
+
+    Config format:
+    #N|#S|#E|#W
+    pin1_regex (low co-ordinates to high co-ordinates; e.g., bottom to top and left to right)
+    pin2_regex
+    ...
+
+    #S|#N|#E|#W
+    """
+    config_file_name = config
+    micron_in_units = reader.dbunits
+
+    H_EXTENSION = int(micron_in_units * hor_extension)
+    V_EXTENSION = int(micron_in_units * ver_extension)
+
+    if H_EXTENSION < 0:
+        H_EXTENSION = 0
+
+    if V_EXTENSION < 0:
+        V_EXTENSION = 0
+
+    H_LAYER = reader.tech.findLayer(hor_layer)
+    V_LAYER = reader.tech.findLayer(ver_layer)
+
+    H_WIDTH = int(Decimal(hor_width_mult) * H_LAYER.getWidth())
+    V_WIDTH = int(Decimal(ver_width_mult) * V_LAYER.getWidth())
+
+    if hor_length is not None:
+        H_LENGTH = int(micron_in_units * hor_length)
+    else:
+        H_LENGTH = max(
+            int(
+                math.ceil(
+                    H_LAYER.getArea() * micron_in_units * micron_in_units / H_WIDTH
+                )
+            ),
+            H_WIDTH,
+        )
+
+    if ver_length is not None:
+        V_LENGTH = int(micron_in_units * ver_length)
+    else:
+        V_LENGTH = max(
+            int(
+                math.ceil(
+                    V_LAYER.getArea() * micron_in_units * micron_in_units / V_WIDTH
+                )
+            ),
+            V_WIDTH,
+        )
+
+    # read config + calculate minima
+    config_file_str = open(config_file_name, "r", encoding="utf8").read()
+
+    try:
+        info_by_side = ioplace_parser.parse(config_file_str)
+    except ValueError as e:
+        print(f"An exception occurred: {e}")
+        exit(os.EX_DATAERR)
+
+    print("Top-level design name:", reader.name)
+
+    bterms = [
+        bterm
+        for bterm in reader.block.getBTerms()
+        if bterm.getSigType() not in ["POWER", "GROUND"]
+    ]
+
+    for side, side_info in info_by_side.items():
+        min = (
+            (V_WIDTH + V_LAYER.getSpacing())
+            if side in ["N", "S"]
+            else (H_WIDTH + H_LAYER.getSpacing())
+        ) / reader.dbunits
+        if side_info.min_distance is None:
+            side_info.min_distance = min
+        if side_info.min_distance < min:
+            print(
+                f"[WARNING] Overriding minimum distance {side_info.min_distance} with {min} for pins on side {side} to avoid overlap.",
+                file=sys.stderr,
+            )
+            side_info.min_distance = min
+
+    # build a list of pins
+    pin_placement = {"N": [], "E": [], "W": [], "S": []}
+
+    regex_by_bterm = {}
+    unmatched_regexes = set()
+    for side, side_info in info_by_side.items():
+        for pin in side_info.pins:
+            if isinstance(pin, int):  # Virtual pins
+                pin_placement[side].append(pin)
+                continue
+
+            anchored_regex = f"^{pin}$"  # anchor
+            matched = False
+            collected = []
+            for bterm in bterms:
+                pin_name = bterm.getName()
+                if re.match(anchored_regex, pin_name) is None:
+                    continue
+                if bterm in regex_by_bterm:
+                    print(
+                        f"[ERROR] Multiple regexes matched {pin_name}. Those are {regex_by_bterm[bterm]} and {pin}",
+                        file=sys.stderr,
+                    )
+                    sys.exit(os.EX_DATAERR)
+                regex_by_bterm[bterm] = pin
+                collected.append(bterm)
+                matched = True
+            collected.sort(key=partial(sorter, order=side_info.sort_mode))
+            pin_placement[side] += collected
+            if not matched:
+                unmatched_regexes.add(pin)
+
+    # check for extra or missing pins
+    not_in_design = unmatched_regexes
+    not_in_config = set(
+        [bterm.getName() for bterm in bterms if bterm not in regex_by_bterm]
+    )
+    mismatches_found = False
+    for is_in, not_in, pins in [
+        ("config", "design", not_in_design),
+        ("design", "config", not_in_config),
+    ]:
+        for name in pins:
+            if (
+                is_in == "config"
+                and (unmatched_error in {"unmatched_cfg", "both"})
+                or is_in == "design"
+                and (unmatched_error in {"unmatched_design", "both"})
+            ):
+                mismatches_found = True
+                print(
+                    f"[ERROR] {name} not found in {not_in} but found in {is_in}.",
+                    file=sys.stderr,
+                )
+            else:
+                print(
+                    f"[WARNING] {name} not found in {not_in} but found in {is_in}.",
+                    file=sys.stderr,
+                )
+
+    if mismatches_found:
+        print("Critical mismatches found.")
+        exit(os.EX_DATAERR)
+
+    if len(not_in_config) > 0:
+        print("Assigning random sides to unmatched pins…")
+        for bterm in not_in_config:
+            random_side = random.choice(list(pin_placement.keys()))
+            pin_placement[random_side].append(bterm)
+
+    # generate slots
+    DIE_AREA = reader.block.getDieArea()
+    BLOCK_LL_X = DIE_AREA.xMin()
+    BLOCK_LL_Y = DIE_AREA.yMin()
+    BLOCK_UR_X = DIE_AREA.xMax()
+    BLOCK_UR_Y = DIE_AREA.yMax()
+
+    print("Block boundaries:", BLOCK_LL_X, BLOCK_LL_Y, BLOCK_UR_X, BLOCK_UR_Y)
+
+    origin, count, h_step = reader.block.findTrackGrid(H_LAYER).getGridPatternY(0)
+    print(f"Horizontal Tracks Origin: {origin}, Count: {count}, Step: {h_step}")
+    h_tracks = grid_to_tracks(origin, count, h_step)
+
+    origin, count, v_step = reader.block.findTrackGrid(V_LAYER).getGridPatternX(0)
+    print(f"Vertical Tracks Origin: {origin}, Count: {count}, Step: {v_step}")
+    v_tracks = grid_to_tracks(origin, count, v_step)
+
+    pin_tracks = {}
+    for side in pin_placement:
+        if side in ["N", "S"]:
+            min_distance = info_by_side[side].min_distance * micron_in_units
+            pin_tracks[side] = [
+                v_tracks[i]
+                for i in range(len(v_tracks))
+                if (i % (math.ceil(min_distance / v_step))) == 0
+            ]
+        elif side in ["W", "E"]:
+            pin_tracks[side] = [
+                h_tracks[i]
+                for i in range(len(h_tracks))
+                if (
+                    i
+                    % (
+                        math.ceil(
+                            info_by_side[side].min_distance * micron_in_units / h_step
+                        )
+                    )
+                )
+                == 0
+            ]
+
+    # reversals (including randomly-assigned pins, if needed)
+    for side, side_info in info_by_side.items():
+        if side_info.reverse_result:
+            pin_placement[side].reverse()
+
+    # create the pins
+    for side in pin_placement:
+        slots, pin_placement[side] = equally_spaced_sequence(
+            side, pin_placement[side], pin_tracks[side]
+        )
+
+        assert len(slots) == len(pin_placement[side])
+
+        for i in range(len(pin_placement[side])):
+            bterm = pin_placement[side][i]
+            slot = slots[i]
+            pin_name = bterm.getName()
+            pins = bterm.getBPins()
+            if len(pins) > 0:
+                print(
+                    f"[WARNING] {pin_name} already has shapes. The shapes will be modified.",
+                    file=sys.stderr,
+                )
+                assert len(pins) == 1
+                pin_bpin = pins[0]
+            else:
+                pin_bpin = odb.dbBPin_create(bterm)
+
+            pin_bpin.setPlacementStatus("PLACED")
+
+            if side in ["N", "S"]:
+                rect = odb.Rect(0, 0, V_WIDTH, V_LENGTH + V_EXTENSION)
+                if side == "N":
+                    y = BLOCK_UR_Y - V_LENGTH
+                else:
+                    y = BLOCK_LL_Y - V_EXTENSION
+                rect.moveTo(slot - V_WIDTH // 2, y)
+                odb.dbBox_create(pin_bpin, V_LAYER, *rect.ll(), *rect.ur())
+            else:
+                rect = odb.Rect(0, 0, H_LENGTH + H_EXTENSION, H_WIDTH)
+                if side == "E":
+                    x = BLOCK_UR_X - H_LENGTH
+                else:
+                    x = BLOCK_LL_X - H_EXTENSION
+                rect.moveTo(x, slot - H_WIDTH // 2)
+                odb.dbBox_create(pin_bpin, H_LAYER, *rect.ll(), *rect.ur())
+
+
+if __name__ == "__main__":
+    io_place()

librelane/scripts/odbpy/ioplace_parser/__init__.py

@@ -0,0 +1,23 @@
+# Copyright 2025 LibreLane Contributors
+#
+# Adapted from ioplace_parser
+#
+# Copyright 2020-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.
+"""
+This is a modified version of https://github.com/efabless/ioplace_parser that
+does NOT use Antlr4 and instead uses a custom parser that is faster and
+dependency-free.
+"""
+from .parse import Side, Order, parse

librelane/scripts/odbpy/ioplace_parser/parse.py

@@ -0,0 +1,147 @@
+# Copyright 2025 LibreLane Contributors
+#
+# Adapted from ioplace_parser
+#
+# Copyright 2020-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 re
+from enum import IntEnum
+from typing import Literal, Optional, Dict, List, Union
+from decimal import Decimal
+import warnings
+
+from dataclasses import dataclass, field
+
+
+class Order(IntEnum):
+    busMajor = 0
+    bitMajor = 1
+
+
+@dataclass
+class Side:
+    min_distance: Optional[Decimal] = None
+    reverse_result: bool = False
+    pins: List[Union[str, int]] = field(default_factory=list)
+    sort_mode: Optional[Order] = Order.busMajor
+
+
+VALUE_ANNOTATIONS = ["min_distance"]
+STANDALONE_ANNOTATIONS = [
+    "bus_major",
+    "bit_major",
+]
+
+
+def parse(string: str) -> Dict[Literal["N", "E", "W", "S"], Side]:
+    """
+    Parses a pin configuration into a dictionary of the four cardinal sides.
+
+    :param string: The input configuration as a string (not a file path)
+    :returns: A dictionary where each cardinal direction points to a Side object.
+    :raises ValueError: On syntax or token recognition errors
+    """
+    sides = {}
+    current_side: Optional[Side] = None
+    global_sort_mode: Order = Order.busMajor
+    global_min_distance: Optional[Decimal] = None
+
+    string_mut = string
+
+    ws_rx = re.compile(r"^\s+")
+    annotation_rx = re.compile(r"^@\s*(\w+)(?:\s*=\s*([0-9]+(?:.[0-9]+)?))?")
+    direction_rx = re.compile(r"^#\s*([NEWS]R?|BUS_SORT)")
+    virtual_pin_rx = re.compile(r"^\$\s*([0-9]+)")
+    non_ws_rx = re.compile(r"^\S+")
+    while len(string_mut):
+        # annotation
+        if skip_match := ws_rx.search(string_mut):
+            string_mut = string_mut[skip_match.end() :]
+        elif anno_match := annotation_rx.search(string_mut):
+            annotation = anno_match[1]
+            if annotation in VALUE_ANNOTATIONS:
+                if anno_match[2] is None:
+                    raise ValueError(f"Annotation {annotation} requires a value")
+                value = anno_match[2]
+                if annotation == "min_distance":
+                    if current_side is None:
+                        global_min_distance = Decimal(value)
+                    else:
+                        current_side.min_distance = Decimal(value)
+            elif annotation in STANDALONE_ANNOTATIONS:
+                if anno_match[2] is not None:
+                    raise ValueError(
+                        f"Annotation {annotation} cannot be assigned a value"
+                    )
+                if annotation == "bus_major":
+                    if current_side is None:
+                        global_sort_mode = Order.busMajor
+                    else:
+                        current_side.sort_mode = Order.busMajor
+                elif annotation == "bit_major":
+                    if current_side is None:
+                        global_sort_mode = Order.bitMajor
+                    else:
+                        current_side.sort_mode = Order.bitMajor
+            else:
+                raise ValueError(f"Unknown annotation '{annotation}'")
+            string_mut = string_mut[anno_match.end() :]
+        elif dir_match := direction_rx.search(string_mut):
+            direction = dir_match[1]
+            if direction == "BUS_SORT":
+                warnings.warn(
+                    "Specifying bit-major using the direction token ('#BUS_SORT') is deprecated: use @bit_major."
+                )
+                global_sort_mode = Order.bitMajor
+            else:
+                current_side = Side(
+                    min_distance=global_min_distance,
+                    reverse_result=len(direction) == 2,
+                    sort_mode=global_sort_mode,
+                )
+                side: Literal["N", "E", "W", "S"] = direction[0]  # type: ignore
+                sides[side] = current_side
+            string_mut = string_mut[dir_match.end() :]
+        elif vp_match := virtual_pin_rx.search(string_mut):
+            count = int(vp_match[1])
+            if current_side is None:
+                raise ValueError(
+                    f"virtual pin declaration ${count} requires a direction to be set first"
+                )
+            current_side.pins.append(count)
+            string_mut = string_mut[vp_match.end() :]
+        elif nonws_match := non_ws_rx.match(string_mut):
+            # assume regex
+            if current_side is None:
+                raise ValueError(
+                    f"identifier/regex '{nonws_match[0]}' requires a direction to be set first"
+                )
+            current_side.pins.append(nonws_match[0])
+            string_mut = string_mut[nonws_match.end() :]
+        else:
+            raise ValueError(
+                f"Syntax Error: Unexpected character starting at {string_mut[:10]}…"
+            )
+
+    all_sides: List[Literal["N", "E", "W", "S"]] = ["N", "E", "W", "S"]
+    for side in all_sides:
+        if side in sides:
+            continue
+        sides[side] = Side(
+            min_distance=global_min_distance,
+            reverse_result=False,
+            sort_mode=global_sort_mode,
+        )
+
+    return sides