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()