def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--schema_dir', required=True)
parser.add_argument('--schema', required=True, choices=SCHEMAS)
parser.add_argument('--root_schema_path', default=None)
parser.add_argument('--patch_path', required=True)
parser.add_argument('--patch_format', required=True, choices=FORMATS)
parser.add_argument('root')
parser.add_argument('patch')
parser.add_argument('output')
args = parser.parse_args()
patch_path = args.patch_path.split('.')
root_schema = get_schema(args.schema_dir, args.schema,
args.root_schema_path)
with open(args.root, 'rb') as f:
message = read_capnp_file(root_schema, f)
message = message.as_builder()
with open(args.patch, 'rb') as f:
patch_capnp(message, patch_path, args.patch_format, f)
with open(args.output, 'wb') as f:
write_capnp_file(message, f)
def init(fileName='', device_file=DEVICE_FILE, schema_dir=SCHEMA_DIR):
"""
Set up the environment for __main__.
Also useful to run after an import for debugging/testing
Parameters:
fileName (str) - Name of file to pass to XDLRC constructor
"""
device_schema = Interchange(SCHEMA_DIR).device_resources_schema.Device
return XDLRC(read_capnp_file(device_schema, device_file), fileName, FAMILY, PKG, GRADE)
def patch_capnp(message, patch_path, patch_format, in_f):
message_to_populate = message
for path in patch_path[:-1]:
message_to_populate = getattr(message_to_populate, path)
message_to_populate = message_to_populate.init(patch_path[-1])
if patch_format == 'capnp':
message = read_capnp_file(message_to_populate.schema, in_f)
json_data = to_json(message)
from_json(message_to_populate, json_data)
else:
read_format_to_message(message_to_populate, patch_format, in_f)
def read_format(schema, input_format, in_f):
""" Read serialized format into capnp message of specific schema.
schema: Capnp schema for input format.
input_format (str): Input format type, either capnp, json, yaml.
in_f (file-like): Binary file that contains serialized data.
Returns capnp message Builder of specified input format.
"""
if input_format == 'capnp':
message = read_capnp_file(schema, in_f)
message = message.as_builder()
elif input_format in ['json', 'yaml', 'pyyaml']:
message = schema.new_message()
read_format_to_message(message, input_format, in_f)
else:
assert False, 'Invalid input format {}'.format(input_format)
return message
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--schema_dir', required=True)
parser.add_argument('--library', default="primitives")
parser.add_argument('device_in')
parser.add_argument('yosys_json')
parser.add_argument('device_out')
args = parser.parse_args()
interchange = Interchange(args.schema_dir)
with open(args.device_in, 'rb') as f:
device = read_capnp_file(interchange.device_resources_schema.Device, f)
device = device.as_builder()
with open(args.yosys_json) as f:
yosys_json = json.load(f)
prim_lib = Library(args.library)
assert 'modules' in yosys_json, yosys_json.keys()
for module_name, module_data in sorted(yosys_json['modules'].items(),
key=lambda x: x[0]):
# Library should only contain blackboxes
assert module_data['attributes'].get('blackbox', 0) or \
module_data['attributes'].get('whitebox', 0), module_name
property_map = {}
if 'attributes' in module_data:
property_map.update(module_data['attributes'])
if 'parameters' in module_data:
property_map.update(module_data['parameters'])
cell = Cell(module_name, property_map)
for port_name, port_data in module_data['ports'].items():
if port_data['direction'] == 'input':
direction = Direction.Input
elif port_data['direction'] == 'output':
direction = Direction.Output
else:
assert port_data['direction'] == 'inout'
direction = Direction.Inout
property_map = {}
if 'attributes' in port_data:
property_map = port_data['attributes']
offset = port_data.get('offset', 0)
upto = port_data.get('upto', False)
if is_bus(port_data['bits'], offset, upto):
end = offset
start = offset + len(port_data['bits']) - 1
if upto:
start, end = end, start
cell.add_bus_port(name=port_name,
direction=direction,
start=start,
end=end,
property_map=property_map)
else:
cell.add_port(name=port_name,
direction=direction,
property_map=property_map)
prim_lib.add_cell(cell)
libraries = {}
libraries[args.library] = prim_lib
# Create the netlist
netlist = LogicalNetlist(name=args.library,
property_map={},
top_instance_name=None,
top_instance=None,
libraries=libraries)
str_list = [s for s in device.strList]
netlist_capnp = netlist.convert_to_capnp(interchange,
indexed_strings=str_list)
# Patch device
device.primLibs = netlist_capnp
if len(device.strList) != len(str_list):
# At least 1 string was added to the list, update the strList.
device.init('strList', len(str_list))
for idx, s in enumerate(str_list):
device.strList[idx] = s
# Save patched device
with open(args.device_out, 'wb') as f:
write_capnp_file(device, f)
def main():
parser = argparse.ArgumentParser(
description="Add timing information to Device")
parser.add_argument("--schema_dir", required=True)
parser.add_argument("--timing_dir", required=True)
parser.add_argument("--family", required=True)
parser.add_argument("device")
parser.add_argument("patched_device")
args = parser.parse_args()
device_schema = get_schema(args.schema_dir, "device")
with open(args.device, 'rb') as f:
dev = read_capnp_file(device_schema, f)
dev = dev.as_builder()
node_model_map, wire_node_map = create_wire_to_node_map(dev)
tileType_wire_name_wire_list_map = create_tile_type_wire_name_to_wire_list(
dev)
string_map = create_string_to_dev_string_map(dev)
tile_name_tileType_map = create_tile_type_name_to_tile_type(dev)
tileType_wires_pip_map = create_tile_type_wire0_wire1_pip_map(dev)
siteName_siteType_map = create_site_name_to_site_type_map(dev)
siteType_name_sitePin_map = create_site_type_name_to_site_pin_map(dev)
tile_type_name_to_number = {}
for i, tileType in enumerate(dev.tileTypeList):
name = dev.strList[tileType.name]
tile_type_name_to_number[name] = i
pip_models = {}
family_map = {"xc7": prjxray_db_reader}
timing_dir = args.timing_dir
timing_reader = family_map[args.family](timing_dir)
timing_data = timing_reader.extract_data()
for tile, _data in timing_data.items():
if tile not in string_map:
continue
tile_name = string_map[tile]
tileType = tile_name_tileType_map[tile_name]
for name, data in _data['wires'].items():
wire_name = string_map[name]
for wire in tileType_wire_name_wire_list_map[(tileType,
wire_name)]:
if wire not in wire_node_map:
continue
node = wire_node_map[wire]
model = node_model_map[node]
res = list(model[0])
cap = list(model[1])
for i in range(len(res)):
res[i] += data[0][i]
for i in range(len(cap)):
cap[i] += data[1][i]
model = (tuple(res), tuple(cap))
node_model_map[node] = model
for old_key, data in _data['pips'].items():
wire0 = string_map[old_key[0]]
wire1 = string_map[old_key[1]]
key = (tileType, wire0, wire1)
if key not in tileType_wires_pip_map:
continue
pip = tileType_wires_pip_map[key]
pip_models[pip] = data
for site, data in _data['sites'].items():
siteType = siteName_siteType_map[string_map[site]]
for sitePin, model in data.items():
sitePin_obj = siteType_name_sitePin_map[(siteType,
string_map[sitePin])]
if model[0][0] is not None and model[0][0] == 'r':
sitePin_obj.model.init('resistance')
corner_model = sitePin_obj.model.resistance
populate_corner_model(corner_model, *model[0][1])
elif model[0][0] is not None and model[0][0] == 'c':
sitePin_obj.model.init('capacitance')
corner_model = sitePin_obj.model.capacitance
populate_corner_model(corner_model, *model[0][1])
sitePin_obj.init('delay')
corner_model = sitePin_obj.delay
populate_corner_model(corner_model, *model[1])
timing_set = set()
for timing in node_model_map.values():
timing_set.add(timing)
timing_dict = {timing: i for i, timing in enumerate(timing_set)}
dev.init("nodeTimings", len(timing_dict))
for model, i in timing_dict.items():
corner_model = dev.nodeTimings[i].resistance
populate_corner_model(corner_model, *model[0])
corner_model = dev.nodeTimings[i].capacitance
populate_corner_model(corner_model, *model[1])
for node, timing in node_model_map.items():
node.nodeTiming = timing_dict[timing]
timing_set = set()
for model in pip_models.values():
timing_set.add(model)
timing_dict = {timing: i for i, timing in enumerate(timing_set)}
dev.init("pipTimings", len(timing_dict))
for model, i in timing_dict.items():
pipTiming = dev.pipTimings[i]
corner_model = pipTiming.inputCapacitance
populate_corner_model(corner_model, *model[0])
corner_model = pipTiming.internalCapacitance
populate_corner_model(corner_model, *model[1])
corner_model = pipTiming.internalDelay
populate_corner_model(corner_model, *model[2])
corner_model = pipTiming.outputResistance
populate_corner_model(corner_model, *model[3])
corner_model = pipTiming.outputCapacitance
populate_corner_model(corner_model, *model[4])
for pip, timing in pip_models.items():
pip.timing = timing_dict[timing]
with open(args.patched_device, "wb") as fp:
write_capnp_file(dev, fp)
parser.add_argument("FAMILY", help="The family of the part")
parser.add_argument("FILE", help="Name of output XDLRC file",
nargs='?', default="")
parser.add_argument("-x", "--extra", help="Generate XDLRC+ file",
action="store_true")
group = parser.add_mutually_exclusive_group()
group.add_argument(
"-t", "--tile", help="Generate XDLRC for a single tile")
group.add_argument("-p", "--prim-defs",
help="Generate XDLRC for Primitive_Defs only", action="store_true")
return parser.parse_args()
if __name__ == "__main__":
args = argparse_setup()
device_schema = Interchange(args.SCHEMA).device_resources_schema.Device
device = XDLRC(read_capnp_file(device_schema, args.DEVICE),
args.FILE, "artix7", "csg324")
if args.tile:
device.generate_tile(args.tile)
device.close_file()
elif args.prim_defs:
device.generate_prim_defs()
device.close_file()
elif args.extra:
device.generate_XDLRC_PLUS()
else:
device.generate_XDLRC()