librelane 2.4.0.dev0__py3-none-any.whl

librelane/scripts/odbpy/label_macro_pins.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+# Copyright 2020 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 odb
+
+from reader import OdbReader, click_odb, click
+
+
+@click.command()
+@click.option(
+    "-n",
+    "--netlist-def",
+    required=True,
+    help="DEF view of the design that has the connectivity information",
+)
+@click.option("-v", "--verbose", default=False, is_flag=True)
+@click.option("-a", "--all-shapes", default=False, is_flag=True)
+@click.option(
+    "-N",
+    "--pad-pin-name",
+    default="PAD",
+    help="Name of the pin of the pad as it appears in the netlist def.",
+)
+@click.option(
+    "-m",
+    "--map",
+    default="",
+    help="Semicolon;delimited extra mappings that are hard to infer from the netlist def. Format: -extra pad_instance_name pad_pin block_pin (INPUT|OUTPUT|INOUT)",
+)
+@click_odb
+def label_macro_pins(
+    netlist_def,
+    verbose,
+    all_shapes,
+    pad_pin_name,
+    map,
+    input_lefs,
+    reader,
+):
+    """
+    Takes a DEF file with no PINS section, a LEF file that has the shapes of all
+    i/o ports that need to labeled, and a netlist where i/o ports are connected
+    to single macro pin given also as an input -> writes a PINS section with shapes
+    generated over those macro pins, "labels".
+    """
+    top = reader
+
+    extra_mappings = []
+    extra_mappings_pin_names = []
+    if map != "":
+        extra_mappings = [tuple(m.split()) for m in map.split(";")]
+        extra_mappings_pin_names = [tup[2] for tup in extra_mappings]
+
+    def getBiggestBox(iterm):
+        inst = iterm.getInst()
+        px, py = inst.getOrigin()
+        orient = inst.getOrient()
+        transform = odb.dbTransform(orient, odb.Point(px, py))
+
+        mterm = iterm.getMTerm()
+        mpins = mterm.getMPins()
+
+        # label biggest mpin
+        biggest_mpin = None
+        biggest_size = -1
+        for i in range(len(mpins)):
+            mpin = mpins[i]
+            box = mpin.getGeometry()[
+                0
+            ]  # assumes there's only one; to extend and get biggest
+
+            llx, lly = box.xMin(), box.yMin()
+            urx, ury = box.xMax(), box.yMax()
+            area = (urx - llx) * (ury - lly)
+            if area > biggest_size:
+                biggest_size = area
+                biggest_mpin = mpin
+
+        main_mpin = biggest_mpin
+        box = main_mpin.getGeometry()[0]
+        ll = odb.Point(box.xMin(), box.yMin())
+        ur = odb.Point(box.xMax(), box.yMax())
+        # x = (ll.getX() + ur.getX())//2
+        # y = (ll.getY() + ur.getY())//2
+        # if VERBOSE: print(x, y)
+        transform.apply(ll)
+        transform.apply(ur)
+
+        layer = box.getTechLayer()
+
+        return [(layer, ll, ur)]
+
+    def getAllBoxes(iterm):
+        inst = iterm.getInst()
+        px, py = inst.getOrigin()
+        orient = inst.getOrient()
+        transform = odb.dbTransform(orient, odb.Point(px, py))
+
+        mterm = iterm.getMTerm()
+        mpins = mterm.getMPins()
+
+        boxes = []
+
+        for i in range(len(mpins)):
+            mpin = mpins[i]
+            geometries = mpin.getGeometry()
+            for box in geometries:
+                # llx, lly = box.xMin(), box.yMin()
+                # urx, ury = box.xMax(), box.yMax()
+                ll = odb.Point(box.xMin(), box.yMin())
+                ur = odb.Point(box.xMax(), box.yMax())
+                transform.apply(ll)
+                transform.apply(ur)
+                layer = box.getTechLayer()
+                boxes.append((layer, ll, ur))
+
+        return boxes
+
+    def labelITerm(top, pad_iterm, pin_name, iotype, all_shapes_flag=False):
+        net_name = pin_name
+        net = top.block.findNet(net_name)
+        if net is None:
+            net = odb.dbNet_create(top.block, net_name)
+
+        pin_bterm = top.block.findBTerm(pin_name)
+        if pin_bterm is None:
+            pin_bterm = odb.dbBTerm_create(net, pin_name)
+
+        assert pin_bterm is not None, "Failed to create or find " + pin_name
+
+        pin_bterm.setIoType(iotype)
+
+        pin_bpin = odb.dbBPin_create(pin_bterm)
+        pin_bpin.setPlacementStatus("PLACED")
+
+        if not all_shapes_flag:
+            boxes = getBiggestBox(pad_iterm)
+        else:
+            boxes = getAllBoxes(pad_iterm)
+
+        for box in boxes:
+            layer, ll, ur = box
+            odb.dbBox_create(
+                pin_bpin, layer, ll.getX(), ll.getY(), ur.getX(), ur.getY()
+            )
+
+        pad_iterm.connect(net)
+        pin_bterm.connect(net)
+
+    mapping = OdbReader(input_lefs, netlist_def)
+
+    pad_pin_map = {}
+    for net in mapping.block.getNets():
+        iterms = net.getITerms()
+        bterms = net.getBTerms()
+        if len(iterms) >= 1 and len(bterms) == 1:
+            pin_name = bterms[0].getName()
+            if pin_name in extra_mappings_pin_names:
+                if verbose:
+                    print(pin_name, "handled by an external mapping; skipping...")
+                continue
+
+            pad_name = None
+            pad_pin_name = None
+            for iterm in iterms:
+                iterm_pin_name = iterm.getMTerm().getName()
+                if iterm_pin_name == pad_pin_name:
+                    pad_name = iterm.getInst().getName()
+                    pad_pin_name = iterm_pin_name
+                    break
+
+            # '\[' and '\]' are common DEF names
+
+            if pad_name is None:
+                print(
+                    "Warning: net",
+                    net.getName(),
+                    "has a BTerm but no ITerms that match PAD_PIN_NAME",
+                )
+
+                print("Warning: will label the first ITerm on the net!!!!!!!")
+
+                pad_name = iterms[0].getInst().getName()
+                pad_pin_name = iterms[0].getMTerm().getName()
+
+            if verbose:
+                print(
+                    "Labeling ",
+                    net.getName(),
+                    "(",
+                    pin_name,
+                    "-",
+                    pad_name,
+                    "/",
+                    pad_pin_name,
+                    ")",
+                )
+
+            pad_pin_map.setdefault(pad_name, [])
+            pad_pin_map[pad_name].append(
+                (pad_pin_name, pin_name, bterms[0].getIoType())
+            )
+
+    for mapping in extra_mappings:
+        pad_pin_map.setdefault(mapping[0], [])
+        pad_pin_map[mapping[0]].append((mapping[1], mapping[2], mapping[3]))
+
+    pad_pins_to_label_count = len(
+        [
+            mapping
+            for sublist in [pair[1] for pair in pad_pin_map.items()]
+            for mapping in sublist
+        ]
+    )
+    bterms = mapping.block.getBTerms()
+    print(
+        set([bterm.getName() for bterm in bterms])
+        - set(
+            [
+                mapping[1]
+                for sublist in [pair[1] for pair in pad_pin_map.items()]
+                for mapping in sublist
+            ]
+        )
+    )
+    assert pad_pins_to_label_count == len(
+        bterms
+    ), "Some pins were not going to be labeled %d/%d" % (
+        pad_pins_to_label_count,
+        len(bterms),
+    )
+    print("Labeling", len(pad_pin_map), "pads")
+    print("Labeling", pad_pins_to_label_count, "pad pins")
+    if verbose:
+        print(pad_pin_map)
+
+    ##############
+
+    labeled_count = 0
+    labeled = []
+    for inst in top.block.getInsts():
+        inst_name = inst.getName()
+        if inst_name in pad_pin_map:
+            for mapping in pad_pin_map[inst_name]:
+                labeled_count += 1
+                pad_pin_name = mapping[0]
+                pin_name = mapping[1]
+                iotype = mapping[2]
+                if verbose:
+                    print("Found: ", inst_name, pad_pin_name, pin_name)
+
+                pad_iterm = inst.findITerm(pad_pin_name)
+
+                labelITerm(top, pad_iterm, pin_name, iotype, all_shapes_flag=all_shapes)
+
+                labeled.append(inst_name)
+
+    assert labeled_count == pad_pins_to_label_count, (
+        "Didn't label what I set out to label %d/%d"
+        % (labeled_count, pad_pins_to_label_count),
+        set(pad_pin_map.keys()) - set(labeled),
+    )
+
+
+if __name__ == "__main__":
+    label_macro_pins()

librelane/scripts/odbpy/lefutil.py

@@ -0,0 +1,97 @@
+# 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.
+import re
+
+from reader import OdbReader, click
+
+
+@click.group()
+def cli():
+    pass
+
+
+@click.command("get_metal_layers")
+@click.option("--output", "-o", default="/dev/stdout", help="Output file.")
+@click.argument("lefs", nargs=-1)
+def get_metal_layers(output, lefs):
+    reader = OdbReader(lefs, None)
+
+    layers = [
+        layer for layer in reader.tech.getLayers() if layer.getRoutingLevel() >= 1
+    ]
+
+    layer_names = [
+        layer.getName()
+        for layer in sorted(layers, key=lambda layer: layer.getRoutingLevel())
+    ]
+
+    with open(output, "w") as f:
+        f.write(" ".join(layer_names))
+
+    print(layer_names)
+
+
+cli.add_command(get_metal_layers)
+
+
+@click.command("zeroize_origin")
+@click.option("--output", "-o", default="./out.lef", help="Output file.")
+@click.argument("lef")
+def zeroize_origin(output, lef):
+    RECT_REGEX = re.compile(
+        r"^\s*RECT\s+(-?\d+\.?\d*)\s+(-?\d+\.?\d*)\s+(-?\d+\.?\d*)\s+(-?\d+\.?\d*)\s+;$"
+    )
+    ORIGIN_REGEX = re.compile(r"^\s*ORIGIN\s+(-?\d+\.?\d*)\s+(-?\d+\.?\d*)\s+;$")
+
+    lef_lines = open(lef).read().splitlines()
+
+    with open(output, "w") as f:
+        OFFSET_X = OFFSET_Y = 0
+        for line in lef_lines:
+            if line.isspace():
+                continue
+            origin_match = ORIGIN_REGEX.search(line)
+            if origin_match:
+                OFFSET_X, OFFSET_Y = float(origin_match.group(1)), float(
+                    origin_match.group(2)
+                )
+                print(line[: line.find("O")] + "ORIGIN %.3f %.3f ;" % (0, 0), file=f)
+            else:
+                rect_match = RECT_REGEX.search(line)
+                if rect_match:
+                    llx, lly, urx, ury = (
+                        float(rect_match.group(1)),
+                        float(rect_match.group(2)),
+                        float(rect_match.group(3)),
+                        float(rect_match.group(4)),
+                    )
+                    print(
+                        line[: line.find("R")]
+                        + "RECT %.3f %.3f %.3f %.3f ;"
+                        % (
+                            llx + OFFSET_X,
+                            lly + OFFSET_Y,
+                            urx + OFFSET_X,
+                            ury + OFFSET_Y,
+                        ),
+                        file=f,
+                    )
+                else:
+                    print(line, end="", file=f)
+
+
+cli.add_command(zeroize_origin)
+
+if __name__ == "__main__":
+    cli()

librelane/scripts/odbpy/placers.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+# Copyright 2020 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 sys
+from decimal import Decimal
+
+from reader import click_odb, click
+
+
+@click.group
+def cli():
+    pass
+
+
+LEF2OA_MAP = {
+    "N": "R0",
+    "S": "R180",
+    "W": "R90",
+    "E": "R270",
+    "FN": "MY",
+    "FS": "MX",
+    "FW": "MXR90",
+    "FE": "MYR90",
+}
+
+
+def lef_rot_to_oa_rot(rot):
+    if rot in LEF2OA_MAP:
+        return LEF2OA_MAP[rot]
+    else:
+        assert rot in [item[1] for item in LEF2OA_MAP.items()], rot
+        return rot
+
+
+def gridify(n, f):
+    """
+    e.g., (1.1243, 0.005) -> 1.120
+    """
+    return round(n / f) * f
+
+
+@click.command()
+@click.option("-c", "--config", required=True, help="Configuration file")
+@click.option(
+    "-f",
+    "--fixed",
+    default=False,
+    is_flag=True,
+    help="A flag to signal whether the placement should be fixed or not",
+)
+@click_odb
+def manual_macro_placement(reader, config, fixed):
+    """
+    Places macros in positions and orientations specified by a config file
+    """
+
+    db_units_per_micron = reader.block.getDbUnitsPerMicron()
+
+    # read config
+    macros = {}
+    with open(config, "r") as config_file:
+        for line in config_file:
+            # Discard comments and empty lines
+            line = line.split("#")[0].strip()
+            if not line:
+                continue
+            line = line.split()
+            name, x, y, orientation = line
+            macro_data = [
+                name,
+                int(Decimal(x) * db_units_per_micron),
+                int(Decimal(y) * db_units_per_micron),
+                orientation,
+            ]
+            name_escaped = reader.escape_verilog_name(name)
+            macros[name_escaped] = macro_data
+
+    print("Placing the following macros:")
+    print(macros)
+
+    print("Design name:", reader.name)
+
+    macros_cnt = len(macros)
+    for inst in reader.block.getInsts():
+        inst_name = inst.getName()
+        if inst.isFixed():
+            assert inst_name not in macros, inst_name
+            continue
+        if inst_name in macros:
+            print("Placing", inst_name)
+            macro_data = macros[inst_name]
+            _, x, y, orientation = macro_data
+            x = gridify(x, 5)
+            y = gridify(y, 5)
+            inst.setOrient(lef_rot_to_oa_rot(orientation))
+            inst.setLocation(x, y)
+            if fixed:
+                inst.setPlacementStatus("FIRM")
+            else:
+                inst.setPlacementStatus("PLACED")
+            del macros[inst_name]
+
+    if len(macros):
+        print("Declared macros not instantiated in design:", file=sys.stderr)
+        for macro in macros.values():
+            print(f"* {macro[0]}", file=sys.stderr)
+        exit(1)
+
+    print(f"Successfully placed {macros_cnt} instances.")
+
+
+cli.add_command(manual_macro_placement)
+
+
+@click.command()
+@click_odb
+def manual_global_placement(reader):
+    db_units_per_micron = reader.block.getDbUnitsPerMicron()
+
+    data = reader.config["MANUAL_GLOBAL_PLACEMENTS"]
+    not_found = []
+    for instance, info in data.items():
+        name_escaped = reader.escape_verilog_name(instance)
+        x, y = info["location"]
+        orientation = lef_rot_to_oa_rot(info["orientation"])
+        found = False
+        for inst in reader.block.getInsts():
+            if inst.getName() == name_escaped:
+                found = True
+                x_dbu = int(x * db_units_per_micron)
+                y_dbu = int(y * db_units_per_micron)
+                inst.setOrient(lef_rot_to_oa_rot(orientation))
+                inst.setLocation(x_dbu, y_dbu)
+                inst.setPlacementStatus("PLACED")
+                break
+        if not found:
+            not_found.append(instance)
+
+    if len(not_found):
+        print(
+            "[ERROR] One or more instances not found. Make sure you use their Verilog and not their LEF names."
+        )
+        for instance in not_found:
+            print(f"* {instance}")
+        exit(1)
+
+
+cli.add_command(manual_global_placement)
+
+if __name__ == "__main__":
+    cli()