mirror of
https://github.com/TinyTapeout/tt-support-tools.git
synced 2026-11-03 04:36:09 +01:00
427 lines
17 KiB
Python
427 lines
17 KiB
Python
import logging
|
|
import re
|
|
from collections.abc import Iterable
|
|
from functools import partial
|
|
from itertools import combinations
|
|
from numbers import Real
|
|
|
|
import gdstk
|
|
from precheck_failure import PrecheckFailure
|
|
from tech_data import power_pins_layer, valid_lef_port_layers
|
|
|
|
|
|
def canonicalize_rectangles(
|
|
rects: Iterable[Iterable[Real]],
|
|
) -> Iterable[Iterable[Real]]:
|
|
# lists all maximal rectangles covered by the union of input rectangles
|
|
|
|
sweep_events = {}
|
|
for lx, by, rx, ty in rects:
|
|
sweep_events[by] = sweep_events.get(by, {})
|
|
sweep_events[by][lx] = sweep_events[by].get(lx, 0) + 1
|
|
sweep_events[by][rx] = sweep_events[by].get(rx, 0) - 1
|
|
sweep_events[ty] = sweep_events.get(ty, {})
|
|
sweep_events[ty][lx] = sweep_events[ty].get(lx, 0) - 1
|
|
sweep_events[ty][rx] = sweep_events[ty].get(rx, 0) + 1
|
|
|
|
closed_rects = []
|
|
open_rects = {}
|
|
cross_section_events = {}
|
|
for y, sweep_line_events in sorted(sweep_events.items()):
|
|
old_multiplicity = 0
|
|
new_multiplicity = 0
|
|
is_covered, covered_intervals, covered_start = False, [], None
|
|
is_removed, removed_intervals, removed_start = False, [], None
|
|
for x in sorted(set(cross_section_events).union(sweep_line_events)):
|
|
old_delta = cross_section_events.get(x, 0)
|
|
new_delta = sweep_line_events.get(x, 0) + old_delta
|
|
old_multiplicity += old_delta
|
|
new_multiplicity += new_delta
|
|
assert old_multiplicity >= 0
|
|
assert new_multiplicity >= 0
|
|
was_covered, was_removed = is_covered, is_removed
|
|
is_covered = new_multiplicity > 0
|
|
is_removed = old_multiplicity > 0 and new_multiplicity == 0
|
|
if was_covered and not is_covered:
|
|
assert covered_start is not None
|
|
covered_intervals.append((covered_start, x))
|
|
covered_start = None
|
|
if was_removed and not is_removed:
|
|
assert removed_start is not None
|
|
removed_intervals.append((removed_start, x))
|
|
removed_start = None
|
|
if is_covered and not was_covered:
|
|
assert covered_start is None
|
|
covered_start = x
|
|
if is_removed and not was_removed:
|
|
assert removed_start is None
|
|
removed_start = x
|
|
|
|
for x, m in sorted(sweep_line_events.items()):
|
|
cross_section_events[x] = cross_section_events.get(x, 0) + m
|
|
if cross_section_events[x] == 0:
|
|
del cross_section_events[x]
|
|
|
|
for (lx, rx), by in open_rects.items():
|
|
closed = False
|
|
for ix, jx in removed_intervals:
|
|
if ix < rx and lx < jx:
|
|
closed = True
|
|
if closed:
|
|
closed_rects.append((lx, by, rx, y))
|
|
|
|
kept_intervals = [
|
|
(b, c)
|
|
for ((a, b), (c, d)) in zip(
|
|
[(None, None)] + removed_intervals, removed_intervals + [(None, None)]
|
|
)
|
|
]
|
|
open_rects_new = {}
|
|
for ix, jx in covered_intervals:
|
|
open_rects_new[(ix, jx)] = y
|
|
for (lx, rx), by in open_rects.items():
|
|
for ix, jx in kept_intervals:
|
|
if (ix is None or ix < rx) and (jx is None or lx < jx):
|
|
clx = lx if ix is None else max(lx, ix)
|
|
crx = rx if jx is None else min(rx, jx)
|
|
open_rects_new[(clx, crx)] = min(
|
|
open_rects_new.get((clx, crx), by), by
|
|
)
|
|
open_rects = open_rects_new
|
|
|
|
return sorted(set(closed_rects))
|
|
|
|
|
|
def parse_fp3(value: str):
|
|
# parse fixed-point numbers with 3 digits after the decimal point
|
|
# e.g. '20.470' to 20470
|
|
ip, fp = value.split(".")
|
|
mul = ip + fp[:3].rjust(3, "0")
|
|
return int(mul)
|
|
|
|
|
|
def parse_dbu_to_nm(value: str, dbu_per_micron: int):
|
|
# parse a value in database units into nanometers
|
|
assert dbu_per_micron != 0
|
|
val_dbu = int(value)
|
|
assert (val_dbu * 1000) % dbu_per_micron == 0
|
|
return (val_dbu * 1000) // dbu_per_micron
|
|
|
|
|
|
def pin_check(
|
|
gds: str, lef: str, template_def: str, toplevel: str, uses_3v3: bool, tech: str
|
|
):
|
|
logging.info("Running pin check...")
|
|
logging.info(f"* gds: {gds}")
|
|
logging.info(f"* lef: {lef}")
|
|
logging.info(f"* template_def: {template_def}")
|
|
logging.info(f"* toplevel: {toplevel}")
|
|
logging.info(f"* uses_3v3: {uses_3v3}")
|
|
|
|
# parse pins from template def
|
|
# def syntax: https://coriolis.lip6.fr/doc/lefdef/lefdefref/DEFSyntax.html
|
|
|
|
units_re = re.compile(r"UNITS DISTANCE MICRONS (\S+) ;")
|
|
diearea_re = re.compile(r"DIEAREA \( (\S+) (\S+) \) \( (\S+) (\S+) \) ;")
|
|
pins_re = re.compile(r"PINS (\d+) ;")
|
|
pin_re = re.compile(r" *- (\S+) \+ NET (\S+) \+ DIRECTION (\S+) \+ USE (\S+)")
|
|
layer_re = re.compile(r" *\+ LAYER (\S+) \( (\S+) (\S+) \) \( (\S+) (\S+) \)")
|
|
placed_re = re.compile(r" *\+ PLACED \( (\S+) (\S+) \) (\S+) ;")
|
|
|
|
def_pins = {}
|
|
dbu_per_micron = 0
|
|
die_width = 0
|
|
die_height = 0
|
|
|
|
with open(template_def) as f:
|
|
for line in f:
|
|
if line.startswith("UNITS "):
|
|
match = units_re.match(line)
|
|
(dbu_per_micron,) = map(int, match.groups())
|
|
parse_nm = partial(parse_dbu_to_nm, dbu_per_micron=dbu_per_micron)
|
|
elif line.startswith("DIEAREA "):
|
|
match = diearea_re.match(line)
|
|
lx, by, rx, ty = map(parse_nm, match.groups())
|
|
if (lx, by) != (0, 0):
|
|
raise PrecheckFailure(
|
|
"Wrong die origin in template DEF, expecting (0, 0)"
|
|
)
|
|
die_width = rx
|
|
die_height = ty
|
|
elif line.startswith("PINS "):
|
|
match = pins_re.match(line)
|
|
pin_count = int(match.group(1))
|
|
break
|
|
|
|
for i in range(pin_count):
|
|
line = next(f)
|
|
match = pin_re.match(line)
|
|
pin_name, net_name, direction, use = match.groups()
|
|
if pin_name != net_name:
|
|
raise PrecheckFailure(
|
|
f"Inconsistent pin name and net name in template DEF: {pin_name} vs {net_name}"
|
|
)
|
|
|
|
line = next(f)
|
|
if not line.strip().startswith("+ PORT"):
|
|
raise PrecheckFailure(
|
|
"Unexpected token in template DEF: PINS not followed by PORT"
|
|
)
|
|
|
|
line = next(f)
|
|
match = layer_re.match(line)
|
|
layer, lx, by, rx, ty = match.groups()
|
|
lx, by, rx, ty = map(parse_nm, (lx, by, rx, ty))
|
|
|
|
line = next(f)
|
|
match = placed_re.match(line)
|
|
ox, oy, direction = match.groups()
|
|
ox, oy = map(parse_nm, (ox, oy))
|
|
|
|
if pin_name in def_pins:
|
|
raise PrecheckFailure("Duplicate pin in template DEF")
|
|
|
|
def_pins[pin_name] = (layer, ox + lx, oy + by, ox + rx, oy + ty)
|
|
|
|
line = next(f)
|
|
if not line.startswith("END PINS"):
|
|
raise PrecheckFailure(
|
|
f"Unexpected token in template DEF: PINS {pin_count} section does not end after {pin_count} pins"
|
|
)
|
|
|
|
# parse pins from user lef
|
|
# lef syntax: https://coriolis.lip6.fr/doc/lefdef/lefdefref/LEFSyntax.html
|
|
|
|
origin_re = re.compile(r"ORIGIN (\S+) (\S+) ;")
|
|
size_re = re.compile(r"SIZE (\S+) BY (\S+) ;")
|
|
layer_re = re.compile(r"LAYER (\S+) ;")
|
|
rect_re = re.compile(r"RECT (\S+) (\S+) (\S+) (\S+) ;")
|
|
|
|
power_pins = ["VGND", "VDPWR"]
|
|
if uses_3v3:
|
|
power_pins.append("VAPWR")
|
|
compat_pins = {"VPWR": "VDPWR"}
|
|
|
|
macro_active = False
|
|
pins_expected = set(def_pins).union(power_pins).union(compat_pins)
|
|
pins_seen = set()
|
|
current_pin = None
|
|
pin_rects = 0
|
|
lef_errors = 0
|
|
lef_ports = {}
|
|
|
|
with open(lef) as f:
|
|
for line in f:
|
|
line = line.strip()
|
|
if line.startswith("MACRO "):
|
|
if line == "MACRO " + toplevel:
|
|
macro_active = True
|
|
else:
|
|
macro_active = False
|
|
elif macro_active:
|
|
if line.startswith("ORIGIN "):
|
|
match = origin_re.match(line)
|
|
lx, by = map(parse_fp3, match.groups())
|
|
if lx != 0 or by != 0:
|
|
raise PrecheckFailure(
|
|
"Wrong die origin in LEF, expecting (0, 0)"
|
|
)
|
|
elif line.startswith("SIZE "):
|
|
match = size_re.match(line)
|
|
rx, ty = map(parse_fp3, match.groups())
|
|
if (rx, ty) != (die_width, die_height):
|
|
raise PrecheckFailure(
|
|
f"Inconsistent die area between LEF and template DEF: ({rx}, {ty}) != ({die_width}, {die_height})"
|
|
)
|
|
elif line.startswith("PIN "):
|
|
if current_pin is not None:
|
|
new_pin = line.removeprefix("PIN ")
|
|
raise PrecheckFailure(
|
|
f"Unexpected token in LEF: pin {new_pin} starts without ending previous pin {current_pin}"
|
|
)
|
|
current_pin = line.removeprefix("PIN ")
|
|
pins_seen.add(current_pin)
|
|
if current_pin not in pins_expected:
|
|
logging.error(f"Unexpected pin {current_pin} in {lef}")
|
|
lef_errors += 1
|
|
pin_rects = 0
|
|
elif line == "PORT":
|
|
if current_pin is None:
|
|
raise PrecheckFailure(
|
|
"Unexpected token in LEF: PORT outside of PIN"
|
|
)
|
|
line = next(f).strip()
|
|
while line.startswith("LAYER "):
|
|
match = layer_re.match(line)
|
|
layer = match.group(1)
|
|
line = next(f).strip()
|
|
while line.startswith("RECT "):
|
|
match = rect_re.match(line)
|
|
lx, by, rx, ty = map(parse_fp3, match.groups())
|
|
pin_rects += 1
|
|
if current_pin not in lef_ports:
|
|
lef_ports[current_pin] = []
|
|
lef_ports[current_pin].append((layer, lx, by, rx, ty))
|
|
line = next(f).strip()
|
|
if line != "END":
|
|
raise PrecheckFailure(
|
|
"Unexpected token in LEF: LAYER within PORT should be followed by RECT or LAYER lines until END of port"
|
|
)
|
|
elif current_pin is not None and line.startswith("END " + current_pin):
|
|
if pin_rects < 1:
|
|
logging.error(f"No ports for pin {current_pin} in {lef}")
|
|
lef_errors += 1
|
|
current_pin = None
|
|
|
|
lef_ports_orig = lef_ports
|
|
lef_ports = {}
|
|
for current_pin, ports_orig in lef_ports_orig.items():
|
|
ports_by_layers = {}
|
|
for layer, lx, by, rx, ty in ports_orig:
|
|
if layer not in ports_by_layers:
|
|
ports_by_layers[layer] = []
|
|
ports_by_layers[layer].append((lx, by, rx, ty))
|
|
ports = []
|
|
for layer, rects in sorted(ports_by_layers.items()):
|
|
for lx, by, rx, ty in canonicalize_rectangles(rects):
|
|
ports.append((layer, lx, by, rx, ty))
|
|
lef_ports[current_pin] = ports
|
|
|
|
for old_pin, new_pin in compat_pins.items():
|
|
if old_pin in lef_ports:
|
|
if new_pin in lef_ports:
|
|
logging.error(f"Both {old_pin} and {new_pin} ports appear in {lef}")
|
|
lef_errors += 1
|
|
else:
|
|
lef_ports[new_pin] = []
|
|
lef_ports[new_pin].extend(lef_ports[old_pin])
|
|
del lef_ports[old_pin]
|
|
|
|
for current_pin in def_pins:
|
|
if current_pin not in lef_ports:
|
|
logging.error(f"Pin {current_pin} not found in {lef}")
|
|
lef_errors += 1
|
|
else:
|
|
if len(lef_ports[current_pin]) > 1:
|
|
logging.error(f"Too many rectangles for pin {current_pin} in {lef}")
|
|
lef_errors += 1
|
|
lef_layer, *lef_rect = lef_ports[current_pin][0]
|
|
def_layer, *def_rect = def_pins[current_pin]
|
|
if lef_layer != def_layer:
|
|
logging.error(
|
|
f"Port {current_pin} on layer {lef_layer} in {lef} but on layer {def_layer} in {template_def}"
|
|
)
|
|
lef_errors += 1
|
|
elif lef_rect != def_rect:
|
|
logging.error(
|
|
f"Port {current_pin} has different dimensions in {lef} and {template_def}"
|
|
)
|
|
lef_errors += 1
|
|
|
|
for current_pin in power_pins:
|
|
if current_pin not in lef_ports:
|
|
logging.error(f"Pin {current_pin} not found in {lef}")
|
|
lef_errors += 1
|
|
else:
|
|
for layer, lx, by, rx, ty in lef_ports[current_pin]:
|
|
width = rx - lx
|
|
if layer != power_pins_layer[tech]:
|
|
logging.error(
|
|
f"Port {current_pin} has wrong layer in {lef}: {layer} != met4"
|
|
)
|
|
lef_errors += 1
|
|
if width < 1200:
|
|
logging.error(
|
|
f"Port {current_pin} has too small width in {lef}: {width/1000} < 1.2 um"
|
|
)
|
|
lef_errors += 1
|
|
if by > 10000:
|
|
logging.error(
|
|
f"Port {current_pin} is too far from bottom edge of module: {by/1000} > 10 um"
|
|
)
|
|
lef_errors += 1
|
|
if die_height - ty > 10000:
|
|
logging.error(
|
|
f"Port {current_pin} is too far from top edge of module: {(die_height-ty)/1000} > 10 um"
|
|
)
|
|
lef_errors += 1
|
|
if lx < 0 or rx > die_width or by < 0 or ty > die_height:
|
|
logging.error(
|
|
f"Port {current_pin} not entirely within project area in {lef}"
|
|
)
|
|
lef_errors += 1
|
|
|
|
# check for overlapping pins
|
|
|
|
for (pin1, rects1), (pin2, rects2) in combinations(sorted(lef_ports.items()), 2):
|
|
for layer1, lx1, by1, rx1, ty1 in rects1:
|
|
for layer2, lx2, by2, rx2, ty2 in rects2:
|
|
if layer1 != layer2:
|
|
continue
|
|
if rx1 < lx2 or rx2 < lx1:
|
|
continue
|
|
if ty1 < by2 or ty2 < by1:
|
|
continue
|
|
logging.error(
|
|
f"Overlapping pins in {lef}: {pin1} and {pin2}."
|
|
"All exported pins have to be separate, and must not overlap or abut."
|
|
)
|
|
lef_errors += 1
|
|
|
|
# check gds for the ports being present
|
|
|
|
lib = gdstk.read_gds(gds)
|
|
top = [cell for cell in lib.top_level() if cell.name == toplevel]
|
|
if not top:
|
|
raise PrecheckFailure("Wrong cell at GDS top-level")
|
|
top = top[0]
|
|
|
|
gds_errors = 0
|
|
|
|
if tech != "gf180mcuD":
|
|
gds_layers = valid_lef_port_layers[tech]
|
|
gds_layer_lookup = {j: i for i, j in gds_layers.items()}
|
|
polygon_list = {layer: [] for layer in gds_layers}
|
|
for poly in top.polygons:
|
|
poly_layer = (poly.layer, poly.datatype)
|
|
layer_name = gds_layer_lookup.get(poly_layer, None)
|
|
if layer_name is not None:
|
|
polygon_list[layer_name].append(poly)
|
|
merged_layers = {}
|
|
for layer in gds_layers:
|
|
merged_layers[layer] = gdstk.boolean(polygon_list[layer], [], "or")
|
|
|
|
for current_pin, lef_rects in sorted(lef_ports_orig.items()):
|
|
for layer, lx, by, rx, ty in lef_rects:
|
|
if layer + ".pin" not in gds_layers:
|
|
raise PrecheckFailure(
|
|
f"Unexpected port layer in LEF: {current_pin} is on layer {layer}"
|
|
)
|
|
|
|
pin_ok = False
|
|
for poly in merged_layers[layer + ".pin"]:
|
|
if poly.contain_all(
|
|
((lx + 1) / 1000, (by + 1) / 1000),
|
|
((rx - 1) / 1000, (by + 1) / 1000),
|
|
((lx + 1) / 1000, (ty - 1) / 1000),
|
|
((rx - 1) / 1000, (ty - 1) / 1000),
|
|
):
|
|
pin_ok = True
|
|
|
|
if not pin_ok:
|
|
logging.error(
|
|
f"Port {current_pin} missing from layer {layer}.pin in {gds}"
|
|
)
|
|
gds_errors += 1
|
|
|
|
if lef_errors > 0 or gds_errors > 0:
|
|
err_list = []
|
|
if lef_errors > 0:
|
|
err_list.append(f"{lef_errors} LEF error" + ("s" if lef_errors > 1 else ""))
|
|
if gds_errors > 0:
|
|
err_list.append(f"{gds_errors} GDS error" + ("s" if gds_errors > 1 else ""))
|
|
err_desc = " and ".join(err_list)
|
|
raise PrecheckFailure(
|
|
f"Some ports are missing or have wrong dimensions, see {err_desc} above"
|
|
)
|