lambdapdk 0.1.37__tar.gz → 0.1.38__tar.gz

{lambdapdk-0.1.37/lambdapdk.egg-info → lambdapdk-0.1.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lambdapdk
-Version: 0.1.37
+Version: 0.1.38
 Summary: Library of open source Process Design Kits
 Author: Zero ASIC
 License:                                  Apache License
@@ -206,6 +206,7 @@ Requires-Dist: pytest-timeout==2.3.1; extra == "test"
 Requires-Dist: tclint==0.4.2; extra == "test"
 Requires-Dist: lambdalib==0.3.0; extra == "test"
 Requires-Dist: sc-leflib==0.4.0; extra == "test"
+Requires-Dist: Jinja2==3.1.4; extra == "test"
 
 # Lambdapdk Introduction
 
@@ -221,6 +222,7 @@ Supported PDKs:
 * [Skywater130](lambdapdk/sky130/base/README.md)
 * [Global Foundries 180](lambdapdk/gf180/README.md)
 * [IHP 180](https://github.com/IHP-GmbH/IHP-Open-PDK)
+* [interposer](lambdapdk/interposer/README.md)
 
 # License
 

{lambdapdk-0.1.37 → lambdapdk-0.1.38}/README.md

@@ -12,6 +12,7 @@ Supported PDKs:
 * [Skywater130](lambdapdk/sky130/base/README.md)
 * [Global Foundries 180](lambdapdk/gf180/README.md)
 * [IHP 180](https://github.com/IHP-GmbH/IHP-Open-PDK)
+* [interposer](lambdapdk/interposer/README.md)
 
 # License
 

{lambdapdk-0.1.37 → lambdapdk-0.1.38}/lambdapdk/__init__.py

@@ -1,7 +1,7 @@
 import siliconcompiler.package as sc_package
 
 
-__version__ = "0.1.37"
+__version__ = "0.1.38"
 
 
 def register_data_source(chip):
@@ -20,10 +20,10 @@ def get_pdks():
     Returns a list of pdk names in lambdapdk
     '''
 
-    from lambdapdk import asap7, freepdk45, sky130, gf180, ihp130
+    from lambdapdk import asap7, freepdk45, sky130, gf180, ihp130, interposer
 
     all_pdks = []
-    for pdk_mod in [asap7, freepdk45, sky130, gf180, ihp130]:
+    for pdk_mod in [asap7, freepdk45, sky130, gf180, ihp130, interposer]:
         pdks = pdk_mod.setup()
         if not isinstance(pdks, (list, tuple)):
             pdks = [pdks]
@@ -43,6 +43,7 @@ def get_libs():
     from lambdapdk.sky130.libs import sky130sc, sky130io, sky130sram
     from lambdapdk.gf180.libs import gf180mcu, gf180io, gf180sram
     from lambdapdk.ihp130.libs import sg13g2_stdcell, sg13g2_sram
+    from lambdapdk.interposer.libs import bumps as interposer_bumps
 
     all_libs = []
     for lib_mod in [
@@ -50,7 +51,8 @@ def get_libs():
             nangate45, fakeram45,
             sky130sc, sky130io, sky130sram,
             gf180mcu, gf180io, gf180sram,
-            sg13g2_stdcell, sg13g2_sram]:
+            sg13g2_stdcell, sg13g2_sram,
+            interposer_bumps]:
         libs = lib_mod.setup()
         if not isinstance(libs, (list, tuple)):
             libs = [libs]

{lambdapdk-0.1.37 → lambdapdk-0.1.38}/lambdapdk/ihp130/libs/sg13g2_sram.py

@@ -15,7 +15,7 @@ def setup():
         path_base = 'ihp-sg13g2/libs.ref/sg13g2_sram'
         lib.add('output', stackup, 'lef', f'{path_base}/lef/{mem_name}.lef')
         lib.add('output', stackup, 'gds', f'{path_base}/gds/{mem_name}.gds')
-        lib.add('output', stackup, 'cdl', f'{path_base}/spice/{mem_name}.cdl')
+        lib.add('output', stackup, 'cdl', f'{path_base}/cdl/{mem_name}.cdl')
 
         lib.add('output', 'typ', 'nldm', f'{path_base}/lib/{mem_name}_typ_1p20V_25C.lib')
         lib.add('output', 'slow', 'nldm', f'{path_base}/lib/{mem_name}_slow_1p08V_125C.lib')

lambdapdk-0.1.38/lambdapdk/interposer/__init__.py

@@ -0,0 +1,111 @@
+import os
+import siliconcompiler
+from lambdapdk import register_data_source
+
+
+stackups = []
+for m in ("3ML", "4ML", "5ML"):
+    for w in ("0400", "0800", "2000", "0400_2000"):
+        stackups.append(f'{m}_{w}')
+
+
+####################################################
+# PDK Setup
+####################################################
+def setup():
+    '''
+    The interposer PDK is a passive technology with a number of
+    simulated stackups. The PDK contains enablement for place and
+    route tools and design rule signoff.
+    Note that this process design kit is provided as an academic
+    and research aid only and the resulting designs are not manufacturable.
+    '''
+
+    foundry = 'virtual'
+    process = 'interposer'
+
+    libtype = 'none'
+
+    node = 130
+    # TODO: dummy numbers, only matter for cost estimation
+    wafersize = 300
+    hscribe = 0.1
+    vscribe = 0.1
+    edgemargin = 2
+
+    pdkdir = os.path.join('lambdapdk', 'interposer', 'base')
+
+    pdk = siliconcompiler.PDK(process, package='lambdapdk')
+    register_data_source(pdk)
+
+    # process name
+    pdk.set('pdk', process, 'foundry', foundry)
+    pdk.set('pdk', process, 'node', node)
+    pdk.set('pdk', process, 'version', 'v0.0.1')
+    pdk.set('pdk', process, 'stackup', stackups)
+    pdk.set('pdk', process, 'wafersize', wafersize)
+    pdk.set('pdk', process, 'edgemargin', edgemargin)
+    pdk.set('pdk', process, 'scribe', (hscribe, vscribe))
+
+    # APR Setup
+    for stackup in stackups:
+        for tool in ('openroad', 'klayout', 'magic'):
+            pdk.set('pdk', process, 'aprtech', tool, stackup, libtype, 'lef',
+                    pdkdir + f'/apr/{stackup}.lef')
+
+        pdk.set('pdk', process, 'minlayer', stackup, 'metal1')
+        pdk.set('pdk', process, 'maxlayer', stackup, 'topmetal')
+
+        # DRC Runsets
+        pdk.set('pdk', process, 'drc', 'runset', 'klayout', stackup, 'drc',
+                pdkdir + f'/setup/klayout/{stackup}.drc')
+
+        key = 'drc_params:drc'
+        pdk.add('pdk', process, 'var', 'klayout', stackup, key, 'input=<input>')
+        pdk.add('pdk', process, 'var', 'klayout', stackup, key, 'topcell=<topcell>')
+        pdk.add('pdk', process, 'var', 'klayout', stackup, key, 'report=<report>')
+        pdk.add('pdk', process, 'var', 'klayout', stackup, key, 'threads=<threads>')
+
+        # Layer map and display file
+        pdk.set('pdk', process, 'layermap', 'klayout', 'def', 'gds', stackup,
+                pdkdir + f'/apr/{stackup}.layermap')
+        pdk.set('pdk', process, 'display', 'klayout', stackup,
+                pdkdir + f'/setup/klayout/{stackup}.lyp')
+
+        pdk.set('pdk', process, 'aprtech', 'openroad', stackup, libtype, 'fill',
+                pdkdir + f'/dfm/openroad/{stackup}.fill.json')
+
+        # Openroad global routing grid derating
+        openroad_layer_adjustments = {
+            'metal1': 0.20,
+            'metal2': 0.20,
+            'metal3': 0.20,
+            'metal4': 0.20,
+            'metal5': 0.20,
+            'metal6': 0.20,
+            'topmetal': 0.20
+        }
+        for layer, adj in openroad_layer_adjustments.items():
+            if layer != 'topmetal' and int(layer[-1]) >= int(stackup[0]):
+                continue
+            pdk.set('pdk', process, 'var', 'openroad', f'{layer}_adjustment', stackup, adj)
+
+        pdk.set('pdk', process, 'var', 'openroad', 'rclayer_signal', stackup, 'metal2')
+        pdk.set('pdk', process, 'var', 'openroad', 'rclayer_clock', stackup, 'metal2')
+
+        pdk.set('pdk', process, 'var', 'openroad', 'pin_layer_vertical', stackup, 'metal2')
+        pdk.set('pdk', process, 'var', 'openroad', 'pin_layer_horizontal', stackup, 'metal3')
+
+        # PEX
+        for corner in ["minimum", "typical", "maximum"]:
+            pdk.set('pdk', process, 'pexmodel', 'openroad', stackup, corner,
+                    pdkdir + '/pex/openroad/' + stackup + '.' + corner + '.tcl')
+
+    return pdk
+
+
+#########################
+if __name__ == "__main__":
+    pdk = setup()
+    pdk.write_manifest(f'{pdk.top()}.json')
+    pdk.check_filepaths()

lambdapdk-0.1.38/lambdapdk/interposer/_generator.py

@@ -0,0 +1,533 @@
+import json
+import os
+
+from jinja2 import Environment, FileSystemLoader
+import xml.etree.ElementTree as ET
+import xml.dom.minidom
+
+template_dir = os.path.join(os.path.dirname(__file__), 'base', 'templates')
+jinja2_env = Environment(loader=FileSystemLoader(template_dir))
+
+
+LICENSE = '''Copyright 2024 ZeroASIC Corp
+
+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
+
+     https://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.
+'''
+
+
+def __get_gds_type_name(gds_type):
+    if gds_type == 0:
+        return ""
+    if gds_type == 10:
+        return "pin"
+    if gds_type == 20:
+        return "text"
+    if gds_type == 30:
+        return "fill"
+
+    raise ValueError(str(gds_type))
+
+
+def make_metal_layer(
+        name,
+        gds_mapping,
+        direction,
+        min_width,
+        min_spacing,
+        resistance_per_um,
+        capacitance_per_um,
+        max_width=None):
+
+    layer = {
+        "name": name,
+        "type": "ROUTING",
+        "direction": direction,
+        "gds": gds_mapping,
+        "width": {
+            "min": min_width
+        },
+        "spacing": {
+            "min": min_spacing
+        },
+        "parasitic": {
+            "resistance": resistance_per_um,
+            "capacitance": capacitance_per_um
+        }
+    }
+
+    if max_width:
+        layer["width"]["max"] = max_width
+
+    return layer
+
+
+def make_cut_layer(
+        name,
+        gds_mapping,
+        width,
+        min_spacing,
+        enclosure_bot,
+        enclosure_top,
+        resistance_per_cut):
+
+    layer = {
+        "name": name,
+        "type": "CUT",
+        "gds": gds_mapping,
+        "width": {
+            "min": width
+        },
+        "spacing": {
+            "min": min_spacing
+        },
+        "enclosure": {
+            "bottom": enclosure_bot,
+            "top": enclosure_top
+        },
+        "parasitic": {
+            "resistance": resistance_per_cut
+        }
+    }
+
+    return layer
+
+
+def build_tech(layer_count, name=None, width=None):
+    if not isinstance(width, (tuple, list)):
+        width = layer_count * [width]
+
+    layers = []
+    gds_layer = 1
+    for n in range(layer_count):
+        layeridx = n + 1
+
+        metal_name = f"metal{layeridx}"
+        max_width = 5.0
+        if layeridx == layer_count:
+            metal_name = "topmetal"
+            gds_layer = 100
+            max_width = None
+
+        layers.append(
+            make_metal_layer(
+                metal_name,
+                {
+                    "number": gds_layer,
+                    "types": {
+                        "NET": 0,
+                        "SPNET": 0,
+                        "PIN": 10,
+                        "LEFPIN": 10,
+                        "FILL": 30
+                    },
+                    "name": {
+                        "PIN": 20,
+                        "SPNET": 20,
+                        "TEXT": 20
+                    }
+                },
+                "HORIZONTAL" if layeridx % 2 == 1 else "VERTICAL",
+                min_width=width[n],
+                min_spacing=width[n],
+                resistance_per_um=1.5000e-03,
+                capacitance_per_um=1.0000E-01,
+                max_width=max_width
+            ))
+
+        if layeridx != layer_count:
+            layers.append(
+                make_cut_layer(
+                    f"via{layeridx}",
+                    {
+                        "number": gds_layer + 1,
+                        "types": {
+                            "NET": 0,
+                            "SPNET": 0,
+                            "PIN": 10,
+                            "LEFPIN": 10,
+                            "FILL": 30
+                        },
+                        "name": {
+                            "PIN": 20,
+                            "SPNET": 20,
+                            "TEXT": 20
+                        }
+                    },
+                    width[n] / 2,
+                    width[n] / 2,
+                    width[n] / 2,
+                    width[n] / 2,
+                    resistance_per_cut=10e-3
+                ))
+        gds_layer += 2
+
+    if not name:
+        name = f"{layer_count}ML"
+
+    tech = {
+        "name": name,
+        "grid": 0.005,
+        "layers": layers,
+        "outline": (0, 0)
+    }
+
+    return tech
+
+
+def build_layermap(tech, path):
+    layermap = []
+    for layer in tech["layers"]:
+        name = layer["name"]
+        gds_number = layer["gds"]["number"]
+
+        for map_type, gds_type in layer["gds"]["types"].items():
+            layermap.append((
+                name,
+                map_type,
+                str(gds_number),
+                str(gds_type)
+            ))
+
+        for map_type, gds_type in layer["gds"]["name"].items():
+            layermap.append((
+                "NAME",
+                f"{name}/{map_type}",
+                str(gds_number),
+                str(gds_type)
+            ))
+
+    layermap.append((
+        "DIEAREA",
+        "ALL",
+        str(tech["outline"][0]),
+        str(tech["outline"][1])
+    ))
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.layermap', 'w') as f:
+        f.write(
+            jinja2_env.get_template('layermap.j2').render(
+                license=LICENSE,
+                layers=layermap
+            )
+        )
+        f.write('\n')
+
+
+def build_openroad_pex(tech, path):
+    corners = {
+        "maximum": 0.3,
+        "typical": 0.0,
+        "minimum": -0.3
+    }
+
+    for corner, adjustment in corners.items():
+        metals = []
+        vias = []
+        for layer in tech["layers"]:
+            name = layer["name"]
+
+            if layer["type"] == "ROUTING":
+                metals.append((
+                    name,
+                    layer["parasitic"]["resistance"]*(1+adjustment),
+                    layer["parasitic"]["capacitance"]*(1+adjustment)
+                ))
+            else:
+                vias.append((
+                    name,
+                    layer["parasitic"]["resistance"]*(1+adjustment)
+                ))
+
+        os.makedirs(path, exist_ok=True)
+        with open(f'{path}/{tech["name"]}.{corner}.tcl', 'w') as f:
+            f.write(
+                jinja2_env.get_template('pex.tcl.j2').render(
+                    license=LICENSE,
+                    metals=metals,
+                    vias=vias
+                )
+            )
+            f.write('\n')
+
+
+def build_klayout_drc(tech, path):
+    layers = []
+
+    for n, layer in enumerate(tech["layers"]):
+        layer_nm = {
+            "name": layer["name"],
+            "type": layer["type"],
+            "width": {
+                "min": int(layer["width"]["min"] * 1000)
+            },
+            "spacing": {
+                "min": int(layer["spacing"]["min"] * 1000)
+            }
+        }
+
+        if "max" in layer["width"]:
+            layer_nm["width"]["max"] = int(layer["width"]["max"] * 1000)
+
+        if layer["type"] == "CUT":
+            layer_nm["enclosure"] = {
+                "bottom": (
+                    tech["layers"][n - 1]["name"],
+                    int(layer["enclosure"]["bottom"] * 1000)
+                ),
+                "top": (
+                    tech["layers"][n + 1]["name"],
+                    int(layer["enclosure"]["top"] * 1000)
+                )
+            }
+
+        gds_types = sorted(set(layer["gds"]["types"].values()))
+        layer_nm["gds"] = [
+            (layer["gds"]["number"], gds_type) for gds_type in gds_types
+        ]
+
+        layers.append(layer_nm)
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.drc', 'w') as f:
+        f.write(
+            jinja2_env.get_template('drc.j2').render(
+                license=LICENSE,
+                grid=int(tech["grid"] * 1000),
+                layers=layers,
+                outline={"number": tech["outline"][0], "type": tech["outline"][1]}
+            )
+        )
+        f.write('\n')
+
+
+def build_klayout_layer_properties(tech, path):
+    colors = [
+        "#ffc280",
+        "#ff9d9d",
+        "#ff80a8",
+        "#c080ff",
+        "#9580ff",
+        "#8086ff",
+        "#80a8ff",
+        "#ff0000",
+        "#ff0080",
+        "#ff00ff",
+        "#8000ff",
+        "#91ff00",
+        "#008000",
+        "#508000",
+        "#808000",
+        "#805000"
+    ]
+    patterns = [
+        "I5",
+        "I9"
+    ]
+
+    layeridx = 0
+
+    def make_layer(name, gds):
+        prop = ET.Element("properties")
+
+        color = colors[layeridx % len(colors)]
+        pattern = patterns[layeridx % len(patterns)]
+
+        for tag, value in [
+                ("frame-color", color),
+                ("frame-brightness", "0"),
+                ("fill-color", color),
+                ("fill-brightness", "0"),
+                ("dither-pattern", pattern),
+                ("line-style", None),
+                ("value", "true"),
+                ("visible", "true"),
+                ("transparent", "false"),
+                ("width", "1"),
+                ("marked", "false"),
+                ("xfill", "false"),
+                ("animation", "0"),
+                ("name", name),
+                ("source", f"{name} {gds[0]}/{gds[1]}@1")
+                ]:
+            el = ET.Element(tag)
+
+            if value is not None:
+                el.text = value
+            prop.append(el)
+
+        return prop
+
+    props = ET.Element("layer-properties")
+    props.append(make_layer("outline", (tech["outline"][0], tech["outline"][1])))
+    layeridx += 1
+    for layer in tech["layers"]:
+        gds_types = sorted(set([*layer["gds"]["types"].values(), *layer["gds"]["name"].values()]))
+        for gds_type in gds_types:
+            name = layer["name"]
+            gds_name = __get_gds_type_name(gds_type)
+            if gds_type:
+                name += "." + gds_name
+            props.append(make_layer(name, (layer["gds"]["number"], gds_type)))
+
+            layeridx += 1
+
+    props.insert(0, ET.Comment(f"\n{LICENSE}"))
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.lyp', 'w') as f:
+        f.write(
+            xml.dom.minidom.parseString(
+                ET.tostring(props)).toprettyxml(indent="  "))
+
+
+def build_lef(tech, path):
+    vias = []
+    for n, layer in enumerate(tech["layers"]):
+        if layer["type"] == "ROUTING":
+            continue
+        bottom_layer = tech["layers"][n - 1]
+        top_layer = tech["layers"][n + 1]
+
+        name = layer["name"].upper() + "_1"
+
+        cut_egde = layer["width"]["min"]
+        cut = (-cut_egde / 2, -cut_egde / 2, cut_egde / 2, cut_egde / 2)
+        bot = (cut[0] - layer["enclosure"]['bottom'], cut[1] - layer["enclosure"]['bottom'],
+               cut[2] + layer["enclosure"]['bottom'], cut[3] + layer["enclosure"]['bottom'])
+        top = (cut[0] - layer["enclosure"]['top'], cut[1] - layer["enclosure"]['top'],
+               cut[2] + layer["enclosure"]['top'], cut[3] + layer["enclosure"]['top'])
+
+        vias.append({
+            "name": name,
+            "layers": [
+                (layer["name"], [f"{v:.3f}" for v in cut]),
+                (bottom_layer["name"], [f"{v:.3f}" for v in bot]),
+                (top_layer["name"], [f"{v:.3f}" for v in top])
+            ]})
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.lef', 'w') as f:
+        f.write(
+            jinja2_env.get_template('lef.j2').render(
+                license=LICENSE,
+                grid=tech["grid"],
+                layers=tech["layers"],
+                vias=vias
+            )
+        )
+
+
+def build_openroad_fill(tech, path):
+    fill = {"layers": {}}
+
+    for layer in tech["layers"]:
+        if layer["type"] == "CUT":
+            continue
+
+        max_spacing = 5 * layer["spacing"]["min"]
+
+        max_width = 10 * layer["width"]["min"]
+        if "max" in layer["width"]:
+            max_width = layer["width"]["max"]
+
+        shapes = []
+        for ratio in (1.0, 0.75, 0.5, 0.25, 0.0):
+            width = layer["width"]["min"] + ratio * (max_width - layer["width"]["min"])
+            width = tech["grid"] * round(width / tech["grid"])
+
+            shapes.append(width)
+
+        fill["layers"][layer["name"]] = {
+            "name": layer["name"],
+            "layer": layer["gds"]["number"],
+            "datatype": layer["gds"]["types"]["NET"],
+            "space_to_outline": max_spacing,
+            "non-opc": {
+                "datatype": layer["gds"]["types"]["FILL"],
+                "width": shapes,
+                "height": shapes,
+                "space_to_fill": layer["spacing"]["min"],
+                "space_to_non_fill": max_spacing
+            }
+        }
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.fill.json', 'w') as f:
+        json.dump(fill, f, indent=2)
+
+
+def build_readme(stackups):
+    from lambdapdk import interposer
+
+    for stackup in stackups:
+        metals = []
+        for layer in stackup["tech"]["layers"]:
+            if layer["type"] == "ROUTING":
+                metals.append((
+                    layer["name"],
+                    f'{int(layer["width"]["min"] * 1000)}nm',
+                    f'{int(layer["spacing"]["min"] * 1000)}nm'
+                ))
+        stackup["metalstack"] = reversed(metals)
+
+    with open('README.md', 'w') as f:
+        f.write(
+            jinja2_env.get_template('README.md.j2').render(
+                desc=interposer.setup.__doc__,
+                license=LICENSE,
+                stackups=stackups
+            )
+        )
+
+
+if __name__ == "__main__":
+    def tapered_metal(layer_count):
+        mid = int(layer_count // 2)
+        widths = mid * [0.4]
+        if layer_count % 2 != 0:
+            widths += [0.8]
+        widths += mid * [2.0]
+        return widths
+
+    tech_specs = {
+        "0400": 0.4,
+        "0800": 0.8,
+        "2000": 2.0,
+        "0400_2000": tapered_metal
+    }
+
+    stackups = []
+
+    for name, width in tech_specs.items():
+        for layer_count in range(3, 6):
+            tech_name = f"{layer_count}ML_{name}"
+
+            widths = width
+            if not isinstance(widths, (int, float, list, tuple)):
+                widths = widths(layer_count)
+
+            tech = build_tech(layer_count, name=tech_name, width=widths)
+            stackups.append({
+                "name": tech_name,
+                "tech": tech
+            })
+
+            build_lef(tech, 'base/apr')
+            build_layermap(tech, 'base/apr')
+            build_klayout_layer_properties(tech, 'base/setup/klayout')
+            build_klayout_drc(tech, 'base/setup/klayout')
+            build_openroad_pex(tech, 'base/pex/openroad')
+            build_openroad_fill(tech, 'base/dfm/openroad')
+
+    build_readme(stackups)

lambdapdk-0.1.38/lambdapdk/interposer/libs/bumps.py

@@ -0,0 +1,31 @@
+import os
+import siliconcompiler
+from lambdapdk import register_data_source
+from lambdapdk.interposer import stackups
+
+
+def setup():
+    '''
+    Interposer bump library
+    '''
+    libdir = "lambdapdk/interposer/libs/bumps/"
+
+    lib = siliconcompiler.Library('interposer_bumps', package='lambdapdk')
+    register_data_source(lib)
+
+    # pdk
+    lib.set('option', 'pdk', 'interposer')
+
+    for stackup in stackups:
+        lib.set('output', stackup, 'lef',
+                os.path.join(libdir, 'lef/bumps.lef'))
+        lib.add('output', stackup, 'gds',
+                os.path.join(libdir, 'gds/bumps.gds'))
+
+    return lib
+
+
+#########################
+if __name__ == "__main__":
+    lib = setup(siliconcompiler.Chip('<lib>'))
+    lib.write_manifest(f'{lib.top()}.json')

{lambdapdk-0.1.37 → lambdapdk-0.1.38/lambdapdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lambdapdk
-Version: 0.1.37
+Version: 0.1.38
 Summary: Library of open source Process Design Kits
 Author: Zero ASIC
 License:                                  Apache License
@@ -206,6 +206,7 @@ Requires-Dist: pytest-timeout==2.3.1; extra == "test"
 Requires-Dist: tclint==0.4.2; extra == "test"
 Requires-Dist: lambdalib==0.3.0; extra == "test"
 Requires-Dist: sc-leflib==0.4.0; extra == "test"
+Requires-Dist: Jinja2==3.1.4; extra == "test"
 
 # Lambdapdk Introduction
 
@@ -221,6 +222,7 @@ Supported PDKs:
 * [Skywater130](lambdapdk/sky130/base/README.md)
 * [Global Foundries 180](lambdapdk/gf180/README.md)
 * [IHP 180](https://github.com/IHP-GmbH/IHP-Open-PDK)
+* [interposer](lambdapdk/interposer/README.md)
 
 # License
 

{lambdapdk-0.1.37 → lambdapdk-0.1.38}/lambdapdk.egg-info/SOURCES.txt

@@ -22,6 +22,9 @@ lambdapdk/gf180/libs/gf180sram.py
 lambdapdk/ihp130/__init__.py
 lambdapdk/ihp130/libs/sg13g2_sram.py
 lambdapdk/ihp130/libs/sg13g2_stdcell.py
+lambdapdk/interposer/__init__.py
+lambdapdk/interposer/_generator.py
+lambdapdk/interposer/libs/bumps.py
 lambdapdk/sky130/__init__.py
 lambdapdk/sky130/libs/sky130io.py
 lambdapdk/sky130/libs/sky130sc.py

{lambdapdk-0.1.37 → lambdapdk-0.1.38}/lambdapdk.egg-info/requires.txt

@@ -7,3 +7,4 @@ pytest-timeout==2.3.1
 tclint==0.4.2
 lambdalib==0.3.0
 sc-leflib==0.4.0
+Jinja2==3.1.4

{lambdapdk-0.1.37 → lambdapdk-0.1.38}/pyproject.toml

@@ -32,7 +32,8 @@ test = [
     "pytest-timeout == 2.3.1",
     "tclint == 0.4.2",
     "lambdalib == 0.3.0",
-    "sc-leflib == 0.4.0"
+    "sc-leflib == 0.4.0",
+    "Jinja2 == 3.1.4"
 ]
 
 [tool.tclint]

{lambdapdk-0.1.37 → lambdapdk-0.1.38}/tests/test_getters.py

@@ -2,15 +2,16 @@ import pytest
 from siliconcompiler import Chip
 import lambdapdk
 
-from lambdapdk import asap7, freepdk45, sky130, gf180, ihp130
+from lambdapdk import asap7, freepdk45, sky130, gf180, ihp130, interposer
 from lambdapdk.asap7.libs import asap7sc7p5t, fakeram7, fakeio7
 from lambdapdk.freepdk45.libs import nangate45, fakeram45
 from lambdapdk.sky130.libs import sky130sc, sky130io, sky130sram
 from lambdapdk.gf180.libs import gf180mcu, gf180io, gf180sram
 from lambdapdk.ihp130.libs import sg13g2_stdcell, sg13g2_sram
+from lambdapdk.interposer.libs import bumps as interposer_bumps
 
 
-@pytest.mark.parametrize('pdk', [asap7, freepdk45, sky130, gf180, ihp130])
+@pytest.mark.parametrize('pdk', [asap7, freepdk45, sky130, gf180, ihp130, interposer])
 def test_pdk(pdk):
     chip = Chip('<pdk>')
     chip.use(pdk)
@@ -24,7 +25,8 @@ def test_pdk(pdk):
     nangate45, fakeram45,  # freepdk45
     sky130sc, sky130io, sky130sram,  # sky130
     gf180mcu, gf180io, gf180sram,  # gf180
-    sg13g2_stdcell, sg13g2_sram  # ihp130
+    sg13g2_stdcell, sg13g2_sram,  # ihp130
+    interposer_bumps  # interposer
     ])
 def test_lib(lib):
     chip = Chip('<lib>')

{lambdapdk-0.1.37 → lambdapdk-0.1.38}/tests/test_paths.py

@@ -2,16 +2,18 @@ import pytest
 from siliconcompiler import Chip
 import os
 
-from lambdapdk import asap7, freepdk45, sky130, gf180, ihp130
+from lambdapdk import asap7, freepdk45, sky130, gf180, ihp130, interposer
 from lambdapdk.asap7.libs import asap7sc7p5t, fakeram7, fakeio7
 from lambdapdk.freepdk45.libs import nangate45, fakeram45
 from lambdapdk.sky130.libs import sky130sc, sky130io, sky130sram
 from lambdapdk.gf180.libs import gf180mcu, gf180io, gf180sram
-from lambdapdk.ihp130.libs import sg13g2_stdcell
+from lambdapdk.ihp130.libs import sg13g2_stdcell, sg13g2_sram
+from lambdapdk.interposer.libs import bumps as interposer_bumps
 
 
 @pytest.mark.parametrize('pdk', [
-    asap7, freepdk45, sky130, gf180, ihp130])
+    asap7, freepdk45, sky130, gf180, ihp130,
+    interposer])
 def test_pdk_paths(pdk):
     chip = Chip('<pdk>')
     chip.use(pdk)
@@ -23,7 +25,8 @@ def test_pdk_paths(pdk):
     nangate45, fakeram45,  # freepdk45
     sky130sc, sky130io, sky130sram,  # sky130
     gf180mcu, gf180io, gf180sram,  # gf180
-    sg13g2_stdcell  # ihp130
+    sg13g2_stdcell, sg13g2_sram,  # ihp130
+    interposer_bumps
     ])
 def test_lib_paths(lib):
     chip = Chip('<lib>')