xilinx/common/utils/prjxray_create_synth_tiles.py

import argparse
import prjxray.db
from prjxray.roi import Roi
import simplejson as json

from prjxray_db_cache import DatabaseCache


def map_tile_to_vpr_coord(conn, tile):
    """ Converts prjxray tile name into VPR tile coordinates.

    It is assumed that this tile should only have one mapped tile.

    """
    c = conn.cursor()
    c.execute("SELECT pkey FROM phy_tile WHERE name = ?;", (tile, ))
    phy_tile_pkey = c.fetchone()[0]

    # Filters NULL tiles to prevent selecting two tiles that point
    # to the same phy_tile
    c.execute(
        """
SELECT tile_map.tile_pkey FROM tile_map INNER JOIN tile
ON tile_map.tile_pkey = tile.pkey INNER JOIN tile_type
ON tile.tile_type_pkey = tile_type.pkey
WHERE tile_map.phy_tile_pkey = ? AND tile_type.name != 'NULL'
    """, (phy_tile_pkey, )
    )
    mapped_tiles = c.fetchall()
    assert len(mapped_tiles) == 1, tile
    tile_pkey = mapped_tiles[0][0]

    c.execute("SELECT grid_x, grid_y FROM tile WHERE pkey = ?", (tile_pkey, ))
    grid_x, grid_y = c.fetchone()

    return grid_x, grid_y


def tile_in_roi(conn, g, roi, tile_pkey):
    """
    Checks if the given tile_pkey is at a location within the specified roi
    """
    c = conn.cursor()
    c.execute(
        """
SELECT name FROM phy_tile WHERE pkey =
(SELECT phy_tile_pkey FROM tile WHERE pkey = ?)
""", (tile_pkey, )
    )
    tile, = c.fetchone()
    loc = g.loc_of_tilename(tile)
    return roi.tile_in_roi(loc)


def wire_in_roi(conn, g, roi, wire_pkey):
    """
    Checks if the given wire_pkey is at a location within the specified roi
    """
    c = conn.cursor()
    c.execute("""
SELECT tile_pkey FROM wire WHERE pkey = ?
""", (wire_pkey, ))
    tile_pkey, = c.fetchone()
    return tile_in_roi(conn, g, roi, tile_pkey)


def wire_manhattan_distance(conn, wire_pkey1, wire_pkey2):
    """
    Determines the manhattan distance between two tiles containing
    the given wire_pkeys
    """
    c = conn.cursor()
    c.execute(
        """
SELECT grid_x, grid_y FROM tile WHERE pkey = (SELECT tile_pkey FROM wire WHERE pkey = ?)
""", (wire_pkey1, )
    )
    x1, y1 = c.fetchone()
    c.execute(
        """
SELECT grid_x, grid_y FROM tile WHERE pkey = (SELECT tile_pkey FROM wire WHERE pkey = ?)
""", (wire_pkey2, )
    )
    x2, y2 = c.fetchone()
    return abs(x1 - x2) + abs(y1 - y2)


def find_wire_from_node(conn, g, roi, node_name, overlay=False):
    """
    Finds a pair on wires in the given node such that:
    1. One wire is inside the roi and the other is outside
    2. The manhattan distance between these the wires is the minimum of any such pair

    Returns the wire from this pair that is outside the roi and the tile the returned
    wire is contained in.
    """
    tile, node = node_name.split('/')

    cur = conn.cursor()
    cur.execute(
        """
SELECT pkey, node_pkey FROM wire WHERE
wire_in_tile_pkey IN (SELECT pkey FROM wire_in_tile WHERE name = ?)
AND
phy_tile_pkey = (SELECT pkey FROM phy_tile WHERE name = ?)
    """, (node, tile)
    )
    results = cur.fetchall()
    assert len(results) == 1
    wire_pkey, node_pkey = results[0]
    cur.execute(
        """
SELECT pkey FROM wire WHERE node_pkey = ?
""", (node_pkey, )
    )
    wire_pkeys = cur.fetchall()
    in_outs = {
        w: (overlay ^ wire_in_roi(conn, g, roi, w))
        for w, in wire_pkeys
    }
    ins = {i for i, v in in_outs.items() if v}
    outs = {i for i, v in in_outs.items() if not v}
    min_manhattan_dist = 1000000
    correct_wire = None
    for i in ins:
        for j in outs:
            d = wire_manhattan_distance(conn, i, j)
            if d < min_manhattan_dist:
                min_manhattan_dist = d
                correct_wire = j

    assert correct_wire is not None, node_name
    cur.execute(
        """
SELECT node_pkey, phy_tile_pkey, wire_in_tile_pkey FROM wire WHERE pkey = ?
""", (correct_wire, )
    )
    node_pkey_correct_wire, phy_tile_pkey, wire_in_tile_pkey = cur.fetchone()
    cur.execute(
        """
SELECT name, tile_type_pkey FROM wire_in_tile WHERE pkey = ?
""", (wire_in_tile_pkey, )
    )
    wire, tile_type_pkey = cur.fetchone()
    cur.execute(
        """
SELECT name FROM tile_type WHERE pkey = ?
""", (tile_type_pkey, )
    )
    tile_type, = cur.fetchone()
    cur.execute(
        """
SELECT name FROM phy_tile WHERE pkey = ?
""", (phy_tile_pkey, )
    )
    tile, = cur.fetchone()
    return tile, wire


def main():
    parser = argparse.ArgumentParser(description="Generate synth_tiles.json")
    parser.add_argument('--db_root', required=True)
    parser.add_argument('--part', required=True)
    parser.add_argument('--roi', required=False)
    parser.add_argument('--overlay', required=False)
    parser.add_argument(
        '--connection_database', help='Connection database', required=True
    )
    parser.add_argument('--synth_tiles', required=True)

    args = parser.parse_args()

    db = prjxray.db.Database(args.db_root, args.part)
    g = db.grid()

    synth_tiles = {}
    synth_tiles['tiles'] = {}

    rois = dict()
    if args.roi:
        with open(args.roi) as f:
            j = json.load(f)

        synth_tiles['info'] = j['info']

        roi = Roi(
            db=db,
            x1=j['info']['GRID_X_MIN'],
            y1=j['info']['GRID_Y_MIN'],
            x2=j['info']['GRID_X_MAX'],
            y2=j['info']['GRID_Y_MAX'],
        )

        rois[roi] = j
    elif args.overlay:
        with open(args.overlay) as f:
            j = json.load(f)

        synth_tiles['info'] = list()

        for r in j:
            roi = Roi(
                db=db,
                x1=r['info']['GRID_X_MIN'],
                y1=r['info']['GRID_Y_MIN'],
                x2=r['info']['GRID_X_MAX'],
                y2=r['info']['GRID_Y_MAX'],
            )

            rois[roi] = r
    else:
        assert False, 'Synth tiles must be for roi or overlay'

    with DatabaseCache(args.connection_database, read_only=True) as conn:
        tile_in_use = set()
        num_synth_tiles = 0

        for roi, j in rois.items():
            if args.overlay:
                synth_tiles['info'].append(j['info'])

            tile_pin_count = dict()
            for port in sorted(sorted(j['ports'], key=lambda i: i['name']),
                               key=lambda i: i['type'], reverse=bool(
                                   args.overlay)):
                if port['type'] == 'out':
                    port_type = 'input' if not args.overlay else 'output'
                    is_clock = False
                elif port['type'] == 'in':
                    is_clock = False
                    port_type = 'output' if not args.overlay else 'input'
                elif port['type'] == 'clk':
                    port_type = 'output' if not args.overlay else 'input'
                    is_clock = True
                else:
                    assert False, port

                if 'wire' not in port:
                    tile, wire = find_wire_from_node(
                        conn, g, roi, port['node'], overlay=bool(args.overlay)
                    )
                else:
                    tile, wire = port['wire'].split('/')

                tile_in_use.add(tile)

                # Make sure connecting wire is not in ROI!
                loc = g.loc_of_tilename(tile)

                if bool(args.overlay) ^ roi.tile_in_roi(loc):
                    # Or if in the ROI, make sure it has no sites.
                    gridinfo = g.gridinfo_at_tilename(tile)
                    assert len(
                        db.get_tile_type(gridinfo.tile_type).get_sites()
                    ) == 0, "{}/{}".format(tile, wire)

                vpr_loc = map_tile_to_vpr_coord(conn, tile)

                if tile not in synth_tiles['tiles']:
                    tile_name = 'SYN-IOPAD-{}'.format(num_synth_tiles)
                    synth_tiles['tiles'][tile] = {
                        'pins': [],
                        'loc': vpr_loc,
                        'tile_name': tile_name,
                        'wires_outside_roi': {},
                    }
                    num_synth_tiles += 1
                    tile_pin_count[tile] = 0

                synth_tiles['tiles'][tile]['pins'].append(
                    {
                        'roi_name':
                            port['name'].replace('[', '_').replace(']', '_'),
                        'wire':
                            wire,
                        'pad':
                            port['pin'],
                        'port_type':
                            port_type,
                        'is_clock':
                            is_clock,
                        'z_loc':
                            tile_pin_count[tile],
                    }
                )

                if 'wires_outside_roi' in port:
                    outside_roi = synth_tiles['tiles'][tile
                                                       ]['wires_outside_roi']

                    for tile_wire in port['wires_outside_roi']:

                        tile_name, wire_name = tile_wire.split('/')
                        if tile_name in outside_roi.keys():
                            outside_roi[tile_name].append(wire_name)
                        else:
                            outside_roi[tile_name] = [wire_name]

                tile_pin_count[tile] += 1

        if not args.overlay:
            # Find two VBRK's in the corner of the fabric to use as the synthetic VCC/
            # GND source.
            vbrk_loc = None
            vbrk_tile = None
            vbrk2_loc = None
            vbrk2_tile = None
            for tile in g.tiles():
                if tile in tile_in_use:
                    continue

                loc = g.loc_of_tilename(tile)
                if not roi.tile_in_roi(loc):
                    continue

                gridinfo = g.gridinfo_at_tilename(tile)
                if 'VBRK' not in gridinfo.tile_type:
                    continue

                assert len(
                    db.get_tile_type(gridinfo.tile_type).get_sites()
                ) == 0, tile

                if vbrk_loc is None:
                    vbrk2_loc = vbrk_loc
                    vbrk2_tile = vbrk_tile
                    vbrk_loc = loc
                    vbrk_tile = tile
                else:
                    if (loc.grid_x < vbrk_loc.grid_x and
                            loc.grid_y < vbrk_loc.grid_y) or vbrk2_loc is None:
                        vbrk2_loc = vbrk_loc
                        vbrk2_tile = vbrk_tile
                        vbrk_loc = loc
                        vbrk_tile = tile

            assert vbrk_loc is not None
            assert vbrk_tile is not None
            assert vbrk_tile not in synth_tiles['tiles']

            vbrk_vpr_loc = map_tile_to_vpr_coord(conn, vbrk_tile)
            synth_tiles['tiles'][vbrk_tile] = {
                'loc':
                    vbrk_vpr_loc,
                'pins':
                    [
                        {
                            'wire': 'VCC',
                            'pad': 'VCC',
                            'port_type': 'VCC',
                            'is_clock': False,
                            'z_loc': '0',
                        },
                    ],
            }

            assert vbrk2_loc is not None
            assert vbrk2_tile is not None
            assert vbrk2_tile not in synth_tiles['tiles']
            vbrk2_vpr_loc = map_tile_to_vpr_coord(conn, vbrk2_tile)
            synth_tiles['tiles'][vbrk2_tile] = {
                'loc':
                    vbrk2_vpr_loc,
                'pins':
                    [
                        {
                            'wire': 'GND',
                            'pad': 'GND',
                            'port_type': 'GND',
                            'is_clock': False,
                            'z_loc': '0',
                        },
                    ],
            }

    with open(args.synth_tiles, 'w') as f:
        json.dump(synth_tiles, f, indent=2)


if __name__ == "__main__":
    main()