def rectMerge(rect1, rect2):
rect = odb.Rect(min(rect1.xMin(), rect2.xMin()),
min(rect1.yMin(), rect2.yMin()),
max(rect1.xMax(), rect2.xMax()),
max(rect1.yMax(), rect2.yMax()))
return rect
def transformRect(rect, orient):
transform = odb.dbTransform(orient)
rect_ll = odb.Point(*rect.ll())
rect_ur = odb.Point(*rect.ur())
transform.apply(rect_ll)
transform.apply(rect_ur)
rect = odb.Rect(rect_ll, rect_ur)
return rect
def rectIntersection(rect1, rect2):
rect = odb.Rect()
if rectOverlaps(rect1, rect2):
rect.set_xlo(max(rect1.xMin(), rect2.xMin()))
rect.set_ylo(max(rect1.yMin(), rect2.yMin()))
rect.set_xhi(min(rect1.xMax(), rect2.xMax()))
rect.set_yhi(min(rect1.yMax(), rect2.yMax()))
return rect
def boxes2Rects(boxes, transform):
rects = []
for box in boxes:
ur = odb.Point(box.xMin(), box.yMin())
ll = odb.Point(box.xMax(), box.yMax())
transform.apply(ll)
transform.apply(ur)
pin_layer = box.getTechLayer()
rects.append({"layer": pin_layer, "rect": odb.Rect(ll, ur)})
return rects
def createWireBox(rect_width,
rect_height,
rect_x,
rect_y,
layer,
net,
reorient="R0"):
rect = odb.Rect(0, 0, rect_width, rect_height)
rect.moveTo(rect_x, rect_y)
rect = transformRect(rect, reorient)
box = {"rect": rect, "layer": layer, "net": net}
return box
def getShapesOverlappingBBox(llx, lly, urx, ury, layers=[], ext_orient="R0"):
shapes_overlapping = []
rect_bbox = odb.Rect(llx, lly, urx, ury)
for box in ALL_BOXES:
box_layer = box["layer"]
ignore_box = (len(layers) != 0)
for layer in layers:
if equalLayers(layer, box_layer):
ignore_box = False
break
if not ignore_box:
rect_box = transformRect(box["rect"], ext_orient)
if rectOverlaps(rect_box, rect_bbox):
shapes_overlapping.append(box)
return shapes_overlapping
def gridify(rect):
x1, y1 = rect.ll()
x2, y2 = rect.ur()
if (x2 - x1) % 2 != 0:
x1 += 5 # 0.005 microns !
return odb.Rect(x1, y1, x2, y2)
# account for obstructions
from_layer = box["layer"]
to_layer = nearest_stripe_box["layer"]
# prefer the highest possible connecting layer (antenna reasons)
connecting_layer = from_layer
if not isHighestRoutingLayer(to_layer):
connecting_layer = getUpperRoutingLayer(to_layer)
elif not isLowestRoutingLayer(to_layer):
connecting_layer = getLowerRoutingLayer(to_layer)
print("Connecting with", connecting_layer.getName(), "to",
to_layer.getName())
wire_rect = odb.Rect(projection_x_min, pad_pin_rect.yMin(),
projection_x_max, stripe_rect.yMin())
# adjust width
MAX_SPACING = getTechMaxSpacing(
(set(layersBetween(from_layer, connecting_layer)).union(
layersBetween(connecting_layer, to_layer))))
# note that the box is move away from the pad to evade interactions with
# nearby pads
overlapping_boxes = getShapesOverlappingBBox(
wire_rect.xMin() - MAX_SPACING,
wire_rect.yMin(),
wire_rect.xMax() + MAX_SPACING,
wire_rect.yMax() - MAX_SPACING,
ext_orient=pad_pin_orient_inv,
layers=list(
set(layersBetween(connecting_layer, to_layer)) - set([to_layer])))
def cli(
input_lef,
output_def,
config,
ver_layer,
hor_layer,
ver_width_mult,
hor_width_mult,
length,
hor_extension,
ver_extension,
reverse,
bus_sort,
input_def,
):
"""
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
"""
def_file_name = input_def
lef_file_name = input_lef
output_def_file_name = output_def
config_file_name = config
bus_sort_flag = bus_sort
h_layer_name = hor_layer
v_layer_name = ver_layer
h_width_mult = float(hor_width_mult)
v_width_mult = float(ver_width_mult)
# Initialize OpenDB
db_top = odb.dbDatabase.create()
odb.read_lef(db_top, lef_file_name)
odb.read_def(db_top, def_file_name)
block = db_top.getChip().getBlock()
micron_in_units = block.getDefUnits()
LENGTH = int(micron_in_units * length)
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
reverse_arr_raw = reverse.split(",")
reverse_arr = []
for element in reverse_arr_raw:
if element.strip() != "":
reverse_arr.append(f"#{element}")
def getGrid(origin, count, step):
tracks = []
pos = origin
for i in range(count):
tracks.append(pos)
pos += step
assert len(tracks) > 0
tracks.sort()
return tracks
def equallySpacedSeq(m, arr):
seq = []
n = len(arr)
# Bresenham
indices = [i * n // m + n // (2 * m) for i in range(m)]
for i in indices:
seq.append(arr[i])
return seq
# HUMAN SORTING: https://stackoverflow.com/questions/5967500/how-to-correctly-sort-a-string-with-a-number-inside
def natural_keys(enum):
def atof(text):
try:
retval = float(text)
except ValueError:
retval = text
return retval
text = enum[0]
text = re.sub(r"(\[|\]|\.|\$)", "", text)
"""
alist.sort(key=natural_keys) sorts in human order
http://nedbatchelder.com/blog/200712/human_sorting.html
(see toothy's implementation in the comments)
float regex comes from https://stackoverflow.com/a/12643073/190597
"""
return [
atof(c) for c in re.split(r"[+-]?([0-9]+(?:[.][0-9]*)?|[.][0-9]+)", text)
]
def bus_keys(enum):
text = enum[0]
m = re.match(r"^.*\[(\d+)\]$", text)
if not m:
return -1
else:
return int(m.group(1))
# read config
pin_placement_cfg = {"#N": [], "#E": [], "#S": [], "#W": []}
cur_side = None
if config_file_name is not None and config_file_name != "":
with open(config_file_name, "r") as config_file:
for line in config_file:
line = line.split()
if len(line) == 0:
continue
if len(line) > 1:
print("Only one entry allowed per line.")
sys.exit(1)
token = line[0]
if cur_side is not None and token[0] != "#":
pin_placement_cfg[cur_side].append(token)
elif token not in [
"#N",
"#E",
"#S",
"#W",
"#NR",
"#ER",
"#SR",
"#WR",
"#BUS_SORT",
]:
print(
"Valid directives are #N, #E, #S, or #W. Append R for reversing the default order.",
"Use #BUS_SORT to group 'bus bits' by index.",
"Please make sure you have set a valid side first before listing pins",
)
sys.exit(1)
elif token == "#BUS_SORT":
bus_sort_flag = True
else:
if len(token) == 3:
token = token[0:2]
reverse_arr.append(token)
cur_side = token
# build a list of pins
chip_top = db_top.getChip()
block_top = chip_top.getBlock()
top_design_name = block_top.getName()
tech = db_top.getTech()
H_LAYER = tech.findLayer(h_layer_name)
V_LAYER = tech.findLayer(v_layer_name)
H_WIDTH = int(h_width_mult * H_LAYER.getWidth())
V_WIDTH = int(v_width_mult * V_LAYER.getWidth())
print("Top-level design name:", top_design_name)
bterms = block_top.getBTerms()
bterms_enum = []
for bterm in bterms:
pin_name = bterm.getName()
bterms_enum.append((pin_name, bterm))
# sort them "humanly"
bterms_enum.sort(key=natural_keys)
if bus_sort_flag:
bterms_enum.sort(key=bus_keys)
bterms = [bterm[1] for bterm in bterms_enum]
pin_placement = {"#N": [], "#E": [], "#S": [], "#W": []}
bterm_regex_map = {}
for side in pin_placement_cfg:
for regex in pin_placement_cfg[side]: # going through them in order
regex += "$" # anchor
for bterm in bterms:
# if a pin name matches multiple regexes, their order will be
# arbitrary. More refinement requires more strict regexes (or just
# the exact pin name).
pin_name = bterm.getName()
if re.match(regex, pin_name) is not None:
if bterm in bterm_regex_map:
print(
"Error: Multiple regexes matched",
pin_name,
". Those are",
bterm_regex_map[bterm],
"and",
regex,
)
sys.exit(os.EX_DATAERR)
bterm_regex_map[bterm] = regex
pin_placement[side].append(bterm) # to maintain the order
unmatched_bterms = [bterm for bterm in bterms if bterm not in bterm_regex_map]
if len(unmatched_bterms) > 0:
print("Warning: Some pins weren't matched by the config file")
print("Those are:", [bterm.getName() for bterm in unmatched_bterms])
if True:
print("Assigning random sides to the above pins")
for bterm in unmatched_bterms:
random_side = random.choice(list(pin_placement.keys()))
pin_placement[random_side].append(bterm)
else:
sys.exit(1)
assert len(block_top.getBTerms()) == len(
pin_placement["#N"]
+ pin_placement["#E"]
+ pin_placement["#S"]
+ pin_placement["#W"]
)
# generate slots
DIE_AREA = block_top.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, step = block_top.findTrackGrid(H_LAYER).getGridPatternY(0)
h_tracks = getGrid(origin, count, step)
origin, count, step = block_top.findTrackGrid(V_LAYER).getGridPatternX(0)
v_tracks = getGrid(origin, count, step)
for rev in reverse_arr:
pin_placement[rev].reverse()
# create the pins
for side in pin_placement:
if side in ["#N", "#S"]:
slots = equallySpacedSeq(len(pin_placement[side]), v_tracks)
else:
slots = equallySpacedSeq(len(pin_placement[side]), h_tracks)
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("Warning:", pin_name, "already has shapes. Modifying them")
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, LENGTH + V_EXTENSION)
if side == "#N":
y = BLOCK_UR_Y - 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, LENGTH + H_EXTENSION, H_WIDTH)
if side == "#E":
x = BLOCK_UR_X - 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())
print(
f"Writing {output_def_file_name}...",
)
odb.write_def(block_top, output_def_file_name)
def io_place(
config,
ver_layer,
hor_layer,
ver_width_mult,
hor_width_mult,
length,
hor_extension,
ver_extension,
reverse,
bus_sort,
output,
input_lef,
input_def,
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
"""
def_file_name = input_def
lef_file_name = input_lef
output_def_file_name = output
config_file_name = config
bus_sort_flag = bus_sort
unmatched_error_flag = unmatched_error
h_layer_name = hor_layer
v_layer_name = ver_layer
h_width_mult = float(hor_width_mult)
v_width_mult = float(ver_width_mult)
# Initialize OpenDB
reader = OdbReader(lef_file_name, def_file_name)
micron_in_units = reader.dbunits
LENGTH = int(micron_in_units * length)
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
reverse_arr_raw = reverse.split(",")
reverse_arr = []
for element in reverse_arr_raw:
if element.strip() != "":
reverse_arr.append(f"#{element}")
# read config
pin_placement_cfg = {"#N": [], "#E": [], "#S": [], "#W": []}
cur_side = None
if config_file_name is not None and config_file_name != "":
with open(config_file_name, "r") as config_file:
for line in config_file:
line = line.split()
if len(line) == 0:
continue
if len(line) > 1:
print("Only one entry allowed per line.")
sys.exit(1)
token = line[0]
if cur_side is not None and token[0] != "#":
pin_placement_cfg[cur_side].append(token)
elif token not in [
"#N",
"#E",
"#S",
"#W",
"#NR",
"#ER",
"#SR",
"#WR",
"#BUS_SORT",
]:
print(
"Valid directives are #N, #E, #S, or #W. Append R for reversing the default order.",
"Use #BUS_SORT to group 'bus bits' by index.",
"Please make sure you have set a valid side first before listing pins",
)
sys.exit(1)
elif token == "#BUS_SORT":
bus_sort_flag = True
else:
if len(token) == 3:
token = token[0:2]
reverse_arr.append(token)
cur_side = token
# build a list of pins
H_LAYER = reader.tech.findLayer(h_layer_name)
V_LAYER = reader.tech.findLayer(v_layer_name)
H_WIDTH = int(h_width_mult * H_LAYER.getWidth())
V_WIDTH = int(v_width_mult * V_LAYER.getWidth())
print("Top-level design name:", reader.name)
bterms = reader.block.getBTerms()
bterms_enum = []
for bterm in bterms:
pin_name = bterm.getName()
bterms_enum.append((pin_name, bterm))
# sort them "humanly"
bterms_enum.sort(key=natural_keys)
if bus_sort_flag:
bterms_enum.sort(key=bus_keys)
bterms = [bterm[1] for bterm in bterms_enum]
pin_placement = {"#N": [], "#E": [], "#S": [], "#W": []}
bterm_regex_map = {}
for side in pin_placement_cfg:
for regex in pin_placement_cfg[side]: # going through them in order
regex += "$" # anchor
for bterm in bterms:
# if a pin name matches multiple regexes, their order will be
# arbitrary. More refinement requires more strict regexes (or just
# the exact pin name).
pin_name = bterm.getName()
if re.match(regex, pin_name) is not None:
if bterm in bterm_regex_map:
print(
"Error: Multiple regexes matched",
pin_name,
". Those are",
bterm_regex_map[bterm],
"and",
regex,
)
sys.exit(os.EX_DATAERR)
bterm_regex_map[bterm] = regex
pin_placement[side].append(bterm) # to maintain the order
unmatched_bterms = [
bterm for bterm in bterms if bterm not in bterm_regex_map
]
if len(unmatched_bterms) > 0:
print("Warning: Some pins weren't matched by the config file")
print("Those are:", [bterm.getName() for bterm in unmatched_bterms])
if unmatched_error_flag:
print("Treating unmatched pins as errors. Exiting..")
sys.exit(1)
else:
print("Assigning random sides to the above pins")
for bterm in unmatched_bterms:
random_side = random.choice(list(pin_placement.keys()))
pin_placement[random_side].append(bterm)
assert len(reader.block.getBTerms()) == len(pin_placement["#N"] +
pin_placement["#E"] +
pin_placement["#S"] +
pin_placement["#W"])
# 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, step = reader.block.findTrackGrid(H_LAYER).getGridPatternY(
0)
h_tracks = getGrid(origin, count, step)
origin, count, step = reader.block.findTrackGrid(V_LAYER).getGridPatternX(
0)
v_tracks = getGrid(origin, count, step)
for rev in reverse_arr:
pin_placement[rev].reverse()
# create the pins
for side in pin_placement:
if side in ["#N", "#S"]:
slots = equallySpacedSeq(len(pin_placement[side]), v_tracks)
else:
slots = equallySpacedSeq(len(pin_placement[side]), h_tracks)
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("Warning:", pin_name,
"already has shapes. Modifying them")
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, LENGTH + V_EXTENSION)
if side == "#N":
y = BLOCK_UR_Y - 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, LENGTH + H_EXTENSION, H_WIDTH)
if side == "#E":
x = BLOCK_UR_X - 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())
print(f"Writing {output_def_file_name}...", )
odb.write_def(reader.block, output_def_file_name)
bterm = pin_placement[side][i]
slot = slots[i]
pin_name = bterm.getName()
pins = bterm.getBPins()
if len(pins) > 0:
print("Warning:", pin_name, "already has shapes. Modifying them")
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, LENGTH + V_EXTENSION)
if side == "#N":
y = BLOCK_UR_Y - 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, LENGTH + H_EXTENSION, H_WIDTH)
if side == "#E":
x = BLOCK_UR_X - 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())
def power_route(
output,
input_lef,
core_vdd_pin,
core_gnd_pin,
vdd_pad_pin_map,
gnd_pad_pin_map,
input_def,
):
"""
Takes a pre-routed top-level layout, produces a DEF file with VDD and GND special nets\
where the power pads are connected to the core ring
"""
# TODO: expose through arguments
ORIENT_LOC_MAP = {"R0": "N", "R90": "W", "R180": "S", "R270": "E"}
# TODO: allow control
VDD_NET_NAME = "VDD"
GND_NET_NAME = "GND"
# SKY130 DEFAULT
SPECIAL_NETS = {
VDD_NET_NAME: {
"core_pin": core_vdd_pin,
"covered": False,
"map": []
},
GND_NET_NAME: {
"core_pin": core_gnd_pin,
"covered": False,
"map": []
},
}
if vdd_pad_pin_map is None:
vdd_pad_pin_map = [{"pad_pin": "vccd", "pad_name_substr": "vccd"}]
else:
vdd_pad_pin_map = [{
"pad_pin": mapping[0],
"pad_name_substr": mapping[1]
} for mapping in vdd_pad_pin_map]
if gnd_pad_pin_map is None:
gnd_pad_pin_map = [
{
"pad_pin": "vssd",
"pad_name_substr": "vssd"
},
{
"pad_pin": "vssa",
"pad_name_substr": "vssa"
},
{
"pad_pin": "vssio",
"pad_name_substr": "vssio"
},
]
else:
gnd_pad_pin_map = [{
"pad_pin": mapping[0],
"pad_name_substr": mapping[1]
} for mapping in gnd_pad_pin_map]
SPECIAL_NETS[VDD_NET_NAME]["map"] = vdd_pad_pin_map
SPECIAL_NETS[GND_NET_NAME]["map"] = gnd_pad_pin_map
##################
reader = OdbReader(input_lef, input_def)
via_rules = reader.tech.getViaGenerateRules()
print("Found", len(via_rules), "VIA GENERATE rules")
# build dictionary of basic custom vias (ROW = COL = 1)
custom_vias = {}
for rule in via_rules:
lower_rules = rule.getViaLayerRule(0)
upper_rules = rule.getViaLayerRule(1)
cut_rules = rule.getViaLayerRule(2)
lower_layer = lower_rules.getLayer()
upper_layer = upper_rules.getLayer()
cut_layer = cut_rules.getLayer()
if lower_layer.getName() in custom_vias:
print("Skipping", rule.getName())
continue
via_params = odb.dbViaParams()
via_params.setBottomLayer(lower_layer)
via_params.setTopLayer(upper_layer)
via_params.setCutLayer(cut_layer)
cut_rect = cut_rules.getRect()
via_params.setXCutSize(cut_rect.dx())
via_params.setYCutSize(cut_rect.dy())
cut_spacing = cut_rules.getSpacing()
via_params.setXCutSpacing(cut_spacing[0] - cut_rect.dx())
via_params.setYCutSpacing(cut_spacing[1] - cut_rect.dy())
lower_enclosure = lower_rules.getEnclosure()
upper_enclosure = upper_rules.getEnclosure()
if "M1M2" in rule.getName():
print(lower_enclosure)
via_params.setXBottomEnclosure(lower_enclosure[0])
via_params.setYBottomEnclosure(lower_enclosure[1])
via_params.setXTopEnclosure(upper_enclosure[0])
via_params.setYTopEnclosure(upper_enclosure[1])
custom_vias[lower_layer.getName()] = {}
custom_vias[lower_layer.getName()][upper_layer.getName()] = {
"rule": rule,
"params": via_params,
}
print("Added", rule.getName())
def create_custom_via(layer1, layer2, width, height, reorient="R0"):
assert width > 0 and height > 0
if layer1.getRoutingLevel() < layer2.getRoutingLevel():
lower_layer_name = layer1.getName()
upper_layer_name = layer2.getName()
elif layer1.getRoutingLevel() > layer2.getRoutingLevel():
lower_layer_name = layer2.getName()
upper_layer_name = layer1.getName()
else:
raise Exception(
"Cannot create a custom via between two identical layers")
if reorient in ["R90", "R270"]:
width, height = height, width
via_name = "via_%s_%s_%dx%d" % (
lower_layer_name,
upper_layer_name,
width,
height,
)
custom_via = reader.block.findVia(via_name)
if not custom_via:
print("Creating", via_name)
via_params = custom_vias[lower_layer_name][upper_layer_name][
"params"]
via_rule = custom_vias[lower_layer_name][upper_layer_name]["rule"]
cut_width = via_params.getXCutSize()
cut_height = via_params.getYCutSize()
cut_spacing_x = via_params.getXCutSpacing()
cut_spacing_y = via_params.getXCutSpacing()
lower_enclosure_x = via_params.getXBottomEnclosure()
lower_enclosure_y = via_params.getYBottomEnclosure()
upper_enclosure_x = via_params.getXTopEnclosure()
upper_enclosure_y = via_params.getYTopEnclosure()
custom_via = odb.dbVia_create(reader.block, via_name)
custom_via.setViaGenerateRule(via_rule)
array_width = width - 2 * max(lower_enclosure_x, upper_enclosure_x)
array_height = height - 2 * max(lower_enclosure_y,
upper_enclosure_y)
# set ROWCOL
rows = 1 + (array_height - cut_height) // (cut_spacing_y +
cut_height)
cols = 1 + (array_width - cut_width) // (cut_spacing_x + cut_width)
via_params.setNumCutRows(rows)
via_params.setNumCutCols(cols)
custom_via.setViaParams(via_params)
return custom_via
def boxes2Rects(boxes, transform):
rects = []
for box in boxes:
ur = odb.Point(box.xMin(), box.yMin())
ll = odb.Point(box.xMax(), box.yMax())
transform.apply(ll)
transform.apply(ur)
pin_layer = box.getTechLayer()
rects.append({"layer": pin_layer, "rect": odb.Rect(ll, ur)})
return rects
def getInstObs(inst):
master = inst.getMaster()
master_ox, master_oy = master.getOrigin()
inst_ox, inst_oy = inst.getOrigin()
px, py = master_ox + inst_ox, master_oy + inst_oy
orient = inst.getOrient()
transform = odb.dbTransform(orient, odb.Point(px, py))
obstructions = master.getObstructions()
rects = boxes2Rects(obstructions, transform)
for rect in rects:
rect["type"] = "obstruction"
return rects
def getITermBoxes(iterm):
iterm_boxes = []
inst = iterm.getInst()
mterm = iterm.getMTerm()
master_ox, master_oy = inst.getMaster().getOrigin()
inst_ox, inst_oy = inst.getOrigin()
px, py = master_ox + inst_ox, master_oy + inst_oy
orient = inst.getOrient()
transform = odb.dbTransform(orient, odb.Point(px, py))
mpins = mterm.getMPins()
if len(mpins) > 1:
print(
"Warning:",
len(mpins),
"mpins for iterm",
inst.getName(),
mterm.getName(),
)
for i in range(len(mpins)):
mpin = mpins[i]
boxes = mpin.getGeometry()
iterm_boxes += boxes2Rects(boxes, transform)
# filter duplications
# TODO: OpenDB bug? duplicate mpins for some reason
iterm_boxes_set = set()
iterm_boxes_uniq = []
for box in iterm_boxes:
rect = box["rect"]
llx, lly = rect.ll()
urx, ury = rect.ur()
set_item = (box["layer"].getName(), llx, lly, urx, ury)
if set_item not in iterm_boxes_set:
iterm_boxes_set.add(set_item)
iterm_boxes_uniq.append(box)
return iterm_boxes_uniq
def getBiggestBoxAndIndex(boxes):
biggest_area = -1
biggest_box = None
biggest_i = -1
for i in range(len(boxes)):
box = boxes[i]
rect = box["rect"]
area = rect.area()
if area > biggest_area:
biggest_area = area
biggest_box = box
biggest_i = i
return biggest_box, biggest_i
def rectOverlaps(rect1, rect2):
return not (rect1.xMax() <= rect2.xMin()
or rect1.xMin() >= rect2.xMax()
or rect1.yMax() <= rect2.yMin()
or rect1.yMin() >= rect2.yMax())
def rectMerge(rect1, rect2):
rect = odb.Rect(
min(rect1.xMin(), rect2.xMin()),
min(rect1.yMin(), rect2.yMin()),
max(rect1.xMax(), rect2.xMax()),
max(rect1.yMax(), rect2.yMax()),
)
return rect
def getShapesOverlappingBBox(llx,
lly,
urx,
ury,
layers=[],
ext_orient="R0"):
shapes_overlapping = []
rect_bbox = odb.Rect(llx, lly, urx, ury)
for box in ALL_BOXES:
box_layer = box["layer"]
ignore_box = len(layers) != 0
for layer in layers:
if equalLayers(layer, box_layer):
ignore_box = False
break
if not ignore_box:
rect_box = transformRect(box["rect"], ext_orient)
if rectOverlaps(rect_box, rect_bbox):
shapes_overlapping.append(box)
return shapes_overlapping
def rectIntersection(rect1, rect2):
rect = odb.Rect()
if rectOverlaps(rect1, rect2):
rect.set_xlo(max(rect1.xMin(), rect2.xMin()))
rect.set_ylo(max(rect1.yMin(), rect2.yMin()))
rect.set_xhi(min(rect1.xMax(), rect2.xMax()))
rect.set_yhi(min(rect1.yMax(), rect2.yMax()))
return rect
def manhattanDistance(x1, y1, x2, y2):
return odb.Point.manhattanDistance(odb.Point(x1, y1),
odb.Point(x2, y2))
def center(x1, y1, x2, y2):
return (x1 + x2) // 2, (y1 + y2) // 2
def gridify(rect):
x1, y1 = rect.ll()
x2, y2 = rect.ur()
if (x2 - x1) % 2 != 0:
x1 += 5 # 0.005 microns !
return odb.Rect(x1, y1, x2, y2)
def forward(point, orient, distance):
x, y = point.x(), point.y()
if orient == "R0":
point_forward = odb.Point(x, y - distance)
elif orient == "R90":
point_forward = odb.Point(x + distance, y)
elif orient == "R180":
point_forward = odb.Point(x, y + distance)
elif orient == "R270":
point_forward = odb.Point(x - distance, y)
else:
print("Unknown orientation")
sys.exit(1)
return point_forward
def transformRect(rect, orient):
transform = odb.dbTransform(orient)
rect_ll = odb.Point(*rect.ll())
rect_ur = odb.Point(*rect.ur())
transform.apply(rect_ll)
transform.apply(rect_ur)
rect = odb.Rect(rect_ll, rect_ur)
return rect
def isObstruction(box):
return box["type"] == "obstruction"
def isCorePin(box):
return box["type"] == "core_pin"
def isStripe(box):
return isCorePin(box) and box["stripe_flag"]
def isPadPin(box):
return box["type"] == "pad_pin"
def isHighestRoutingLayer(layer):
return layer.getRoutingLevel() == reader.tech.getRoutingLayerCount()
def isLowestRoutingLayer(layer):
return layer.getRoutingLevel() == 1
def isRoutingLayer(layer):
return isinstance(layer,
odb.dbTechLayer) and layer.getRoutingLevel() != 0
def getUpperRoutingLayer(layer):
if not isRoutingLayer(layer):
raise Exception(
"Attempting to get upper routing layer of a non-routing layer")
if isHighestRoutingLayer(layer):
raise Exception(
"Attempting to get upper routing layer of the highest routing layer"
)
return layer.getUpperLayer().getUpperLayer()
def getLowerRoutingLayer(layer):
if not isRoutingLayer(layer):
raise Exception(
"Attempting to get lower routing layer of a non-routing layer")
if isLowestRoutingLayer(layer):
raise Exception(
"Attempting to get lower routing layer of the lowest routing layer"
)
return layer.getLowerLayer().getLowerLayer()
def equalLayers(layer1, layer2):
return layer1.getName() == layer2.getName()
def layersBetween(layer1, layer2):
# Inclusive
layers_between = [layer1]
if not equalLayers(layer1, layer2):
if layer1.getRoutingLevel() < layer2.getRoutingLevel():
layer1 = getUpperRoutingLayer(layer1)
while not equalLayers(layer1, layer2):
layers_between.append(layer1)
layer1 = getUpperRoutingLayer(layer1)
else:
layer1 = getLowerRoutingLayer(layer1)
while not equalLayers(layer1, layer2):
layers_between.append(layer1)
layer1 = getLowerRoutingLayer(layer1)
layers_between.append(layer2)
return layers_between
def createWireBox(rect_width,
rect_height,
rect_x,
rect_y,
layer,
net,
reorient="R0"):
rect = odb.Rect(0, 0, rect_width, rect_height)
rect.moveTo(rect_x, rect_y)
rect = transformRect(rect, reorient)
box = {"rect": rect, "layer": layer, "net": net}
return box
def getTechMaxSpacing(layers=reader.tech.getLayers()):
max_spacing = -1
for layer in layers:
max_spacing = max(max_spacing, layer.getSpacing())
# print("Max spacing for", layers, "is", max_spacing)
return max_spacing
print("Top-level design name:", reader.name)
# create special nets
for special_net_name in SPECIAL_NETS:
net = odb.dbNet_create(reader.block, special_net_name)
net.setSpecial()
net.setWildConnected()
wire = odb.dbSWire_create(net, "ROUTED")
SPECIAL_NETS[special_net_name]["net"] = net
SPECIAL_NETS[special_net_name]["wire"] = wire
ALL_BOXES = []
# disconnect all iterms from anywhere else !!! (is this even needed?)
for inst in reader.block.getInsts():
iterms = inst.getITerms()
ALL_BOXES += getInstObs(inst)
for iterm in iterms:
master_name = inst.getMaster().getName()
pin_name = iterm.getMTerm().getName()
matched_special_net_name = None
for special_net_name in SPECIAL_NETS:
net = SPECIAL_NETS[special_net_name]["net"]
for mapping in SPECIAL_NETS[special_net_name]["map"]:
core_pin = SPECIAL_NETS[special_net_name]["core_pin"]
pad_pin = mapping["pad_pin"]
pad_name_substr = mapping["pad_name_substr"]
if (pin_name == pad_pin
and pad_name_substr in master_name): # pad pin
matched_special_net_name = special_net_name
print(inst.getName(), "connected to", net.getName())
# iterm.connect(net)
# iterm.setSpecial()
# get the pin shapes
iterm_boxes = getITermBoxes(iterm)
pad_orient = iterm.getInst().getOrient()
for box in iterm_boxes:
box["net"] = special_net_name
box["type"] = "pad_pin"
box["orient"] = pad_orient
ALL_BOXES += iterm_boxes
elif pin_name == core_pin: # macro ring
matched_special_net_name = special_net_name
print(
inst.getName(),
"will be connected to",
master_name,
"/",
pin_name,
)
# iterm.connect(net)
# iterm.setSpecial()
iterm_boxes = getITermBoxes(iterm)
for box in iterm_boxes:
box["net"] = special_net_name
box["type"] = "core_pin"
box["stripe_flag"] = False
h_stripes = []
v_stripes = []
for i in range(4): # ASSUMPTION: 4 CORE RING-STRIPES
biggest_pin_box, biggest_pin_box_i = getBiggestBoxAndIndex(
iterm_boxes)
if biggest_pin_box is None:
continue
del iterm_boxes[biggest_pin_box_i]
biggest_pin_box["stripe_flag"] = True
rect = biggest_pin_box["rect"]
if rect.dx() > rect.dy(): # horizontal stripe
biggest_pin_box["orient"] = "R90"
h_stripes.append(biggest_pin_box)
else:
biggest_pin_box["orient"] = "R0"
v_stripes.append(biggest_pin_box)
if len(h_stripes) >= 2:
if (h_stripes[0]["rect"].yMin() <
h_stripes[1]["rect"].yMin()):
h_stripes[0]["side"] = "S"
h_stripes[1]["side"] = "N"
else:
h_stripes[0]["side"] = "N"
h_stripes[1]["side"] = "S"
elif len(h_stripes) == 1:
print(
"Warning: only one horizontal stripe found for",
core_pin,
)
if (reader.block.getBBox().yMax() -
h_stripes[0]["rect"].yMin() >
reader.block.getBBox().yMin() -
h_stripes[0]["rect"].yMin()):
h_stripes[0]["side"] = "S"
else:
h_stripes[0]["side"] = "N"
else:
print(
"Warning: No horizontal stripes in the design!"
)
if len(v_stripes) >= 2:
if (v_stripes[0]["rect"].xMin() <
v_stripes[1]["rect"].xMin()):
v_stripes[0]["side"] = "W"
v_stripes[1]["side"] = "E"
else:
v_stripes[0]["side"] = "E"
v_stripes[1]["side"] = "W"
elif len(v_stripes) == 1:
print(
"Warning: only one vertical stripe found for",
core_pin)
if (reader.block.getBBox().xMax() -
v_stripes[0]["rect"].xMin() >
reader.block.getBBox().xMin() -
v_stripes[0]["rect"].xMin()):
v_stripes[0]["side"] = "W"
else:
v_stripes[0]["side"] = "E"
else:
print(
"Warning: No vertical stripes in the design!")
ALL_BOXES += iterm_boxes + v_stripes + h_stripes
if (matched_special_net_name is
None): # other pins are obstructions for our purposes
new_obstructions = getITermBoxes(iterm)
for obs in new_obstructions:
obs["type"] = "obstruction"
ALL_BOXES += new_obstructions
# only types are: obstruction, core_pin, pad_pin
assert len({box["type"]: None for box in ALL_BOXES}) == 3
wire_boxes = []
PAD_PINS = [box for box in ALL_BOXES if isPadPin(box)]
CORE_STRIPES = [box for box in ALL_BOXES if isStripe(box)]
# Go over power pad pins, find the nearest ring-stripe,
# check how to connect to it
connections_count = 0
for box in PAD_PINS:
pad_pin_orient = box["orient"]
pad_pin_rect = box["rect"]
##
# if connections_count > 29:
# pprint(wire_boxes)
# break
##
nearest_stripe_box = None
for stripe in CORE_STRIPES:
if (box["net"] == stripe["net"]
and stripe["side"] == ORIENT_LOC_MAP[pad_pin_orient]):
nearest_stripe_box = stripe
if nearest_stripe_box is None:
print(
"Pad pin at",
box["rect"].ll(),
box["rect"].ur(),
"doesn't have a facing stripe. Skipping.",
)
continue
stripe_rect = nearest_stripe_box["rect"]
# TRANSFORM TO R0 ORIENTATION
pad_pin_orient_inv = "R" + str((360 - int(pad_pin_orient[1:])) % 360)
assert pad_pin_orient_inv in ORIENT_LOC_MAP
pad_pin_rect = transformRect(pad_pin_rect, pad_pin_orient_inv)
stripe_rect = transformRect(stripe_rect, pad_pin_orient_inv)
projection_x_min, projection_x_max = max(pad_pin_rect.xMin(),
stripe_rect.xMin()), min(
stripe_rect.xMax(),
pad_pin_rect.xMax())
MIN_WIDTH = 5000
if projection_x_max - projection_x_min < MIN_WIDTH:
continue
# account for obstructions
from_layer = box["layer"]
to_layer = nearest_stripe_box["layer"]
# prefer the highest possible connecting layer (antenna reasons)
connecting_layer = from_layer
if not isHighestRoutingLayer(to_layer):
connecting_layer = getUpperRoutingLayer(to_layer)
elif not isLowestRoutingLayer(to_layer):
connecting_layer = getLowerRoutingLayer(to_layer)
print("Connecting with", connecting_layer.getName(), "to",
to_layer.getName())
wire_rect = odb.Rect(projection_x_min, pad_pin_rect.yMin(),
projection_x_max, stripe_rect.yMin())
# adjust width
MAX_SPACING = getTechMaxSpacing(
(set(layersBetween(from_layer, connecting_layer)).union(
layersBetween(connecting_layer, to_layer))))
# note that the box is move away from the pad to evade interactions with
# nearby pads
overlapping_boxes = getShapesOverlappingBBox(
wire_rect.xMin() - MAX_SPACING,
wire_rect.yMin(),
wire_rect.xMax() + MAX_SPACING,
wire_rect.yMax() - MAX_SPACING,
ext_orient=pad_pin_orient_inv,
layers=list(
set(layersBetween(connecting_layer, to_layer)) -
set([to_layer])),
)
# find the new possible wire_rect width after subtracting the obstructions
skip = False
obs_boundaries = []
for ov_box in overlapping_boxes:
obs_rect = transformRect(ov_box["rect"], pad_pin_orient_inv)
# if it is completely contained in an obstruction
if (obs_rect.xMin() <= wire_rect.xMin() < wire_rect.xMax() <=
obs_rect.xMax()):
skip = True
break
if (wire_rect.xMin() - MAX_SPACING <= obs_rect.xMin() <=
wire_rect.xMax() + MAX_SPACING):
obs_boundaries.append(obs_rect.xMin())
if (wire_rect.xMin() - MAX_SPACING <= obs_rect.xMax() <=
wire_rect.xMax() + MAX_SPACING):
obs_boundaries.append(obs_rect.xMax())
obs_boundaries.sort()
if len(obs_boundaries) > 0:
obs_min_x = obs_boundaries[0]
obs_max_x = obs_boundaries[-1]
print("Adjusting", wire_rect.ll(), wire_rect.ur())
print(obs_max_x - obs_min_x)
print(obs_min_x, obs_max_x)
if (obs_min_x - (wire_rect.xMin() - MAX_SPACING) >
(wire_rect.xMax() + MAX_SPACING) - obs_max_x):
wire_rect.set_xhi(obs_min_x - MAX_SPACING)
else:
wire_rect.set_xlo(obs_max_x + MAX_SPACING)
print("To", wire_rect.ll(), wire_rect.ur())
# leave some space for routing
from_layer_space = 2 * from_layer.getSpacing() + from_layer.getWidth()
wire_width = wire_rect.dx() - from_layer_space
wire_x = wire_rect.xMin() + from_layer_space
wire_y = wire_rect.yMax()
if wire_width < MIN_WIDTH:
skip = True
if skip:
continue
basic_rect = rectIntersection(wire_rect, stripe_rect)
# 1. extend outside by half of the size of the "basic rectangle"
wire_y -= basic_rect.dy() // 2
wire_boxes.append(
createWireBox(
wire_width,
basic_rect.dy() // 2,
wire_x,
wire_y,
from_layer,
box["net"],
reorient=pad_pin_orient,
))
# 2. vias up till the connecting_layer on the next basic rect
wire_y -= basic_rect.dy()
prev_layer = None
for layer in layersBetween(from_layer, connecting_layer):
if prev_layer is not None:
via = create_custom_via(
prev_layer,
layer,
wire_width,
basic_rect.dy(),
reorient=pad_pin_orient,
)
wire_boxes.append(
createWireBox(
wire_width,
basic_rect.dy(),
wire_x,
wire_y,
via,
box["net"],
reorient=pad_pin_orient,
))
wire_boxes.append(
createWireBox(
wire_width,
basic_rect.dy(),
wire_x,
wire_y,
layer,
box["net"],
reorient=pad_pin_orient,
))
prev_layer = layer
# 3. use the connecting layer to connect to the stripe
wire_height = wire_y - wire_rect.yMin()
wire_y = wire_rect.yMin()
wire_boxes.append(
createWireBox(
wire_width,
wire_height,
wire_x,
wire_y,
connecting_layer,
box["net"],
reorient=pad_pin_orient,
))
# 4. vias down from the connecting_layer to the to_layer (stripe layer)
prev_layer = None
for layer in layersBetween(connecting_layer, to_layer):
if prev_layer is not None:
via = create_custom_via(
prev_layer,
layer,
wire_width,
basic_rect.dy(),
reorient=pad_pin_orient,
)
wire_boxes.append(
createWireBox(
wire_width,
basic_rect.dy(),
wire_x,
wire_y,
via,
box["net"],
reorient=pad_pin_orient,
))
wire_boxes.append(
createWireBox(
wire_width,
basic_rect.dy(),
wire_x,
wire_y,
layer,
box["net"],
reorient=pad_pin_orient,
))
prev_layer = layer
connections_count += 1
# ROUTING
print("creating", len(wire_boxes), "wires")
for box in wire_boxes:
net_name = box["net"]
print(net_name, ": drawing a special wire on layer",
box["layer"].getName())
rect = gridify(box["rect"])
if isRoutingLayer(box["layer"]):
odb.dbSBox_create(
SPECIAL_NETS[net_name]["wire"],
box["layer"],
*rect.ll(),
*rect.ur(),
"COREWIRE",
odb.dbSBox.UNDEFINED,
)
else:
odb.dbSBox_create(
SPECIAL_NETS[net_name]["wire"],
box["layer"],
(rect.xMin() + rect.xMax()) // 2,
(rect.yMin() + rect.yMax()) // 2,
"COREWIRE",
)
SPECIAL_NETS[net_name]["covered"] = True
uncovered_nets = [
net_name for net_name in SPECIAL_NETS
if not SPECIAL_NETS[net_name]["covered"]
]
if len(uncovered_nets) > 0:
print("No routes created on the following nets:")
print(uncovered_nets)
print("Make sure the pads to be connected are facing the core rings")
sys.exit(1)
# OUTPUT
odb.write_def(reader.block, output)
odb.write_lef(odb.dbLib_getLib(reader.db, 1), f"{output}.lef")
