| #!/usr/bin/env python3 |
| """ |
| Import the top level tile interconnect information from Project X-Ray database |
| files. |
| |
| The Project X-Ray specifies the connections between tiles and the connect |
| between tiles and their sites. prjxray_tile_import generates a VPR pb_type |
| that has the correct tile pin names to connect to the routing fabric, and |
| connects those tile pins to each site within the tile. |
| |
| """ |
| |
| from __future__ import print_function |
| import argparse |
| import os |
| import sys |
| import prjxray.db |
| import prjxray.site_type |
| import os.path |
| import simplejson as json |
| import re |
| import sqlite3 |
| |
| import lxml.etree as ET |
| from lib.pb_type_xml import ( |
| start_pb_type, start_tile, add_vpr_tile_prefix, add_tile_direct, |
| object_ref, add_switchblock_locations, write_xml, ModelXml, add_direct, |
| XI_INCLUDE, XI_URL |
| ) |
| |
| |
| def find_port(pin_name, ports): |
| if pin_name in ports: |
| return { |
| 'pin_name': pin_name, |
| 'pin_idx': None, |
| } |
| |
| # Find trailing digits, which are assumed to be pin indicies, example: |
| # ADDRARDADDR13 |
| m = re.search('([0-9]+)$', pin_name) |
| if m is None: |
| return None |
| |
| prefix = pin_name[:-len(m.group(1))] |
| prefix_pin_idx = int(m.group(1)) |
| |
| if prefix in ports and prefix_pin_idx < ports[prefix]: |
| return { |
| 'pin_name': prefix, |
| 'pin_idx': prefix_pin_idx, |
| } |
| else: |
| return None |
| |
| |
| def parse_site_type_instance(site_types): |
| """ Convert site_types argument into map. |
| |
| Parameters |
| ---------- |
| site_types : str |
| |
| Returns |
| ------- |
| site_type_instances : map of str to list of str |
| Maps site type to array of site type instances. First instance of |
| site should use first element, second instance should use second |
| element, etc. |
| |
| """ |
| site_type_instances = {} |
| for s in site_types.split(','): |
| site_type, site_type_instance = s.split('/') |
| |
| if site_type not in site_type_instances: |
| site_type_instances[site_type] = [] |
| |
| site_type_instances[site_type].append(site_type_instance) |
| |
| return site_type_instances |
| |
| |
| def expand_nodes_in_tile_type(conn, tile_type_pkey): |
| cur = conn.cursor() |
| cur.execute( |
| """ |
| CREATE TEMP TABLE phy_tiles AS |
| SELECT tile_map.phy_tile_pkey |
| FROM tile_map |
| INNER JOIN phy_tile |
| ON phy_tile.pkey = tile_map.phy_tile_pkey |
| WHERE tile_map.tile_pkey IN ( |
| SELECT pkey FROM tile WHERE tile_type_pkey = ? |
| ) |
| GROUP BY phy_tile.tile_type_pkey;""", (tile_type_pkey, ) |
| ) |
| |
| # Set of node pkeys to expand |
| cur.execute( |
| """ |
| SELECT DISTINCT node_pkey |
| FROM wire |
| WHERE phy_tile_pkey IN (SELECT phy_tile_pkey FROM phy_tiles);""" |
| ) |
| nodes_to_expand = set(node_pkey for (node_pkey, ) in cur) |
| |
| nodes_to_set = {} |
| |
| while len(nodes_to_expand) > 0: |
| node_pkey = nodes_to_expand.pop() |
| |
| node_set = nodes_to_set.get(node_pkey, set((node_pkey, ))) |
| nodes_to_set[node_pkey] = node_set |
| |
| cur.execute( |
| """ |
| WITH |
| other_wires(phy_tile_pkey, pip_in_tile_pkey, other_wire_in_tile_pkey) AS ( |
| SELECT |
| wire.phy_tile_pkey, |
| undirected_pips.pip_in_tile_pkey, |
| undirected_pips.other_wire_in_tile_pkey |
| FROM undirected_pips |
| INNER JOIN wire |
| ON wire.wire_in_tile_pkey = undirected_pips.wire_in_tile_pkey |
| INNER JOIN pip_in_tile |
| ON pip_in_tile.pkey = undirected_pips.pip_in_tile_pkey |
| WHERE |
| wire.node_pkey = ? |
| AND |
| NOT pip_in_tile.is_pseudo |
| ) |
| SELECT wire.node_pkey |
| FROM wire |
| INNER JOIN other_wires |
| ON |
| wire.wire_in_tile_pkey = other_wires.other_wire_in_tile_pkey |
| AND |
| wire.phy_tile_pkey = other_wires.phy_tile_pkey |
| WHERE |
| wire.phy_tile_pkey IN (SELECT phy_tile_pkey FROM phy_tiles);""", |
| (node_pkey, ) |
| ) |
| |
| # Update node sets |
| for (other_node_pkey, ) in cur: |
| node_set |= nodes_to_set.get( |
| other_node_pkey, set((other_node_pkey, )) |
| ) |
| |
| # Merge node sets |
| for node_pkey in node_set: |
| nodes_to_set[node_pkey] = node_set |
| |
| unique_node_sets = {} |
| for node_set in nodes_to_set.values(): |
| if id(node_set) not in unique_node_sets: |
| unique_node_sets[id(node_set)] = node_set |
| |
| if False: |
| # Print node sets for debugging and inspection. |
| for node_set in unique_node_sets.values(): |
| print() |
| print(id(node_set), len(node_set)) |
| for node_pkey in node_set: |
| cur.execute( |
| """ |
| SELECT name |
| FROM wire_in_tile |
| WHERE pkey IN ( |
| SELECT wire.wire_in_tile_pkey |
| FROM wire |
| WHERE node_pkey = ? |
| )""", (node_pkey, ) |
| ) |
| print(node_pkey, ' '.join(name for (name, ) in cur)) |
| |
| cur.execute("""DROP TABLE phy_tiles""") |
| |
| return unique_node_sets.values() |
| |
| |
| def find_connections(conn, input_wires, output_wires, tile_type_pkey): |
| """ Remove top-level ports only connected to internal sources and generates |
| tile internal connections.""" |
| |
| # Create connected node sets |
| node_sets = list(expand_nodes_in_tile_type(conn, tile_type_pkey)) |
| |
| # Number of site external connections for ports |
| is_top_level_pin_external = {} |
| for wire in input_wires: |
| is_top_level_pin_external[wire] = False |
| |
| for wire in output_wires: |
| is_top_level_pin_external[wire] = False |
| |
| internal_connections = {} |
| top_level_connections = {} |
| |
| wire_to_site_pin = {} |
| |
| cur = conn.cursor() |
| for node_set in node_sets: |
| ipin_count = 0 |
| opin_count = 0 |
| node_set_has_external = False |
| |
| pins_used_in_node_sets = set() |
| input_pins = set() |
| output_pins = set() |
| |
| for node_pkey in node_set: |
| cur.execute( |
| """ |
| SELECT |
| tile.tile_type_pkey, |
| wire_in_tile.name, |
| site_type.name, |
| site_pin.name, |
| site_pin.direction, |
| count() |
| FROM wire |
| INNER JOIN wire_in_tile |
| ON wire.wire_in_tile_pkey = wire_in_tile.pkey |
| INNER JOIN site_pin |
| ON site_pin.pkey = wire_in_tile.site_pin_pkey |
| INNER JOIN tile |
| ON wire.tile_pkey = tile.pkey |
| INNER JOIN site_type |
| ON site_type.pkey = site_pin.site_type_pkey |
| WHERE |
| wire.node_pkey = ? |
| AND |
| wire_in_tile.site_pin_pkey IS NOT NULL |
| GROUP BY site_pin.direction; |
| """, (node_pkey, ) |
| ) |
| for (wire_tile_type_pkey, wire_name, site_type_name, site_pin_name, |
| direction, count) in cur: |
| if wire_tile_type_pkey == tile_type_pkey: |
| value = (site_type_name, site_pin_name) |
| if wire_name in wire_to_site_pin: |
| assert value == wire_to_site_pin[wire_name], ( |
| wire_name, value, wire_to_site_pin[wire_name] |
| ) |
| else: |
| wire_to_site_pin[wire_name] = value |
| |
| pins_used_in_node_sets.add(wire_name) |
| direction = prjxray.site_type.SitePinDirection(direction) |
| |
| if direction == prjxray.site_type.SitePinDirection.IN: |
| output_pins.add(wire_name) |
| opin_count += count |
| elif direction == prjxray.site_type.SitePinDirection.OUT: |
| input_pins.add(wire_name) |
| ipin_count += count |
| else: |
| assert False, (node_pkey, direction) |
| else: |
| node_set_has_external = True |
| |
| assert len(input_pins) in [0, 1], input_pins |
| |
| if ipin_count == 0 or opin_count == 0 or node_set_has_external: |
| # This node set is connected externally, mark as such |
| for wire_name in pins_used_in_node_sets: |
| is_top_level_pin_external[wire_name] = True |
| |
| if ipin_count > 0 and opin_count > 0: |
| # TODO: Add check that pips and site pins on these internal |
| # connections are 0 delay. |
| assert len(input_pins) == 1 |
| input_wire = input_pins.pop() |
| |
| for wire_name in output_pins: |
| if wire_name in internal_connections: |
| assert input_wire == internal_connections[wire_name] |
| else: |
| internal_connections[wire_name] = input_wire |
| |
| for wire in sorted(is_top_level_pin_external): |
| if not is_top_level_pin_external[wire]: |
| if wire in input_wires: |
| input_wires.remove(wire) |
| elif wire in output_wires: |
| output_wires.remove(wire) |
| else: |
| assert False, wire |
| else: |
| top_level_connections[wire] = wire_to_site_pin[wire] |
| |
| output_internal_connections = {} |
| for output_wire in internal_connections: |
| output_internal_connections[wire_to_site_pin[output_wire]] = \ |
| wire_to_site_pin[internal_connections[output_wire]] |
| |
| return top_level_connections, output_internal_connections |
| |
| |
| NORMALIZED_TILE_TYPES = { |
| "RIOI3": "IOI3_TILE", |
| "RIOI3_SING": "IOI3_TILE", |
| "RIOI3_TBYTESRC": "IOI3_TILE", |
| "RIOI3_TBYTETERM": "IOI3_TILE", |
| "LIOI3": "IOI3_TILE", |
| "LIOI3_SING": "IOI3_TILE", |
| "LIOI3_TBYTESRC": "IOI3_TILE", |
| "LIOI3_TBYTETERM": "IOI3_TILE", |
| "LIOB33": "IOB_TILE", |
| "LIOB33_SING": "IOB_TILE", |
| "RIOB33": "IOB_TILE", |
| "RIOB33_SING": "IOB_TILE", |
| "CMT_TOP_R_UPPER_T": "CMT_TOP_UPPER_T", |
| "CMT_TOP_L_UPPER_T": "CMT_TOP_UPPER_T", |
| } |
| |
| NORMALIZED_SITE_TYPES = { |
| "IOB33M": "IOB", |
| "IOB33S": "IOB", |
| "IOB33": "IOB", |
| "ILOGICE3": "ILOGIC", |
| "OLOGICE3": "OLOGIC", |
| "IDELAYE2": "IDELAY", |
| } |
| |
| |
| def get_tile_prefixes(conn, tile_type_pkeys, site_types, site_remap): |
| cur = conn.cursor() |
| |
| tile_prefixes = {} |
| |
| for tile_type_pkey in tile_type_pkeys: |
| cur.execute( |
| """ |
| SELECT |
| DISTINCT tile_type.name, site_type.pkey, site_type.name |
| FROM |
| wire_in_tile |
| INNER JOIN tile_type ON tile_type.pkey = wire_in_tile.phy_tile_type_pkey |
| INNER JOIN site ON site.pkey = wire_in_tile.site_pkey |
| INNER JOIN site_type ON site_type.pkey = site.site_type_pkey |
| WHERE |
| wire_in_tile.tile_type_pkey = ? |
| AND site_pin_pkey IS NOT NULL; |
| """, (tile_type_pkey, ) |
| ) |
| for tile_type_name, site_type_pkey, site_type_name in cur: |
| norm_tile = NORMALIZED_TILE_TYPES.get( |
| tile_type_name, tile_type_name |
| ) |
| if site_type_pkey not in site_types: |
| new_site_type_pkey = site_remap[site_type_pkey] |
| assert new_site_type_pkey in site_types |
| site_type_pkey = new_site_type_pkey |
| |
| norm_site = NORMALIZED_SITE_TYPES.get( |
| site_type_name, site_type_name |
| ) |
| |
| prefix = '{' + norm_tile + '}.{' + norm_site + '}' |
| |
| if site_type_pkey in tile_prefixes: |
| assert prefix == tile_prefixes[site_type_pkey], ( |
| prefix, tile_prefixes[site_type_pkey] |
| ) |
| else: |
| tile_prefixes[site_type_pkey] = prefix |
| |
| return tile_prefixes |
| |
| |
| def sites_in_tile_type(conn, tile_type_pkey): |
| cur = conn.cursor() |
| |
| # Find instances of sites, sorted by their original tile type. |
| # Then choice the first of each site type as the wire set. |
| # This ensures a unique and internally consistent site set for analyzing |
| # connectivity. |
| # |
| # Note: This does assume that only one instance of each site is present |
| # in each tile, which is checked. |
| sites = {} |
| sites_in_tiles = set() |
| cur.execute( |
| """ |
| SELECT |
| site.site_type_pkey, wire_in_tile.site_pkey, wire_in_tile.phy_tile_type_pkey |
| FROM wire_in_tile |
| INNER JOIN site |
| ON site.pkey = wire_in_tile.site_pkey |
| WHERE |
| wire_in_tile.tile_type_pkey = ? |
| GROUP BY site.site_type_pkey, wire_in_tile.phy_tile_type_pkey |
| ORDER BY wire_in_tile.phy_tile_type_pkey;""", (tile_type_pkey, ) |
| ) |
| for site_type_pkey, site_pkey, phy_tile_type_pkey in cur: |
| if site_type_pkey not in sites: |
| sites[site_type_pkey] = site_pkey |
| |
| # Verify that assumption that each site type is only used once per tile |
| # is true. |
| key = (site_type_pkey, phy_tile_type_pkey) |
| assert key not in sites_in_tiles, key |
| sites_in_tiles.add(key) |
| |
| return sites, sites_in_tiles |
| |
| |
| def yield_mapped_site_sets(site_remaps, site_type_pkeys): |
| yield frozenset( |
| site_remaps.get(site_type_pkey, site_type_pkey) |
| for site_type_pkey in site_type_pkeys |
| ) |
| |
| |
| def check_site_equiv(conn, general_site_type_pkey, specific_site_type_pkey): |
| """ Verify assumption that site pin names on specific site are subset of general site. |
| |
| E.g. every pin on the specific site should be present on the generic site. |
| |
| """ |
| cur = conn.cursor() |
| |
| cur.execute( |
| "SELECT name FROM site_pin WHERE site_type_pkey = ?", |
| (general_site_type_pkey, ) |
| ) |
| general_site_pins = set(name for (name, ) in cur) |
| |
| cur.execute( |
| "SELECT name FROM site_pin WHERE site_type_pkey = ?", |
| (specific_site_type_pkey, ) |
| ) |
| for (name, ) in cur: |
| assert name in general_site_pins, ( |
| general_site_pins, name, specific_site_type_pkey |
| ) |
| |
| |
| def create_pb_type( |
| conn, pin_assignments, site_directory, output_directory, pb_type, |
| site_type_pkeys, tile_type_pkeys, site_remaps, site_name_remaps, |
| node_tile_map |
| ): |
| cur = conn.cursor() |
| cur2 = conn.cursor() |
| |
| wire_to_site_pin = {} |
| internal_connections = {} |
| top_level_pin_external = set() |
| top_level_wire_external = set() |
| |
| all_pb_type_input_pins = None |
| all_pb_type_output_pins = None |
| |
| for tile_type_pkey in tile_type_pkeys: |
| pb_type_input_pins = set() |
| pb_type_output_pins = set() |
| |
| for node_set in node_tile_map[tile_type_pkey]: |
| ipin_count = 0 |
| opin_count = 0 |
| node_set_has_external = False |
| |
| pins_used_in_node_sets = set() |
| input_pins = set() |
| output_pins = set() |
| |
| for node_pkey in node_set: |
| cur.execute( |
| """ |
| SELECT |
| tile.tile_type_pkey, |
| wire_in_tile.name, |
| site_type.pkey, |
| site_type.name, |
| site_pin.name, |
| site_pin.direction, |
| count() |
| FROM wire |
| INNER JOIN wire_in_tile |
| ON wire.wire_in_tile_pkey = wire_in_tile.pkey |
| INNER JOIN site_pin |
| ON site_pin.pkey = wire_in_tile.site_pin_pkey |
| INNER JOIN tile |
| ON wire.tile_pkey = tile.pkey |
| INNER JOIN site_type |
| ON site_type.pkey = site_pin.site_type_pkey |
| WHERE |
| wire.node_pkey = ? |
| AND |
| wire_in_tile.site_pin_pkey IS NOT NULL |
| GROUP BY site_pin.direction; |
| """, (node_pkey, ) |
| ) |
| for (wire_tile_type_pkey, wire_name, site_type_pkey, |
| site_type_name, site_pin_name, direction, count) in cur: |
| |
| if wire_tile_type_pkey == tile_type_pkey: |
| if site_type_pkey not in site_type_pkeys: |
| # Remap if a mapping exists |
| site_type_name = site_name_remaps.get( |
| site_type_name, site_type_name |
| ) |
| cur2.execute( |
| "SELECT pkey FROM site_type WHERE name = ?", |
| (site_type_name, ) |
| ) |
| new_site_type_pkey = cur2.fetchone()[0] |
| assert new_site_type_pkey in site_type_pkeys, ( |
| pb_type, tile_type_pkey, node_pkey, |
| site_type_pkey, new_site_type_pkey, |
| site_type_pkeys, site_type_name |
| ) |
| |
| direction = prjxray.site_type.SitePinDirection( |
| direction |
| ) |
| value = (site_type_name, site_pin_name, direction) |
| if wire_name in wire_to_site_pin: |
| assert value == wire_to_site_pin[wire_name], ( |
| wire_name, value, wire_to_site_pin[wire_name] |
| ) |
| else: |
| wire_to_site_pin[wire_name] = value |
| |
| pins_used_in_node_sets.add( |
| (wire_name, site_type_name, site_pin_name) |
| ) |
| |
| if direction == prjxray.site_type.SitePinDirection.IN: |
| output_pins.add(wire_name) |
| pb_type_output_pins.add( |
| (site_type_name, site_pin_name) |
| ) |
| opin_count += count |
| elif direction == prjxray.site_type.SitePinDirection.OUT: |
| input_pins.add(wire_name) |
| pb_type_input_pins.add( |
| (site_type_name, site_pin_name) |
| ) |
| ipin_count += count |
| else: |
| assert False, (node_pkey, direction) |
| else: |
| node_set_has_external = True |
| |
| assert len(input_pins) in [0, 1], input_pins |
| |
| if ipin_count == 0 or opin_count == 0 or node_set_has_external or len( |
| site_type_pkeys) == 1: |
| # This node set is connected externally, mark as such |
| for wire_name, site_type_name, site_pin_name in pins_used_in_node_sets: |
| top_level_wire_external.add(wire_name) |
| top_level_pin_external.add((site_type_name, site_pin_name)) |
| |
| if len(site_type_pkeys) == 1: |
| continue |
| |
| if ipin_count > 0 and opin_count > 0: |
| # TODO: Add check that pips and site pins on these internal |
| # connections are 0 delay. |
| assert len(input_pins) == 1 |
| input_wire = input_pins.pop() |
| |
| for wire_name in output_pins: |
| k = wire_to_site_pin[wire_name] |
| v = wire_to_site_pin[input_wire] |
| if k in internal_connections: |
| assert v == internal_connections[k], ( |
| v, internal_connections[k] |
| ) |
| else: |
| internal_connections[k] = v |
| |
| pb_type_input_pins = set( |
| v for v in pb_type_input_pins if v in top_level_pin_external |
| ) |
| pb_type_output_pins = set( |
| v for v in pb_type_output_pins if v in top_level_pin_external |
| ) |
| |
| if all_pb_type_input_pins is None: |
| all_pb_type_input_pins = pb_type_input_pins |
| all_pb_type_output_pins = pb_type_output_pins |
| else: |
| all_pb_type_input_pins &= pb_type_input_pins |
| all_pb_type_output_pins &= pb_type_output_pins |
| |
| ########################################################################## |
| # Generate the model.xml file # |
| ########################################################################## |
| model = ModelXml( |
| f=os.path.join( |
| output_directory, pb_type.lower(), |
| '{}.model.xml'.format(pb_type.lower()) |
| ), |
| site_directory=site_directory |
| ) |
| |
| for site_type_pkey in site_type_pkeys: |
| cur.execute( |
| "SELECT name FROM site_type WHERE pkey = ?", (site_type_pkey, ) |
| ) |
| site_type = cur.fetchone()[0] |
| model.add_model_include(site_type, site_type) |
| model.write_model() |
| |
| ########################################################################## |
| # Generate the pb_type.xml file # |
| ########################################################################## |
| |
| pb_type_xml = start_pb_type( |
| pb_type, |
| pin_assignments, |
| ['{}_{}'.format(site, pin) for site, pin in all_pb_type_output_pins], |
| ['{}_{}'.format(site, pin) for site, pin in all_pb_type_input_pins], |
| ) |
| |
| interconnect_xml = ET.Element('interconnect') |
| |
| site_pbtype = site_directory + "/{0}/{1}.pb_type.xml" |
| |
| site_prefixes = get_tile_prefixes( |
| conn, tile_type_pkeys, site_type_pkeys, site_remaps |
| ) |
| |
| cell_names = {} |
| site_type_ports = {} |
| |
| for site_type_pkey in site_type_pkeys: |
| cur.execute( |
| "SELECT name FROM site_type WHERE pkey = ?", (site_type_pkey, ) |
| ) |
| site_type = cur.fetchone()[0] |
| site_prefix = site_prefixes[site_type_pkey] |
| site_type_path = site_pbtype.format( |
| site_type.lower(), site_type.lower() |
| ) |
| |
| cell_pb_type = ET.ElementTree() |
| root_element = cell_pb_type.parse(site_type_path) |
| cell_names[site_type] = root_element.attrib['name'] |
| |
| ports = {} |
| for inputs in root_element.iter('input'): |
| ports[inputs.attrib['name']] = int(inputs.attrib['num_pins']) |
| |
| for clocks in root_element.iter('clock'): |
| ports[clocks.attrib['name']] = int(clocks.attrib['num_pins']) |
| |
| for outputs in root_element.iter('output'): |
| ports[outputs.attrib['name']] = int(outputs.attrib['num_pins']) |
| |
| assert site_type not in site_type_ports, ( |
| site_type, site_type_ports.keys() |
| ) |
| site_type_ports[site_type] = ports |
| |
| attrib = dict(root_element.attrib) |
| include_xml = ET.SubElement(pb_type_xml, 'pb_type', attrib) |
| ET.SubElement( |
| include_xml, XI_INCLUDE, { |
| 'href': |
| site_type_path, |
| 'xpointer': |
| "xpointer(pb_type/child::node()[local-name()!='metadata'])", |
| } |
| ) |
| |
| metadata_xml = ET.SubElement(include_xml, 'metadata') |
| if len(site_type_pkeys) > 1: |
| ET.SubElement( |
| metadata_xml, 'meta', { |
| 'name': 'fasm_prefix', |
| } |
| ).text = site_prefix |
| |
| # Import pb_type metadata if it exists. |
| if any(child.tag == 'metadata' for child in root_element): |
| ET.SubElement( |
| metadata_xml, XI_INCLUDE, { |
| 'href': site_type_path, |
| 'xpointer': "xpointer(pb_type/metadata/child::node())", |
| } |
| ) |
| |
| for site_type, site_pin_name in top_level_pin_external: |
| port = find_port(site_pin_name, site_type_ports[site_type]) |
| if port is None: |
| print( |
| "*** WARNING *** Didn't find port for name {} for site type {}" |
| .format(site_pin_name, site_type), |
| file=sys.stderr |
| ) |
| continue |
| |
| site_name = cell_names[site_type] |
| is_input = (site_type, site_pin_name) in all_pb_type_input_pins |
| is_output = (site_type, site_pin_name) in all_pb_type_output_pins |
| |
| if not is_input and not is_output: |
| continue |
| |
| if is_input: |
| add_direct( |
| interconnect_xml, |
| input=object_ref(site_name, **port), |
| output=object_ref( |
| add_vpr_tile_prefix(pb_type), |
| '{}_{}'.format(site_type, site_pin_name), |
| ), |
| ) |
| |
| for site_type, site_pin_name in top_level_pin_external: |
| port = find_port(site_pin_name, site_type_ports[site_type]) |
| if port is None: |
| continue |
| |
| site_name = cell_names[site_type] |
| is_input = (site_type, site_pin_name) in all_pb_type_input_pins |
| is_output = (site_type, site_pin_name) in all_pb_type_output_pins |
| |
| if not is_input and not is_output: |
| continue |
| |
| if is_output: |
| add_direct( |
| interconnect_xml, |
| input=object_ref( |
| add_vpr_tile_prefix(pb_type), |
| '{}_{}'.format(site_type, site_pin_name) |
| ), |
| output=object_ref(site_name, **port), |
| ) |
| |
| for (dest_site_type, dest_site_pin_name, _), (src_site_type, src_site_pin_name, _) in \ |
| sorted(internal_connections.items(), key=lambda x: (x[1], x[0])): |
| src_port = find_port(src_site_pin_name, site_type_ports[src_site_type]) |
| src_site_name = cell_names[src_site_type] |
| if src_port is None: |
| print( |
| "*** WARNING *** Didn't find port for name {} for site type {}" |
| .format(src_site_pin_name, src_site_type), |
| file=sys.stderr |
| ) |
| continue |
| |
| dest_port = find_port( |
| dest_site_pin_name, site_type_ports[dest_site_type] |
| ) |
| dest_site_name = cell_names[dest_site_type] |
| if dest_port is None: |
| print( |
| "*** WARNING *** Didn't find port for name {} for site type {}" |
| .format(dest_site_pin_name, dest_site_type), |
| file=sys.stderr |
| ) |
| continue |
| |
| add_direct( |
| interconnect_xml, |
| input=object_ref(src_site_name, **src_port), |
| output=object_ref(dest_site_name, **dest_port), |
| ) |
| |
| pb_type_xml.append(interconnect_xml) |
| |
| write_xml( |
| os.path.join( |
| output_directory, pb_type.lower(), |
| '{}.pb_type.xml'.format(pb_type.lower()) |
| ), pb_type_xml |
| ) |
| |
| top_level_connections = {} |
| for wire in sorted(top_level_wire_external): |
| site_type, site_pin_name, _ = wire_to_site_pin[wire] |
| is_input = (site_type, site_pin_name) in all_pb_type_input_pins |
| is_output = (site_type, site_pin_name) in all_pb_type_output_pins |
| |
| if not is_input and not is_output: |
| continue |
| |
| top_level_connections[wire] = wire_to_site_pin[wire] |
| |
| return top_level_connections |
| |
| |
| def create_tile( |
| conn, tile_type, tile_type_pkey, tile_connections, pb_types, |
| pin_assignments, output_directory |
| ): |
| cur = conn.cursor() |
| |
| input_wires = set() |
| output_wires = set() |
| |
| cur.execute( |
| """ |
| SELECT DISTINCT wire_in_tile.name |
| FROM wire_in_tile |
| WHERE |
| wire_in_tile.tile_type_pkey = ? |
| AND |
| wire_in_tile.site_pin_pkey IS NOT NULL; |
| """, (tile_type_pkey, ) |
| ) |
| for (wire_name, ) in cur: |
| for pb_type in pb_types: |
| if wire_name in tile_connections[pb_type]: |
| site_type_name, site_pin_name, direction = tile_connections[ |
| pb_type][wire_name] |
| |
| if direction == prjxray.site_type.SitePinDirection.IN: |
| input_wires.add(wire_name) |
| elif direction == prjxray.site_type.SitePinDirection.OUT: |
| output_wires.add(wire_name) |
| else: |
| assert False, (wire_name, direction) |
| |
| tile_xml = start_tile( |
| tile_type, |
| pin_assignments, |
| input_wires, |
| output_wires, |
| ) |
| |
| equivalent_sites_xml = ET.Element('equivalent_sites') |
| |
| for pb_type in pb_types: |
| site_xml = ET.Element( |
| 'site', { |
| 'pb_type': add_vpr_tile_prefix(pb_type), |
| 'pin_mapping': 'custom' |
| } |
| ) |
| equivalent_sites_xml.append(site_xml) |
| |
| for wire_name in input_wires | output_wires: |
| if wire_name in tile_connections[pb_type]: |
| site_type_name, site_pin_name, direction = tile_connections[ |
| pb_type][wire_name] |
| add_tile_direct( |
| site_xml, |
| tile=object_ref( |
| add_vpr_tile_prefix(tile_type), |
| wire_name, |
| ), |
| pb_type=object_ref( |
| add_vpr_tile_prefix(pb_type), |
| '{}_{}'.format(site_type_name, site_pin_name) |
| ), |
| ) |
| |
| sub_tile_xml = tile_xml.find('./sub_tile') |
| |
| sub_tile_xml.append(equivalent_sites_xml) |
| |
| add_switchblock_locations(tile_xml) |
| |
| write_xml( |
| os.path.join( |
| output_directory, tile_type.lower(), |
| '{}.tile.xml'.format(tile_type.lower()) |
| ), tile_xml |
| ) |
| |
| |
| def main(): |
| parser = argparse.ArgumentParser( |
| description=__doc__, fromfile_prefix_chars='@', prefix_chars='-~' |
| ) |
| |
| parser.add_argument( |
| '--site_directory', |
| required=True, |
| help="""Diretory where sites are defined""" |
| ) |
| |
| parser.add_argument( |
| '--output_directory', |
| required=True, |
| help="Directory to write output XML too.", |
| ) |
| |
| parser.add_argument( |
| '--pin_assignments', |
| required=True, |
| ) |
| |
| parser.add_argument( |
| '--connection_database', |
| required=True, |
| help=( |
| "Location of connection database to define this tile type. " + |
| "The tile will be defined by the sites and wires from the " + |
| "connection database in lue of Project X-Ray." |
| ) |
| ) |
| |
| parser.add_argument( |
| '--tile_types', |
| required=True, |
| help="Comma seperated list of tiles to create equivilance between." |
| ) |
| |
| parser.add_argument('--pb_types', nargs='+', required=True, help="") |
| |
| parser.add_argument( |
| '--site_equivilances', |
| help="Comma seperated list of site equivilances to apply." |
| ) |
| |
| args = parser.parse_args() |
| |
| with open(args.pin_assignments) as f: |
| pin_assignments = json.load(f) |
| |
| ET.register_namespace('xi', XI_URL) |
| with sqlite3.connect("file:{}?mode=ro".format(args.connection_database), |
| uri=True) as conn: |
| |
| cur = conn.cursor() |
| tile_types = {} |
| node_tile_map = {} |
| sites = {} |
| sites_in_tiles = {} |
| |
| pb_types = {} |
| |
| site_remaps = {} |
| site_name_remaps = {} |
| |
| if args.site_equivilances is not None: |
| for site_remap in args.site_equivilances.split(','): |
| general_site, specific_site = site_remap.split('=') |
| assert general_site not in site_name_remaps, general_site |
| site_name_remaps[general_site] = specific_site |
| |
| cur.execute( |
| "SELECT pkey FROM site_type WHERE name = ?", |
| (general_site, ) |
| ) |
| general_site_type_pkey = cur.fetchone()[0] |
| |
| cur.execute( |
| "SELECT pkey FROM site_type WHERE name = ?", |
| (specific_site, ) |
| ) |
| specific_site_type_pkey = cur.fetchone()[0] |
| |
| site_remaps[general_site_type_pkey] = specific_site_type_pkey |
| |
| check_site_equiv( |
| conn, general_site_type_pkey, specific_site_type_pkey |
| ) |
| |
| site_collections_to_pb_type = {} |
| |
| for pb_type_def_string in args.pb_types: |
| pb_type_name, pb_type_sites = pb_type_def_string.split('=') |
| pb_type_sites = pb_type_sites.split(',') |
| |
| assert pb_type_name not in pb_types, pb_type_name |
| pb_types[pb_type_name] = [] |
| |
| for site in pb_type_sites: |
| cur.execute( |
| "SELECT pkey FROM site_type WHERE name = ?", (site, ) |
| ) |
| result = cur.fetchone() |
| assert result is not None, site |
| site_type_pkey = result[0] |
| pb_types[pb_type_name].append(site_type_pkey) |
| |
| pb_types[pb_type_name] = frozenset(pb_types[pb_type_name]) |
| |
| assert pb_types[pb_type_name] not in site_collections_to_pb_type, ( |
| pb_type_name, pb_types[pb_type_name] |
| ) |
| |
| site_collections_to_pb_type[pb_types[pb_type_name]] = pb_type_name |
| |
| pb_types_in_tile = {} |
| |
| tiles_that_instance_pb_type = {} |
| |
| for tile_type in args.tile_types.split(','): |
| cur.execute( |
| "SELECT pkey FROM tile_type WHERE name = ?", (tile_type, ) |
| ) |
| tile_type_pkey = cur.fetchone()[0] |
| tile_types[tile_type] = tile_type_pkey |
| node_tile_map[tile_type_pkey] = expand_nodes_in_tile_type( |
| conn, tile_type_pkey |
| ) |
| sites[tile_type_pkey], sites_in_tiles[ |
| tile_type_pkey] = sites_in_tile_type(conn, tile_type_pkey) |
| |
| seen_sets = set() |
| site_type_pkeys = frozenset(sites[tile_type_pkey].keys()) |
| seen_sets.add(site_type_pkeys) |
| |
| pb_types_in_tile[tile_type_pkey] = [ |
| site_collections_to_pb_type[site_type_pkeys] |
| ] |
| |
| for site_set in yield_mapped_site_sets(site_remaps, |
| site_type_pkeys): |
| if site_set in seen_sets: |
| continue |
| |
| pb_types_in_tile[tile_type_pkey].append( |
| site_collections_to_pb_type[site_set] |
| ) |
| |
| for pb_type in pb_types_in_tile[tile_type_pkey]: |
| if pb_type not in tiles_that_instance_pb_type: |
| tiles_that_instance_pb_type[pb_type] = [] |
| |
| tiles_that_instance_pb_type[pb_type].append(tile_type_pkey) |
| |
| tile_connections = {} |
| |
| for pb_type in tiles_that_instance_pb_type: |
| tile_connections[pb_type] = create_pb_type( |
| conn=conn, |
| pin_assignments=pin_assignments, |
| site_directory=args.site_directory, |
| output_directory=args.output_directory, |
| pb_type=pb_type, |
| site_type_pkeys=pb_types[pb_type], |
| tile_type_pkeys=tiles_that_instance_pb_type[pb_type], |
| site_remaps=site_remaps, |
| site_name_remaps=site_name_remaps, |
| node_tile_map=node_tile_map |
| ) |
| |
| for tile_type in tile_types: |
| tile_type_pkey = tile_types[tile_type] |
| create_tile( |
| conn=conn, |
| tile_type=tile_type, |
| tile_type_pkey=tile_type_pkey, |
| tile_connections=tile_connections, |
| pb_types=pb_types_in_tile[tile_type_pkey], |
| output_directory=args.output_directory, |
| pin_assignments=pin_assignments, |
| ) |
| |
| |
| if __name__ == '__main__': |
| main() |
