pin_bterm = chip_block.findBTerm(pin_name)
if pin_bterm is None:
pin_bterm = odb.dbBTerm_create(net, pin_name)
assert pin_bterm is not None, "Failed to create or find " + pin_name
pin_bterm.setIoType(iotype)
# x = odb.new_intp(); y = odb.new_intp()
# pad_iterm.getAvgXY(x, y); # crashes with clamps
# x = odb.intp_value(x); y = odb.intp_value(y)
pin_bpin = odb.dbBPin_create(pin_bterm)
pin_bpin.setPlacementStatus("PLACED")
odb.dbBox_create(pin_bpin,
pad_pin_layer,
ll.getX(),
ll.getY(),
ur.getX(),
ur.getY())
odb.dbITerm_connect(pad_iterm, net)
pin_bterm.connect(net)
labeled.append(inst_name)
assert labeled_count == pad_pins_to_label_count, ("Didn't label what I set out to label %d/%d" % (labeled_count, pad_pins_to_label_count),
set(pad_pin_map.keys())-set(labeled))
print("Writing", output_def_file_name)
odb.write_def(chip_block, output_def_file_name)
# print(to_connect)
nets_macro = block_macro.getNets()
created_macros = {}
for net in nets_macro:
iterms = net.getITerms() # asssumption: no pins (bterms) on top level
if not keep_flag:
for iterm in iterms:
odb.dbITerm_disconnect(iterm)
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(block_macro, 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 = block_macro.findInst(node_inst_name)
odb.dbITerm_connect(
new_inst.findITerm(node_iterm.getMTerm().getName()), net)
odb.write_def(block_macro, output_def_file_name)
required=True,
help='Output placed DEF file')
args = parser.parse_args()
input_lef_file_names = args.lef
input_def_file_name = args.input_def
output_def_file_name = args.output_def
# Load
db_design = odb.dbDatabase.create()
for lef in input_lef_file_names:
odb.read_lef(db_design, lef)
odb.read_def(db_design, input_def_file_name)
chip_design = db_design.getChip()
block_design = chip_design.getBlock()
top_design_name = block_design.getName()
print("Design name:", top_design_name)
cfg = {
'diode_cell_true': 'sky130_fd_sc_hd__diode_2',
'diode_cell_fake': 'sky130_ef_sc_hd__fakediode_2',
'diode_cell_pin': 'DIODE',
}
di = DiodeInserter(block_design, cfg)
di.execute()
# Write result
odb.write_def(block_design, output_def_file_name)
block_power = chip_power.getBlock()
assert block_power.getName() == design_name
print("Successfully created a new database")
POWER_GROUND_PORT_NAMES = [port.getName() for port in VDD_PORTS+GND_PORTS]
# using get_power_ground_ports doesn't work since the pins weren't
# created using pdngen
power_ground_ports = [port for port in block_power.getBTerms()\
if port.getName() in POWER_GROUND_PORT_NAMES]
for port in power_ground_ports:
iterms = port.getNet().getITerms()
for iterm in iterms:
inst_name = iterm.getInst().getName()
pin_name = iterm.getMTerm().getName()
original_inst = block.findInst(inst_name)
assert original_inst is not None, "Instance " + inst_name + " not found in the original netlist. Perhaps it was optimized out during synthesis?"
original_iterm = original_inst.findITerm(pin_name)
assert original_iterm is not None, inst_name + " doesn't have a pin named " + pin_name
original_port = find_power_ground_port(port.getName(), VDD_PORTS+GND_PORTS)
assert original_port is not None, port.getName() + " not found in the original netlist."
odb.dbITerm_disconnect(original_iterm)
odb.dbITerm_connect(original_iterm, original_port.getNet())
print("Modified connections between", port.getName(), "and", inst_name)
odb.write_def(block, output_file_name)
import os
current_dir = os.path.dirname(os.path.realpath(__file__))
tests_dir = os.path.abspath(os.path.join(current_dir, os.pardir))
opendb_dir = os.path.abspath(os.path.join(tests_dir, os.pardir))
data_dir = os.path.join(tests_dir, "data")
db = odb.dbDatabase.create()
odb.read_lef(
db, os.path.join(data_dir, "Nangate45", "NangateOpenCellLibrary.mod.lef"))
odb.read_lef(db, os.path.join(data_dir, "ICEWall", "dummy_pads.lef"))
odb.read_def(db, os.path.join(data_dir, "ICEWall", "octilinear.def"))
chip = db.getChip()
if chip == None:
exit("Read DEF Failed")
result = odb.write_def(
chip.getBlock(),
os.path.join(opendb_dir, "build", "generated_octilinear.def"))
assert result == 1, "DEF not written"
db_file = os.path.join(opendb_dir, "build", "export_oct.db")
export_result = odb.write_db(db, db_file)
if export_result != 1:
exit("Export DB Failed")
new_db = odb.dbDatabase.create()
new_db = odb.read_db(new_db, db_file)
if odb.db_diff(db, new_db):
exit("Error: Difference found between exported and imported DB")
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(block_top, output_def_file_name)
odb.write_lef(odb.dbLib_getLib(db_top, 1), output_def_file_name + ".lef")
print("Done")
opendb_dir = os.path.abspath(os.path.join(tests_dir, os.pardir)) data_dir = os.path.join(tests_dir, "data") db = odb.dbDatabase.create() odb.read_lef(db, os.path.join(data_dir, "gscl45nm.lef")) odb.read_def(db, os.path.join(data_dir, "design.def")) chip = db.getChip() block = chip.getBlock() bterms = block.getBTerms() assert (len(bterms) == 12) pins = bterms[0].getBPins() assert (len(pins) == 2) boxes = pins[0].getBoxes() assert (len(boxes) == 2) box_0 = boxes[0] box_1 = boxes[1] assert (box_0.xMin() == 19950) assert (box_0.yMin() == 10000) assert (box_0.xMax() == 20050) assert (box_0.yMax() == 10100) assert (box_1.xMin() == 19980) assert (box_1.yMin() == 10000) assert (box_1.xMax() == 20020) assert (box_1.yMax() == 10150) result = odb.write_def(block, os.path.join(opendb_dir, "build/def.out")) exit()
input_lef_file_names = args.lef
input_def_file_name = args.input_def
output_def_file_name = args.output_def
for lef in input_lef_file_names:
odb.read_lef(db_design, lef)
odb.read_def(db_design, input_def_file_name)
chip_design = db_design.getChip()
block_design = chip_design.getBlock()
top_design_name = block_design.getName()
print("Design name:", top_design_name)
SRAMPower(block_design).process_all()
odb.write_def(block_design, output_def_file_name)
import sys
sys.exit(0)
import opendbpy as odb
db_design = odb.dbDatabase.create()
odb.read_lef(db_design, 'test_pwr2/tmp/floorplan/merged_unpadded.lef')
odb.read_def(db_design, 'test_pwr2/tmp/floorplan/pdn.def')
chip_design = db_design.getChip()
block_design = chip_design.getBlock()
top_design_name = block_design.getName()
for obs in obses:
obs = obs.strip()
m = re.match(RE_OBS, obs)
assert m,\
"Incorrectly formatted input (%s).\n Format: layer llx lly urx ury, ..." % (obs)
layer = m.group('layer')
bbox = [float(x) for x in m.group('bbox').split()]
obs_list.append((layer, bbox))
design_db = odb.dbDatabase.create()
for lef in input_lef_file_names:
odb.read_lef(design_db, lef)
odb.read_def(design_db, input_def_file_name)
design_chip = design_db.getChip()
design_block = design_chip.getBlock()
design_insts = design_block.getInsts()
design_tech = design_db.getTech()
for obs in obs_list:
layer = obs[0]
bbox = obs[1]
dbu = design_tech.getDbUnitsPerMicron()
bbox = [int(x * dbu) for x in bbox]
print("Creating an obstruction on", layer, "at", *bbox, "(DBU)")
odb.dbObstruction_create(design_block, design_tech.findLayer(layer), *bbox)
odb.write_def(design_block, output_def_file_name)
vias = tech.getVias()
via1 = vias[0]
layer1 = via1.getBottomLayer()
via2 = vias[1]
via3 = vias[2]
block = chip.getBlock()
net = odb.dbNet_create(block, "w1")
wire = odb.dbWire_create(net)
wire_encoder = odb.dbWireEncoder()
wire_encoder.begin(wire)
wire_encoder.newPath(layer1, "ROUTED")
wire_encoder.addPoint(2000, 2000)
jid1 = wire_encoder.addPoint(10000, 2000)
wire_encoder.addPoint(18000, 2000)
wire_encoder.newPath(jid1)
wire_encoder.addTechVia(via1)
jid2 = wire_encoder.addPoint(10000, 10000)
wire_encoder.addPoint(10000, 18000)
wire_encoder.newPath(jid2)
jid3 = wire_encoder.addTechVia(via2)
wire_encoder.end()
result = odb.write_def(block, os.path.join(opendb_dir,
"build/wire_encoder.def"))
if (result != 1):
exit("Write DEF failed")
