librelane 2.4.0__py3-none-any.whl

librelane/scripts/odbpy/apply_def_template.py

@@ -0,0 +1,49 @@
+#!/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 defutil
+import utl
+
+from reader import click_odb, click
+
+
+@click.command()
+@click.option("-t", "--def-template", required=True, help="Template DEF")
+@click.option(
+    "--copy-def-power",
+    default=False,
+    is_flag=True,
+    help="Whether to copy power pins from the DEF template",
+)
+@click.option(
+    "--permissive/--strict",
+    default=False,
+    help="Whether to treat pin matching permissively (ignoring non-matching pins) or strictly (flagging all non-matching pins as errors)",
+)
+@click_odb
+def cli(reader, input_lefs, permissive, copy_def_power, def_template):
+    defutil.relocate_pins(
+        reader.db,
+        input_lefs,
+        def_template,
+        permissive,
+        copy_def_power,
+    )
+    area = defutil.get_die_area(def_template, input_lefs)
+    area_metric = f"{area[0]} {area[1]} {area[2]} {area[3]}"
+    utl.metric("design__die__bbox", area_metric)
+
+
+if __name__ == "__main__":
+    cli()

librelane/scripts/odbpy/cell_frequency.py

@@ -0,0 +1,107 @@
+# Copyright 2024 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 os
+import re
+
+from collections import Counter
+from reader import click, click_odb, OdbReader
+
+import rich
+from rich.table import Table
+from rich.console import Console
+
+
+@click.command()
+@click.option(
+    "--out-dir",
+    type=click.Path(file_okay=False, dir_okay=True),
+    required=True,
+    help="Directory to output tables to",
+)
+@click.option(
+    "--buffer-list",
+    type=click.Path(file_okay=True, dir_okay=False),
+    help="List of wildcard strings",
+)
+@click_odb
+def main(
+    out_dir,
+    buffer_list,
+    reader: OdbReader,
+):
+    db = reader.db
+    block = db.getChip().getBlock()
+
+    pattern = r"^(\S+)__(\S+)_\d+"
+    compiled_pattern = re.compile(pattern)
+
+    cell_frequency_table = Table(
+        "Cell",
+        "Count",
+        title="Cells by Master",
+    )
+    scl_table = Table(
+        "SCL",
+        "Count",
+        title="Cells by SCL",
+    )
+    cell_fn_table = Table(
+        "Cell Function",
+        "Count",
+        title="Cells by Function",
+        title_justify="center",
+    )
+    buffer_table = Table(
+        "Buffer",
+        "Count",
+        title="Buffers by Cell Master",
+    )
+
+    cells = [instance.getMaster().getName() for instance in block.getInsts()]
+    buffers = open(buffer_list).read().split()
+    buffer_frequency = Counter([cell for cell in cells if cell in buffers])
+    cell_frequency = Counter(cells)
+    scl_frequency = Counter()
+    cell_fn_frequency = Counter()
+
+    for cell in cell_frequency.keys():
+        if match := compiled_pattern.search(cell):
+            scl, cell_type = match[1], match[2]
+            cell_type_key = f"{scl}__{cell_type}"
+            scl_frequency[scl] += cell_frequency[cell]
+            cell_fn_frequency[cell_type_key] += cell_frequency[cell]
+
+    console = Console()
+    for table, frequency, name in [
+        (cell_frequency_table, cell_frequency, "cell"),
+        (cell_fn_table, cell_fn_frequency, "cell_function"),
+        (scl_table, scl_frequency, "by_scl"),
+        (buffer_table, buffer_frequency, "buffers"),
+    ]:
+        freqs = sorted(frequency.items(), key=lambda x: x[0])
+        for key, value in freqs:
+            table.add_row(key, str(value))
+
+        table.min_width = console.width
+        console.print(table)
+
+        full_table_path = os.path.join(out_dir, f"{name}.rpt")
+        table.min_width = 160
+        with open(full_table_path, "w") as f:
+            file_console = rich.console.Console(file=f, width=160)
+            file_console.print(table)
+
+
+if __name__ == "__main__":
+    main()

librelane/scripts/odbpy/check_antenna_properties.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+# Copyright 2024 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 yaml
+
+from tempfile import NamedTemporaryFile
+from textwrap import dedent
+from reader import click_odb, click, odb
+
+
+def check_cells(odb_cells):
+    report = []
+
+    for cell in odb_cells:
+        cell_name = cell.getName()
+        inout_pins = []
+        input_pins = []
+        output_pins = []
+        for mterm in cell.getMTerms():
+            if mterm.getSigType() in ["GROUND", "POWER", "ANALOG"]:
+                continue
+            pin_name = mterm.getName()
+            diff_area = mterm.getDiffArea()
+            gate_area = (
+                mterm.getDefaultAntennaModel()
+                and mterm.getDefaultAntennaModel().getGateArea()
+                or []
+            )
+            io_type = mterm.getIoType()
+            if io_type == "INOUT" and not (len(diff_area) or len(gate_area)):
+                inout_pins.append(pin_name)
+            elif io_type == "INPUT" and not len(gate_area):
+                input_pins.append(pin_name)
+            elif io_type == "OUTPUT" and not len(diff_area):
+                output_pins.append(pin_name)
+        if inout_pins:
+            print(
+                f"[WARNING] Cell '{cell_name}' has ({len(inout_pins)}) inout pin(s) without anetnna gate information not antenna diffusion information. They might be disconnected."
+            )
+        if input_pins:
+            print(
+                f"[WARNING] Cell '{cell_name}' has ({len(input_pins)}) input pin(s) without antenna gate information. They might not be connected to a gate."
+            )
+        if output_pins:
+            print(
+                f"[WARNING] Cell '{cell_name}' has ({len(output_pins)}) output pin(s) without antenna diffusion information. They might not be driven."
+            )
+
+        entry = {
+            "cell": cell_name,
+            "inout": inout_pins,
+            "output": output_pins,
+            "input": input_pins,
+        }
+        report.append(entry)
+
+        return report
+
+
+def get_top_level_cell(input_lefs, design_lef, cell_name):
+    db = odb.dbDatabase.create()
+    for lef in input_lefs:
+        odb.read_lef(db, lef)
+    odb.read_lef(db, design_lef)
+
+    with NamedTemporaryFile("w") as f:
+        lines = dedent(
+            """VERSION 5.8 ;
+               DESIGN empty ;
+               END DESIGN
+            """
+        )
+        f.writelines(lines)
+        f.seek(0)
+        odb.read_def(db.getTech(), f.name)
+    libs = db.getLibs()
+    cells = {}
+    for lib in libs:
+        cells.update({m: m for m in lib.getMasters()})
+    top_level_cell = next(
+        filter(lambda cell: cell.getName() in cell_name, cells.keys())
+    )
+    return top_level_cell
+
+
+@click.option(
+    "-c", "--cell-name", required=True, multiple=True, help="Names of cells to check"
+)
+@click.option("--design-lef", help="Top level design LEF view")
+@click.option("-r", "--report-file", help="YAML report file")
+@click.command()
+@click_odb
+def check_antenna_properties(reader, cell_name, report_file, input_lefs, design_lef):
+    cells = []
+    if design_lef:
+        cells.append(get_top_level_cell(input_lefs, design_lef, cell_name))
+    cells += list(filter(lambda cell: cell.getName() in cell_name, reader.cells))
+    report = check_cells(cells)
+
+    with open(report_file, "w") as f:
+        f.write(yaml.dump(report))
+
+
+if __name__ == "__main__":
+    check_antenna_properties()

librelane/scripts/odbpy/contextualize.py

@@ -0,0 +1,109 @@
+# 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 odb
+
+from reader import OdbReader, click_odb, click
+
+
+@click.command()
+@click.option(
+    "-D",
+    "--top-def",
+    required=True,
+    help="DEF view of the top-level design instantiating the macro",
+)
+@click.option(
+    "-L",
+    "--top-lef",
+    required=True,
+    help="DEF view of the top-level design instantiating the macro",
+)
+@click.option("--keep-inner-connections", default=False, is_flag=True)
+@click_odb
+def contextualize(reader, top_def, top_lef, keep_inner_connections):
+    reader.add_lef(top_lef)
+
+    top = OdbReader(top_lef, top_def)
+    macro = reader
+
+    print("Block design name:", macro.name)
+    print("Top-level design name:", top.name)
+
+    nets_top = top.block.getNets()
+    to_connect = {}
+    MACRO_TOP_PLACEMENT_X = 0
+    MACRO_TOP_PLACEMENT_Y = 0
+
+    assert macro.name in [
+        inst.getMaster().getName() for inst in top.block.getInsts()
+    ], "%s not found in %s" % (macro.name, top.name)
+
+    for net in nets_top:
+        iterms = net.getITerms()  # asssumption: no pins (bterms) on top level
+        block_net_name = None
+        for iterm in iterms:
+            macro_name = iterm.getMTerm().getMaster().getName()
+            if macro_name == macro.name:
+                block_net_name = iterm.getMTerm().getName()
+                macro_top_inst = iterm.getInst()
+                (
+                    MACRO_TOP_PLACEMENT_X,
+                    MACRO_TOP_PLACEMENT_Y,
+                ) = macro_top_inst.getLocation()
+                print("Block net name: ", block_net_name)
+                break
+        if block_net_name is not None:
+            to_connect[block_net_name] = []
+            for iterm in iterms:
+                macro_name = iterm.getMTerm().getMaster().getName()
+                if macro_name != macro.name:
+                    to_connect[block_net_name].append(iterm)
+            block_net_name = None
+
+            # print(macro_name, inst_name, end= ' ')
+            # print(iterm.getMTerm().getName())
+
+    # print(to_connect)
+
+    nets_macro = macro.block.getNets()
+    created_macros = {}
+    for net in nets_macro:
+        iterms = net.getITerms()  # asssumption: no pins (bterms) on top level
+        if not keep_inner_connections:
+            for iterm in iterms:
+                iterm.disconnect()
+        if net.getName() in to_connect:
+            for node_iterm in to_connect[net.getName()]:
+                node_master = node_iterm.getMTerm().getMaster()
+                node_inst = node_iterm.getInst()
+                node_inst_name = node_iterm.getInst().getName()
+                if node_inst_name not in created_macros:
+                    created_macros[node_inst_name] = 1
+                    print("Creating: ", node_master.getName(), node_inst_name)
+                    new_inst = odb.dbInst_create(
+                        macro.block, node_master, node_inst_name
+                    )
+                    new_inst.setOrient(node_inst.getOrient())
+                    new_inst.setLocation(
+                        node_inst.getLocation()[0] - MACRO_TOP_PLACEMENT_X,
+                        node_inst.getLocation()[1] - MACRO_TOP_PLACEMENT_Y,
+                    )
+                    new_inst.setPlacementStatus("FIRM")
+                else:
+                    new_inst = macro.block.findInst(node_inst_name)
+                new_inst.findITerm(node_iterm.getMTerm().getName()).connect(net)
+
+
+if __name__ == "__main__":
+    contextualize()