librelane 2.4.0.dev0__py3-none-any.whl

librelane/scripts/odbpy/filter_unannotated.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# Copyright 2023 Efabless Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this report 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
+import pprint
+from collections import namedtuple
+
+from reader import click_odb, click
+
+import odb
+import utl
+
+
+def filter_net(net: odb.dbNet) -> bool:
+    # wire is the physical implementation of a net.
+    # if a net has no wire. there is no problem for it being unannotated
+    return net.getWire() is not None
+
+
+@click.option("--corner")
+@click.option("--checks-report", "checks_report")
+@click.command()
+@click_odb
+def main(reader, corner, checks_report):
+    Net = namedtuple("Net", "name bterms")
+    BTerm = namedtuple("BTerm", "name type")
+
+    db = reader.db
+    block = db.getChip().getBlock()
+    nets = block.getNets()
+
+    report_content = []
+    with open(checks_report, "r") as f:
+        report_content = f.readlines()
+
+    annotation_report_start = "report_parasitic_annotation -report_unannotated\n"
+    annotation_report_end = (
+        "===========================================================================\n"
+    )
+    start_index = report_content.index(annotation_report_start)
+    end_index = report_content.index(annotation_report_end, start_index)
+
+    print("Unannotated report:")
+    pprint.pprint(report_content[start_index:end_index])
+
+    # Sample report:
+    # Found 324 unannotated drivers.
+    #  analog_io[0]
+    #  analog_io[10]
+    #  analog_io[11]
+    # Found 68 partially unannotated drivers.
+    #  wbs_adr_i[0]
+    #   mprj/wbs_adr_i[31]
+    #  wbs_adr_i[10]
+    #   mprj/wbs_adr_i[21]
+    #  wbs_adr_i[11]
+    # ....
+
+    reported_nets = [
+        line.rstrip().lstrip()
+        for line in report_content[start_index:end_index]
+        if re.match(r" \S+", line)
+    ]
+    print("Reported nets:")
+    pprint.pprint(reported_nets)
+    connected_nets = [
+        Net(
+            name=net.getName(),
+            bterms=[
+                BTerm(bterm.getName(), bterm.getIoType()) for bterm in net.getBTerms()
+            ],
+        )
+        for net in nets
+        if (net.getName() in reported_nets) and filter_net(net)
+    ]
+    print("Filtered nets:")
+    pprint.pprint(connected_nets)
+    utl.metric_integer(
+        f"timing__unannotated_net__count__corner:{corner}", len(reported_nets)
+    )
+    utl.metric_integer(
+        f"timing__unannotated_net_filtered__count__corner:{corner}",
+        len(connected_nets),
+    )
+    print("done")
+
+
+if __name__ == "__main__":
+    main()

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()