Google Git Google Git
Sign in
foss-fpga-tools/symbiflow-arch-defs/659bb9015294eca1e79d43ba13076b5c573ebcfd/./xc/common/utils/prjxray_form_channels.py
blob: c18441078cd9e505b5d02e88333829e45353ba6f [file]
#!/usr/bin/env python3
""" Classify 7-series nodes and generate channels for required nodes.
Rough structure:
Create initial database import by importing tile types, tile wires, tile pips,
site types and site pins. After importing tile types, imports the grid of
tiles. This uses tilegrid.json, tile_type_*.json and site_type_*.json.
Once all tiles are imported, all wires in the grid are added and nodes are
formed from the sea of wires based on the tile connections description
(tileconn.json).
In order to determine what each node is used for, site pins and pips are counted
on each node (count_sites_and_pips_on_nodes). Depending on the site pin and
pip count, the nodes are classified into one of 4 buckets:
NULL - An unconnected node
CHANNEL - A routing node
EDGE_WITH_MUX - An edge between an IPIN and OPIN.
EDGES_TO_CHANNEL - An edge between an IPIN/OPIN and a CHANNEL.
Then all CHANNEL are grouped into tracks (form_tracks) and graph nodes are
created for the CHANNELs. Graph edges are added to connect graph nodes that are
part of the same track.
Note that IPIN and OPIN graph nodes are not added yet, as pins have not been
assigned sides of the VPR tiles yet. This occurs in
prjxray_assign_tile_pin_direction.
"""
import argparse
import csv
import prjxray.db
import prjxray.tile
from prjxray.timing import PvtCorner
from lib import progressbar_utils
import tile_splitter.grid
from lib.rr_graph import points
from lib.rr_graph import tracks
from lib.rr_graph import graph2
import datetime
import os
import os.path
from lib.connection_database import NodeClassification, create_tables, node_to_site_pins
from prjxray_db_cache import DatabaseCache
from prjxray_define_segments import SegmentWireMap
SINGLE_PRECISION_FLOAT_MIN = 2**-126
VCC_NET = 'VCC_NET'
GND_NET = 'GND_NET'
def import_site_type(db, write_cur, site_types, site_type_name):
assert site_type_name not in site_types
site_type = db.get_site_type(site_type_name)
if site_type_name in site_types:
return
write_cur.execute(
"INSERT INTO site_type(name) VALUES (?)", (site_type_name, )
)
site_types[site_type_name] = write_cur.lastrowid
for site_pin in site_type.get_site_pins():
pin_info = site_type.get_site_pin(site_pin)
write_cur.execute(
"""
INSERT INTO site_pin(name, site_type_pkey, direction)
VALUES
(?, ?, ?)""", (
pin_info.name, site_types[site_type_name],
pin_info.direction.value
)
)
def create_get_switch(conn):
""" Returns functions to get or create switches with various timing.
Every switch that requires different timing is given it's own switch
in VPR. get_switch returns a switch a pip. get_switch_timing returns
a switch given a particular timing.
"""
write_cur = conn.cursor()
pip_cache = {}
write_cur.execute(
"SELECT pkey FROM switch WHERE name = ?",
("__vpr_delayless_switch__", )
)
pip_cache[(False, 0.0, 0.0, 0.0)] = write_cur.fetchone()[0]
def get_switch_timing(
is_pass_transistor, delay, internal_capacitance, drive_resistance
):
""" Return a switch that matches provided timing.
Arguments
---------
is_pass_transistor : bool-like
If true, this switch should be represented as a "pass_gate".
delay : float or convertable to float
Intrinsic delay through switch (seconds)
internal_capacitance : float or convertable to float
Internal capacitance to switch (Farads).
drive_resistance : float or convertable to float
Drive resistance from switch (Ohms).
Returns
-------
switch_pkey : int
Switch primary key that represents provided arguments.
"""
key = (
bool(is_pass_transistor), float(delay), float(drive_resistance),
float(internal_capacitance)
)
if key not in pip_cache:
name = 'routing'
switch_type = 'mux'
if is_pass_transistor:
name = 'pass_transistor'
switch_type = 'pass_gate'
name = '{}_R{}_C{}_Tdel{}'.format(
name, drive_resistance, internal_capacitance, delay
)
write_cur.execute(
"""
INSERT INTO
switch(
name, internal_capacitance, drive_resistance, intrinsic_delay, switch_type
)
VALUES
(?, ?, ?, ?, ?)""", (
name, internal_capacitance, drive_resistance, delay,
switch_type
)
)
pip_cache[key] = write_cur.lastrowid
write_cur.connection.commit()
return pip_cache[key]
def get_switch(pip, pip_timing):
""" Return switch_pkey for given pip timing.
Arguments
---------
pip : tile.Pip object
Pip being modelled
pip_timing : tile.PipTiming object
Pip timing being modelled
Returns
-------
switch_pkey : int
Switch primary key that represents provided arguments.
"""
delay = 0.0
drive_resistance = 0.0
internal_capacitance = 0.0
if pip_timing is not None:
if pip_timing.delays is not None:
# Use the largest intristic delay for now.
# This conservative on slack timing, but not on hold timing.
#
# nanosecond -> seconds
delay = pip_timing.delays[PvtCorner.SLOW].max / 1e9
if pip_timing.internal_capacitance is not None:
# microFarads -> Farads
internal_capacitance = pip_timing.internal_capacitance / 1e6
if pip_timing.drive_resistance is not None:
# milliOhms -> Ohms
drive_resistance = pip_timing.drive_resistance / 1e3
return get_switch_timing(
pip.is_pass_transistor, delay, internal_capacitance,
drive_resistance
)
return get_switch, get_switch_timing
def build_pss_object_mask(db, tile_type_name):
"""
Looks for objects present in PSS* tiles of Zynq7 and masks out those
that are purely PS related and not configued by the PL.
"""
tile_type = db.get_tile_type(tile_type_name)
sites = tile_type.get_sites()
masked_wires = []
masked_pips = []
# Get all IOPADS for MIO and DDR signals
iopad_sites = [s for s in sites if s.type == "IOPAD"]
for site in iopad_sites:
# Get pins/wires
site_pins = [p for p in site.site_pins if p.name == "IO"]
for site_pin in site_pins:
# Mask the wire
masked_wires.append(site_pin.wire)
# Find a PIP(s) for this wire, mask them as well as wires on
# their other sides.
for p in tile_type.get_pips():
if p.net_from == site_pin.wire:
masked_pips.append(p.name)
masked_wires.append(p.net_to)
if p.net_to == site_pin.wire:
masked_pips.append(p.name)
masked_wires.append(p.net_from)
# Masked sites names
masked_sites = [(s.prefix, s.name) for s in iopad_sites]
return masked_sites, masked_wires, masked_pips
def import_tile_type(
db, write_cur, tile_types, site_types, tile_type_name, get_switch
):
assert tile_type_name not in tile_types
tile_type = db.get_tile_type(tile_type_name)
# For Zynq7 PSS* tiles build a list of sites, wires and PIPs to ignore
if tile_type_name.startswith("PSS"):
masked_sites, masked_wires, masked_pips = build_pss_object_mask(
db, tile_type_name
)
else:
masked_sites = []
masked_wires = []
masked_pips = []
write_cur.execute(
"INSERT INTO tile_type(name) VALUES (?)", (tile_type_name, )
)
tile_types[tile_type_name] = write_cur.lastrowid
wires = {}
for wire, wire_rc_element in tile_type.get_wires().items():
if wire in masked_wires:
continue
capacitance = 0.0
resistance = 0.0
if wire_rc_element is not None:
# microFarads -> Farads
capacitance = wire_rc_element.capacitance / 1e6
# milliOhms -> Ohms
resistance = wire_rc_element.resistance / 1e3
write_cur.execute(
"""
INSERT INTO wire_in_tile(name, phy_tile_type_pkey, tile_type_pkey, capacitance, resistance)
VALUES
(?, ?, ?, ?, ?)""", (
wire, tile_types[tile_type_name], tile_types[tile_type_name],
capacitance, resistance
)
)
wires[wire] = write_cur.lastrowid
for pip in tile_type.get_pips():
if pip.name in masked_pips:
continue
switch_pkey = get_switch(pip, pip.timing)
backward_switch_pkey = get_switch(pip, pip.backward_timing)
write_cur.execute(
"""
INSERT INTO pip_in_tile(
name, tile_type_pkey, src_wire_in_tile_pkey,
dest_wire_in_tile_pkey, can_invert, is_directional, is_pseudo,
is_pass_transistor, switch_pkey, backward_switch_pkey
)
VALUES
(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""", (
pip.name, tile_types[tile_type_name], wires[pip.net_from],
wires[pip.net_to
], pip.can_invert, pip.is_directional, pip.is_pseudo,
pip.is_pass_transistor, switch_pkey, backward_switch_pkey
)
)
pip_pkey = write_cur.lastrowid
write_cur.execute(
"""
INSERT INTO undirected_pips(
wire_in_tile_pkey, pip_in_tile_pkey, other_wire_in_tile_pkey)
VALUES
(?, ?, ?), (?, ?, ?);""", (
wires[pip.net_from],
pip_pkey,
wires[pip.net_to],
wires[pip.net_to],
pip_pkey,
wires[pip.net_from],
)
)
for site in tile_type.get_sites():
if (site.prefix, site.name) in masked_sites:
continue
if site.type not in site_types:
import_site_type(db, write_cur, site_types, site.type)
def add_wire_to_site_relation(
db, write_cur, tile_types, site_types, tile_type_name,
get_switch_timing
):
tile_type = db.get_tile_type(tile_type_name)
for site in tile_type.get_sites():
if site.type not in site_types:
continue
write_cur.execute(
"""
INSERT INTO site(name, x_coord, y_coord, site_type_pkey, tile_type_pkey)
VALUES
(?, ?, ?, ?, ?)""", (
site.name, site.x, site.y, site_types[site.type],
tile_types[tile_type_name]
)
)
site_pkey = write_cur.lastrowid
for site_pin in site.site_pins:
write_cur.execute(
"""
SELECT
pkey
FROM
site_pin
WHERE
name = ?
AND site_type_pkey = ?""", (site_pin.name, site_types[site.type])
)
result = write_cur.fetchone()
site_pin_pkey = result[0]
intrinsic_delay = 0
drive_resistance = 0
capacitance = 0
if site_pin.timing is not None:
# Use the largest intristic delay for now.
# This conservative on slack timing, but not on hold timing.
#
# nanosecond -> seconds
intrinsic_delay = site_pin.timing.delays[PvtCorner.SLOW
].max / 1e9
if isinstance(site_pin.timing, prjxray.tile.OutPinTiming):
# milliOhms -> Ohms
drive_resistance = site_pin.timing.drive_resistance / 1e3
elif isinstance(site_pin.timing, prjxray.tile.InPinTiming):
# microFarads -> Farads
capacitance = site_pin.timing.capacitance / 1e6
else:
assert False, site_pin
else:
# Use min value instead of 0 to prevent
# VPR from freaking out over a zero net delay.
#
# Note this is the single precision float minimum, because VPR
# uses single precision, not double precision.
intrinsic_delay = SINGLE_PRECISION_FLOAT_MIN
site_pin_switch_pkey = get_switch_timing(
is_pass_transistor=False,
delay=intrinsic_delay,
internal_capacitance=capacitance,
drive_resistance=drive_resistance,
)
write_cur.execute(
"""
UPDATE
wire_in_tile
SET
site_pkey = ?,
site_pin_pkey = ?,
site_pin_switch_pkey = ?
WHERE
name = ?
and tile_type_pkey = ?;""", (
site_pkey, site_pin_pkey, site_pin_switch_pkey,
site_pin.wire, tile_types[tile_type_name]
)
)
def build_tile_type_indicies(write_cur):
write_cur.execute(
"CREATE INDEX site_pin_index ON site_pin(name, site_type_pkey);"
)
write_cur.execute(
"CREATE INDEX wire_name_index ON wire_in_tile(name, tile_type_pkey);"
)
write_cur.execute(
"CREATE INDEX wire_tile_site_index ON wire_in_tile(tile_type_pkey, site_pkey);"
)
write_cur.execute(
"CREATE INDEX wire_site_pin_index ON wire_in_tile(site_pin_pkey);"
)
write_cur.execute(
"CREATE INDEX tile_type_index ON phy_tile(tile_type_pkey);"
)
write_cur.execute(
"CREATE INDEX pip_tile_type_index ON pip_in_tile(tile_type_pkey);"
)
write_cur.execute(
"CREATE INDEX src_pip_index ON pip_in_tile(src_wire_in_tile_pkey);"
)
write_cur.execute(
"CREATE INDEX dest_pip_index ON pip_in_tile(dest_wire_in_tile_pkey);"
)
write_cur.execute(
"""CREATE INDEX undirected_pip_index ON
undirected_pips(wire_in_tile_pkey, other_wire_in_tile_pkey);"""
)
def build_other_indicies(write_cur):
write_cur.execute("CREATE INDEX phy_tile_name_index ON phy_tile(name);")
write_cur.execute(
"CREATE INDEX phy_tile_location_index ON phy_tile(grid_x, grid_y);"
)
write_cur.execute(
"CREATE INDEX site_instance_index on site_instance(name);"
)
def import_phy_grid(db, grid, conn, get_switch, get_switch_timing):
write_cur = conn.cursor()
tile_types = {}
site_types = {}
for tile in grid.tiles():
gridinfo = grid.gridinfo_at_tilename(tile)
if gridinfo.tile_type not in tile_types:
if gridinfo.tile_type in tile_types:
continue
import_tile_type(
db, write_cur, tile_types, site_types, gridinfo.tile_type,
get_switch
)
write_cur.connection.commit()
build_tile_type_indicies(write_cur)
write_cur.connection.commit()
for tile_type in tile_types:
add_wire_to_site_relation(
db, write_cur, tile_types, site_types, tile_type, get_switch_timing
)
clock_regions = {}
for tile in grid.tiles():
gridinfo = grid.gridinfo_at_tilename(tile)
clock_region_pkey = None
if gridinfo.clock_region is not None:
if gridinfo.clock_region.name not in clock_regions:
write_cur.execute(
"""
INSERT INTO clock_region(name, x_coord, y_coord)
VALUES (?, ?, ?)""", (
gridinfo.clock_region.name,
gridinfo.clock_region.x,
gridinfo.clock_region.y,
)
)
clock_regions[gridinfo.clock_region.name] = write_cur.lastrowid
clock_region_pkey = clock_regions[gridinfo.clock_region.name]
loc = grid.loc_of_tilename(tile)
# tile: pkey name tile_type_pkey grid_x grid_y
write_cur.execute(
"""
INSERT INTO phy_tile(name, tile_type_pkey, grid_x, grid_y, clock_region_pkey)
VALUES
(?, ?, ?, ?, ?)""", (
tile,
tile_types[gridinfo.tile_type],
loc.grid_x,
loc.grid_y,
clock_region_pkey,
)
)
phy_tile_pkey = write_cur.lastrowid
tile_type = db.get_tile_type(gridinfo.tile_type)
for site, instance_site in zip(tile_type.sites,
tile_type.get_instance_sites(gridinfo)):
write_cur.execute(
"""
INSERT INTO site_instance(name, x_coord, y_coord, site_pkey, phy_tile_pkey)
SELECT ?, ?, ?, site.pkey, ?
FROM site
WHERE
site.name = ?
AND
site.x_coord = ?
AND
site.y_coord = ?
AND
site.site_type_pkey = (SELECT pkey FROM site_type WHERE name = ?)
AND
tile_type_pkey = ?;
""", (
instance_site.name,
instance_site.x,
instance_site.y,
phy_tile_pkey,
site.name,
site.x,
site.y,
site.type,
tile_types[gridinfo.tile_type],
)
)
site_instance_pkey = write_cur.lastrowid
write_cur.execute(
"UPDATE site_instance SET prohibited = ? WHERE pkey = ?", (
instance_site.name in gridinfo.prohibited_sites,
site_instance_pkey,
)
)
build_other_indicies(write_cur)
write_cur.connection.commit()
def import_nodes(db, grid, conn):
# Some nodes are just 1 wire, so start by enumerating all wires.
cur = conn.cursor()
write_cur = conn.cursor()
write_cur.execute("""BEGIN EXCLUSIVE TRANSACTION;""")
tile_wire_map = {}
wires = {}
for tile in progressbar_utils.progressbar(grid.tiles()):
gridinfo = grid.gridinfo_at_tilename(tile)
tile_type = db.get_tile_type(gridinfo.tile_type)
cur.execute(
"""SELECT pkey, tile_type_pkey FROM phy_tile WHERE name = ?;""",
(tile, )
)
phy_tile_pkey, tile_type_pkey = cur.fetchone()
for wire in tile_type.get_wires():
# pkey node_pkey tile_pkey wire_in_tile_pkey
cur.execute(
"""
SELECT pkey FROM wire_in_tile WHERE name = ? and tile_type_pkey = ?;""",
(wire, tile_type_pkey)
)
wire_in_tile_pkey = cur.fetchone()
if wire_in_tile_pkey is None:
continue
wire_in_tile_pkey = wire_in_tile_pkey[0]
write_cur.execute(
"""
INSERT INTO wire(phy_tile_pkey, wire_in_tile_pkey)
VALUES
(?, ?);""", (phy_tile_pkey, wire_in_tile_pkey)
)
assert (tile, wire) not in tile_wire_map
wire_pkey = write_cur.lastrowid
tile_wire_map[(tile, wire)] = wire_pkey
wires[wire_pkey] = None
write_cur.execute("""COMMIT TRANSACTION;""")
connections = db.connections()
for connection in progressbar_utils.progressbar(
connections.get_connections()):
a_pkey = tile_wire_map[
(connection.wire_a.tile, connection.wire_a.wire)]
b_pkey = tile_wire_map[
(connection.wire_b.tile, connection.wire_b.wire)]
a_node = wires[a_pkey]
b_node = wires[b_pkey]
if a_node is None:
a_node = set((a_pkey, ))
if b_node is None:
b_node = set((b_pkey, ))
if a_node is not b_node:
a_node |= b_node
for wire in a_node:
wires[wire] = a_node
nodes = {}
for wire_pkey, node in wires.items():
if node is None:
node = set((wire_pkey, ))
assert wire_pkey in node
nodes[id(node)] = node
wires_assigned = set()
for node in progressbar_utils.progressbar(nodes.values()):
write_cur.execute("""INSERT INTO node(number_pips) VALUES (0);""")
node_pkey = write_cur.lastrowid
for wire_pkey in node:
wires_assigned.add(wire_pkey)
write_cur.execute(
"""
UPDATE wire
SET node_pkey = ?
WHERE pkey = ?
;""", (node_pkey, wire_pkey)
)
assert len(set(wires.keys()) ^ wires_assigned) == 0
del tile_wire_map
del nodes
del wires
write_cur.execute(
"CREATE INDEX wire_in_tile_index ON wire(wire_in_tile_pkey);"
)
write_cur.execute(
"CREATE INDEX wire_index ON wire(phy_tile_pkey, wire_in_tile_pkey);"
)
write_cur.execute("CREATE INDEX wire_node_index ON wire(node_pkey);")
write_cur.connection.commit()
def count_sites_and_pips_on_nodes(conn):
cur = conn.cursor()
print("{}: Counting sites on nodes".format(datetime.datetime.now()))
cur.execute(
"""
WITH node_sites(node_pkey, number_site_pins) AS (
SELECT
wire.node_pkey,
count(wire_in_tile.site_pin_pkey)
FROM
wire_in_tile
INNER JOIN wire ON wire.wire_in_tile_pkey = wire_in_tile.pkey
WHERE
wire_in_tile.site_pin_pkey IS NOT NULL
GROUP BY
wire.node_pkey
)
SELECT
max(node_sites.number_site_pins)
FROM
node_sites;
"""
)
# Nodes are only expected to have 1 site
assert cur.fetchone()[0] == 1
print("{}: Assigning site wires for nodes".format(datetime.datetime.now()))
cur.execute(
"""
WITH site_wires(wire_pkey, node_pkey) AS (
SELECT
wire.pkey,
wire.node_pkey
FROM
wire_in_tile
INNER JOIN wire ON wire.wire_in_tile_pkey = wire_in_tile.pkey
WHERE
wire_in_tile.site_pin_pkey IS NOT NULL
)
UPDATE
node
SET
site_wire_pkey = (
SELECT
site_wires.wire_pkey
FROM
site_wires
WHERE
site_wires.node_pkey = node.pkey
);
"""
)
print("{}: Counting pips on nodes".format(datetime.datetime.now()))
cur.execute(
"""
CREATE TABLE node_pip_count(
node_pkey INT,
number_pips INT,
FOREIGN KEY(node_pkey) REFERENCES node(pkey)
);"""
)
cur.execute(
"""
INSERT INTO node_pip_count(node_pkey, number_pips)
SELECT
wire.node_pkey,
count(pip_in_tile.pkey)
FROM
pip_in_tile
INNER JOIN wire
WHERE
pip_in_tile.is_pseudo = 0 AND (
pip_in_tile.src_wire_in_tile_pkey = wire.wire_in_tile_pkey
OR pip_in_tile.dest_wire_in_tile_pkey = wire.wire_in_tile_pkey)
GROUP BY
wire.node_pkey;"""
)
cur.execute("CREATE INDEX pip_count_index ON node_pip_count(node_pkey);")
print("{}: Inserting pip counts".format(datetime.datetime.now()))
cur.execute(
"""
UPDATE
node
SET
number_pips = (
SELECT
node_pip_count.number_pips
FROM
node_pip_count
WHERE
node_pip_count.node_pkey = node.pkey
)
WHERE
pkey IN (
SELECT
node_pkey
FROM
node_pip_count
);"""
)
cur.execute("""DROP TABLE node_pip_count;""")
cur.connection.commit()
def check_edge_with_mux_timing(
conn, get_switch_timing, src_wire_pkey, dest_wire_pkey, pip_pkey
):
""" Check if edge with mux timing can be "lumped" into the switch.
Returns
-------
switch_pkey : int
Switch primary key to model EDGE_WITH_MUX connection.
"""
cur = conn.cursor()
cur.execute(
"""
SELECT site_pin_switch_pkey, resistance, capacitance FROM wire_in_tile WHERE pkey = (
SELECT wire_in_tile_pkey FROM wire WHERE pkey = ?
)""", (src_wire_pkey, )
)
src_site_pin_switch_pkey, src_wire_resistance, src_wire_capacitance = cur.fetchone(
)
assert src_wire_resistance == 0, src_wire_pkey
cur.execute(
"""
SELECT intrinsic_delay, drive_resistance FROM switch WHERE pkey = ?
""", (src_site_pin_switch_pkey, )
)
src_site_pin_intrinsic_delay, src_site_pin_drive_resistance = cur.fetchone(
)
cur.execute(
"""
SELECT site_pin_switch_pkey, resistance, capacitance FROM wire_in_tile WHERE pkey = (
SELECT wire_in_tile_pkey FROM wire WHERE pkey = ?
)""", (dest_wire_pkey, )
)
dest_site_pin_switch_pkey, dest_wire_resistance, dest_wire_capacitance = cur.fetchone(
)
assert dest_wire_resistance == 0, dest_wire_pkey
cur.execute(
"""
SELECT intrinsic_delay, internal_capacitance FROM switch WHERE pkey = ?
""", (dest_site_pin_switch_pkey, )
)
dest_site_pin_intrinsic_delay, dest_site_pin_capacitance = cur.fetchone()
cur.execute(
"""
SELECT name, switch_pkey FROM pip_in_tile WHERE pkey = ?""", (pip_pkey, )
)
pip_name, switch_pkey = cur.fetchone()
cur.execute(
"""
SELECT
name, intrinsic_delay, internal_capacitance, drive_resistance, switch_type
FROM switch WHERE pkey = ?
""", (switch_pkey, )
)
(
switch_name, switch_intrinsic_delay, switch_internal_capacitance,
switch_drive_resistance, switch_type
) = cur.fetchone()
assert switch_type in ["mux", "pass_gate"], (switch_pkey, switch_type)
zero_delay_to_switch = src_site_pin_drive_resistance == 0 or (
switch_internal_capacitance == 0 and src_wire_capacitance == 0
)
zero_delay_from_switch = switch_drive_resistance == 0 or (
dest_wire_capacitance == 0 and dest_site_pin_capacitance == 0
)
if zero_delay_to_switch and zero_delay_from_switch and \
src_site_pin_intrinsic_delay == 0 and \
dest_site_pin_intrinsic_delay == 0:
return get_switch_timing(
is_pass_transistor=False,
delay=switch_intrinsic_delay,
internal_capacitance=0,
drive_resistance=0,
)
if switch_type == "mux":
switch_delay = src_site_pin_intrinsic_delay
switch_delay += src_site_pin_drive_resistance * (
switch_internal_capacitance + src_wire_capacitance
)
switch_delay += switch_intrinsic_delay
switch_delay += switch_drive_resistance * (
dest_wire_capacitance + dest_site_pin_capacitance
)
switch_delay += dest_site_pin_intrinsic_delay
else:
assert switch_type == "pass_gate"
assert switch_intrinsic_delay == 0
assert switch_drive_resistance == 0
switch_delay = src_site_pin_intrinsic_delay
switch_delay += src_site_pin_drive_resistance * (
src_wire_capacitance + switch_internal_capacitance +
dest_wire_capacitance + dest_site_pin_capacitance
)
switch_delay += dest_site_pin_intrinsic_delay
return get_switch_timing(
is_pass_transistor=False,
delay=switch_delay,
internal_capacitance=0,
drive_resistance=0
)
def classify_nodes(conn, get_switch_timing):
write_cur = conn.cursor()
# Nodes are NULL if they they only have either a site pin or 1 pip, but
# nothing else.
write_cur.execute(
"""
UPDATE node SET classification = ?
WHERE (node.site_wire_pkey IS NULL AND node.number_pips <= 1) OR
(node.site_wire_pkey IS NOT NULL AND node.number_pips == 0)
;""", (NodeClassification.NULL.value, )
)
write_cur.execute(
"""
UPDATE node SET classification = ?
WHERE node.number_pips > 1 and node.site_wire_pkey IS NULL;""",
(NodeClassification.CHANNEL.value, )
)
write_cur.execute(
"""
UPDATE node SET classification = ?
WHERE node.number_pips > 1 and node.site_wire_pkey IS NOT NULL;""",
(NodeClassification.EDGES_TO_CHANNEL.value, )
)
null_nodes = []
edges_to_channel = []
edge_with_mux = []
cur = conn.cursor()
cur.execute(
"""
SELECT
count(pkey)
FROM
node
WHERE
number_pips == 1
AND site_wire_pkey IS NOT NULL;"""
)
num_nodes = cur.fetchone()[0]
with progressbar_utils.ProgressBar(max_value=num_nodes) as bar:
bar.update(0)
for idx, (node, site_wire_pkey) in enumerate(cur.execute("""
SELECT
pkey,
site_wire_pkey
FROM
node
WHERE
number_pips == 1
AND site_wire_pkey IS NOT NULL;""")):
bar.update(idx)
write_cur.execute(
"""
WITH wire_in_node(
wire_pkey, phy_tile_pkey, wire_in_tile_pkey
) AS (
SELECT
wire.pkey,
wire.phy_tile_pkey,
wire.wire_in_tile_pkey
FROM
wire
WHERE
wire.node_pkey = ?
)
SELECT
pip_in_tile.pkey,
pip_in_tile.src_wire_in_tile_pkey,
pip_in_tile.dest_wire_in_tile_pkey,
wire_in_node.wire_pkey,
wire_in_node.wire_in_tile_pkey,
wire_in_node.phy_tile_pkey
FROM
wire_in_node
INNER JOIN pip_in_tile
WHERE
pip_in_tile.is_pseudo = 0 AND (
pip_in_tile.src_wire_in_tile_pkey = wire_in_node.wire_in_tile_pkey
OR pip_in_tile.dest_wire_in_tile_pkey = wire_in_node.wire_in_tile_pkey)
LIMIT
1;
""", (node, )
)
(
pip_pkey, src_wire_in_tile_pkey, dest_wire_in_tile_pkey,
wire_in_node_pkey, wire_in_tile_pkey, phy_tile_pkey
) = write_cur.fetchone()
assert write_cur.fetchone() is None, node
assert (
wire_in_tile_pkey == src_wire_in_tile_pkey
or wire_in_tile_pkey == dest_wire_in_tile_pkey
), (wire_in_tile_pkey, pip_pkey)
if src_wire_in_tile_pkey == wire_in_tile_pkey:
other_wire = dest_wire_in_tile_pkey
else:
other_wire = src_wire_in_tile_pkey
write_cur.execute(
"""
SELECT node_pkey FROM wire WHERE
wire_in_tile_pkey = ? AND
phy_tile_pkey = ?;
""", (other_wire, phy_tile_pkey)
)
(other_node_pkey, ) = write_cur.fetchone()
assert write_cur.fetchone() is None
assert other_node_pkey is not None, (other_wire, phy_tile_pkey)
write_cur.execute(
"""
SELECT site_wire_pkey, number_pips
FROM node WHERE pkey = ?;
""", (other_node_pkey, )
)
result = write_cur.fetchone()
assert result is not None, other_node_pkey
other_site_wire_pkey, other_number_pips = result
assert write_cur.fetchone() is None
force_direct = False
write_cur.execute(
"""
SELECT name
FROM pip_in_tile WHERE pkey = ?;
""", (pip_pkey, )
)
pip_name = write_cur.fetchone()[0]
# A solution for:
# https://github.com/SymbiFlow/symbiflow-arch-defs/issues/1033
if "PADOUT0" in pip_name and "DIFFI_IN1" in pip_name:
force_direct = True
if "PADOUT1" in pip_name and "DIFFI_IN0" in pip_name:
force_direct = True
if other_site_wire_pkey is not None and (other_number_pips == 1
or force_direct):
if src_wire_in_tile_pkey == wire_in_tile_pkey:
src_wire_pkey = site_wire_pkey
dest_wire_pkey = other_site_wire_pkey
else:
src_wire_pkey = other_site_wire_pkey
dest_wire_pkey = site_wire_pkey
edge_with_mux.append(
(
(node, other_node_pkey), src_wire_pkey, dest_wire_pkey,
pip_pkey
)
)
elif other_site_wire_pkey is None and other_number_pips == 1:
null_nodes.append(node)
null_nodes.append(other_node_pkey)
pass
else:
edges_to_channel.append(node)
for nodes, src_wire_pkey, dest_wire_pkey, pip_pkey in progressbar_utils.progressbar(
edge_with_mux):
assert len(nodes) == 2
switch_pkey = check_edge_with_mux_timing(
conn, get_switch_timing, src_wire_pkey, dest_wire_pkey, pip_pkey
)
write_cur.execute(
"""
UPDATE node SET classification = ?
WHERE pkey IN (?, ?);""",
(NodeClassification.EDGE_WITH_MUX.value, nodes[0], nodes[1])
)
write_cur.execute(
"""
INSERT INTO edge_with_mux(src_wire_pkey, dest_wire_pkey, pip_in_tile_pkey, switch_pkey)
VALUES
(?, ?, ?, ?);""", (src_wire_pkey, dest_wire_pkey, pip_pkey, switch_pkey)
)
for node in progressbar_utils.progressbar(edges_to_channel):
write_cur.execute(
"""
UPDATE node SET classification = ?
WHERE pkey = ?;""", (
NodeClassification.EDGES_TO_CHANNEL.value,
node,
)
)
for null_node in progressbar_utils.progressbar(null_nodes):
write_cur.execute(
"""
UPDATE node SET classification = ?
WHERE pkey = ?;""", (
NodeClassification.NULL.value,
null_node,
)
)
write_cur.execute("CREATE INDEX node_type_index ON node(classification);")
write_cur.execute(
"""
CREATE INDEX edge_with_mux_index ON edge_with_mux(
src_wire_pkey,
dest_wire_pkey,
pip_in_tile_pkey,
switch_pkey);"""
)
write_cur.connection.commit()
def get_node_rc(conn, node_pkey):
""" Returns capacitance and resistance for given node.
Returns
-------
capacitance : float
Node capacitance (Farads)
resistance : float
Node resistance (Ohms)
"""
capacitance = 0
resistance = 0
cur = conn.cursor()
for wire_cap, wire_res in cur.execute("""
SELECT capacitance, resistance FROM wire_in_tile WHERE pkey IN (
SELECT wire_in_tile_pkey FROM wire WHERE node_pkey = ?
);""", (node_pkey, )):
capacitance += wire_cap
resistance += wire_res
return capacitance, resistance
def get_segment_for_node(cur, segments, node_pkey):
""" Attempt to determine the segment for the given node.
Parameters
----------
conn : sqlite3.Connection
Connection to channels.db
segments : SegmentWireMap
Object for determined segment based on wire names.
node_pkey : int
Node to determine segment of. Is primary key into node table.
Returns
-------
segment_pkey : int
Primary key to segment table of segment for this node.
"""
cur.execute(
"""
SELECT name FROM wire_in_tile WHERE pkey IN (
SELECT wire_in_tile_pkey FROM wire WHERE node_pkey = ?
);""", (node_pkey, )
)
segment_name = segments.get_segment_for_wires(
wire for (wire, ) in cur.fetchall()
)
cur.execute(
"""
SELECT pkey FROM segment WHERE name = ?
""", (segment_name, )
)
return cur.fetchone()[0]
def insert_tracks(conn, segments, tracks_to_insert):
write_cur = conn.cursor()
write_cur.execute('SELECT pkey FROM switch WHERE name = "short";')
short_pkey = write_cur.fetchone()[0]
track_graph_nodes = {}
track_pkeys = []
for node, tracks_list, track_conn, tracks_model, seg_pkey in progressbar_utils.progressbar(
tracks_to_insert):
write_cur.execute(
"""INSERT INTO track(segment_pkey) VALUES (?)""", (seg_pkey, )
)
track_pkey = write_cur.lastrowid
track_pkeys.append(track_pkey)
write_cur.execute(
"""UPDATE node SET track_pkey = ? WHERE pkey = ?""",
(track_pkey, node)
)
track_graph_node_pkey = []
for idx, track in enumerate(tracks_list):
if track.direction == 'X':
node_type = graph2.NodeType.CHANX
elif track.direction == 'Y':
node_type = graph2.NodeType.CHANY
else:
assert False, track.direction
if idx == 0:
capacitance, resistance = get_node_rc(conn, node)
else:
capacitance = 0
resistance = 0
write_cur.execute(
"""
INSERT INTO graph_node(
graph_node_type, track_pkey, node_pkey,
x_low, x_high, y_low, y_high, capacity, capacitance, resistance
)
VALUES
(?, ?, ?, ?, ?, ?, ?, 1, ?, ?)""", (
node_type.value, track_pkey, node, track.x_low,
track.x_high, track.y_low, track.y_high, capacitance,
resistance
)
)
track_graph_node_pkey.append(write_cur.lastrowid)
track_graph_nodes[node] = track_graph_node_pkey
for connection in track_conn:
write_cur.execute(
"""
INSERT INTO graph_edge(
src_graph_node_pkey, dest_graph_node_pkey,
switch_pkey, track_pkey
)
VALUES
(?, ?, ?, ?),
(?, ?, ?, ?)""", (
track_graph_node_pkey[connection[0]],
track_graph_node_pkey[connection[1]],
short_pkey,
track_pkey,
track_graph_node_pkey[connection[1]],
track_graph_node_pkey[connection[0]],
short_pkey,
track_pkey,
)
)
conn.commit()
wire_to_graph = {}
for node, tracks_list, track_conn, tracks_model, _ in progressbar_utils.progressbar(
tracks_to_insert):
track_graph_node_pkey = track_graph_nodes[node]
write_cur.execute(
"""
WITH wires_from_node(wire_pkey, tile_pkey) AS (
SELECT
pkey,
tile_pkey
FROM
wire
WHERE
node_pkey = ?
)
SELECT
wires_from_node.wire_pkey,
tile.grid_x,
tile.grid_y
FROM
tile
INNER JOIN wires_from_node ON tile.pkey = wires_from_node.tile_pkey;
""", (node, )
)
wires = write_cur.fetchall()
for wire_pkey, grid_x, grid_y in wires:
connections = list(
tracks_model.get_tracks_for_wire_at_coord((grid_x,
grid_y)).values()
)
assert len(connections) > 0, (
connections, wire_pkey, track_pkey, grid_x, grid_y, node
)
graph_node_pkey = track_graph_node_pkey[connections[0]]
wire_to_graph[wire_pkey] = graph_node_pkey
for wire_pkey, graph_node_pkey in progressbar_utils.progressbar(
wire_to_graph.items()):
write_cur.execute(
"""
UPDATE wire SET graph_node_pkey = ?
WHERE pkey = ?""", (graph_node_pkey, wire_pkey)
)
conn.commit()
write_cur.execute(
"""CREATE INDEX graph_node_nodes ON graph_node(node_pkey);"""
)
write_cur.execute(
"""CREATE INDEX graph_node_tracks ON graph_node(track_pkey);"""
)
write_cur.execute(
"""CREATE INDEX graph_edge_tracks ON graph_edge(track_pkey);"""
)
conn.commit()
return track_pkeys
def create_track(node, unique_pos):
xs, ys = points.decompose_points_into_tracks(unique_pos)
tracks_list, track_connections = tracks.make_tracks(xs, ys, unique_pos)
tracks_model = tracks.Tracks(tracks_list, track_connections)
return [node, tracks_list, track_connections, tracks_model]
def form_tracks(conn, segments):
cur = conn.cursor()
cur2 = conn.cursor()
cur.execute(
'SELECT count(pkey) FROM node WHERE classification == ?;',
(NodeClassification.CHANNEL.value, )
)
num_nodes = cur.fetchone()[0]
tracks_to_insert = []
with progressbar_utils.ProgressBar(max_value=num_nodes) as bar:
bar.update(0)
for idx, (node_pkey, ) in enumerate(cur.execute("""
SELECT pkey FROM node WHERE classification == ?;
""", (NodeClassification.CHANNEL.value, ))):
bar.update(idx)
unique_pos = set()
# Get coordinates for all wires in this node.
for grid_x, grid_y in cur2.execute("""
SELECT DISTINCT grid_x, grid_y FROM tile WHERE pkey IN (
SELECT tile_pkey FROM wire WHERE node_pkey = ? AND tile_pkey IS NOT NULL
)""", (node_pkey, )):
unique_pos.add((grid_x, grid_y))
# Find the VPR grid locations that this channel connects to.
#
# Algorithm:
# 1. Identify all pips that connect to or from this node
# 2. Traverse each pip, and determine if the connected node is a
# EDGES_TO_CHANNEL. NULL nodes are uninteresting, and CHANNEL
# nodes are already covered in the earlier loop getting
# locations of the
# discarded.
# 3a. For CHANNEL to CHANNEL connections, use the pip location.
# 3b. For CHANNEL to EDGES_TO_CHANNEL (e.g. site pin connections)
# use location of site in VPR grid.
# 3a loop
for grid_x, grid_y in cur2.execute("""
-- Get wires from this node
WITH wires_from_node(wire_in_tile_pkey, phy_tile_pkey) AS (
SELECT
wire_in_tile_pkey,
phy_tile_pkey
FROM
wire
WHERE
node_pkey = ? AND tile_pkey IS NOT NULL
),
other_wires(phy_tile_pkey, wire_in_tile_pkey) AS (
SELECT
wires_from_node.phy_tile_pkey,
undirected_pips.other_wire_in_tile_pkey
FROM undirected_pips
INNER JOIN wires_from_node ON
undirected_pips.wire_in_tile_pkey = wires_from_node.wire_in_tile_pkey)
SELECT tile.grid_x, tile.grid_y
FROM tile
WHERE pkey IN (
SELECT wire.tile_pkey FROM wire
INNER JOIN other_wires ON
wire.wire_in_tile_pkey = other_wires.wire_in_tile_pkey
AND
wire.phy_tile_pkey = other_wires.phy_tile_pkey
);""", (node_pkey, )):
unique_pos.add((grid_x, grid_y))
# 3b loop
for grid_x, grid_y in cur2.execute("""
-- Get wires from this node
WITH wires_from_node(wire_in_tile_pkey, phy_tile_pkey) AS (
SELECT
wire_in_tile_pkey,
phy_tile_pkey
FROM
wire
WHERE
node_pkey = ? AND tile_pkey IS NOT NULL
),
other_wires(phy_tile_pkey, wire_in_tile_pkey) AS (
SELECT
wires_from_node.phy_tile_pkey,
undirected_pips.other_wire_in_tile_pkey
FROM undirected_pips
INNER JOIN wires_from_node ON
undirected_pips.wire_in_tile_pkey = wires_from_node.wire_in_tile_pkey),
other_nodes(other_node_pkey) AS (
SELECT wire.node_pkey FROM wire
INNER JOIN other_wires ON
wire.wire_in_tile_pkey = other_wires.wire_in_tile_pkey
AND
wire.phy_tile_pkey = other_wires.phy_tile_pkey),
other_tiles(site_wire_pkey) AS (
SELECT node.site_wire_pkey FROM node
WHERE
pkey IN (SELECT other_node_pkey FROM other_nodes)
AND
classification = ?
)
SELECT tile.grid_x, tile.grid_y
FROM tile
WHERE pkey IN (
SELECT DISTINCT tile_pkey
FROM wire
WHERE pkey IN (
SELECT other_tiles.site_wire_pkey FROM other_tiles
)
);
""", (node_pkey, NodeClassification.EDGES_TO_CHANNEL.value)):
unique_pos.add((grid_x, grid_y))
# Determine segment for each routing resource.
segment_pkey = get_segment_for_node(cur2, segments, node_pkey)
tracks_to_insert.append(
create_track(node_pkey, unique_pos) + [segment_pkey]
)
# Create constant tracks
vcc_track_to_insert, gnd_track_to_insert = create_constant_tracks(conn)
# Assign constant networks special segments to given them dedicated
# router lookaheads.
cur.execute("SELECT pkey FROM segment WHERE name = ?", (VCC_NET, ))
vcc_segment_pkey = cur.fetchone()[0]
cur.execute("SELECT pkey FROM segment WHERE name = ?", (GND_NET, ))
gnd_segment_pkey = cur.fetchone()[0]
vcc_idx = len(tracks_to_insert)
tracks_to_insert.append(vcc_track_to_insert + [vcc_segment_pkey])
gnd_idx = len(tracks_to_insert)
tracks_to_insert.append(gnd_track_to_insert + [gnd_segment_pkey])
track_pkeys = insert_tracks(conn, segments, tracks_to_insert)
vcc_track_pkey = track_pkeys[vcc_idx]
gnd_track_pkey = track_pkeys[gnd_idx]
write_cur = conn.cursor()
write_cur.execute(
"""
INSERT INTO constant_sources(vcc_track_pkey, gnd_track_pkey) VALUES (?, ?)
""", (
vcc_track_pkey,
gnd_track_pkey,
)
)
# Create synthetic physical tile for constant network to assign a
# canonical location too.
#
# This location is not important, but exists for uniformity with other
# routing nodes.
write_cur.execute(
"""
INSERT INTO phy_tile(name, grid_x, grid_y) VALUES (?, ?, ?)
""", ("CONSTANT_SOURCE", 1, 1)
)
zero_phy_tile_pkey = write_cur.lastrowid
write_cur.execute(
"UPDATE track SET canon_phy_tile_pkey = ? WHERE pkey = ?", (
zero_phy_tile_pkey,
vcc_track_pkey,
)
)
write_cur.execute(
"UPDATE track SET canon_phy_tile_pkey = ? WHERE pkey = ?", (
zero_phy_tile_pkey,
gnd_track_pkey,
)
)
conn.commit()
connect_hardpins_to_constant_network(conn, vcc_track_pkey, gnd_track_pkey)
def connect_hardpins_to_constant_network(conn, vcc_track_pkey, gnd_track_pkey):
""" Connect TIEOFF HARD1 and HARD0 pins.
Update nodes connected to to HARD1 or HARD0 pins to point to the new
VCC or GND track. This should connect the pips to the constant
network instead of the TIEOFF site.
"""
cur = conn.cursor()
cur.execute(
"""
SELECT pkey FROM site_type WHERE name = ?
""", ("TIEOFF", )
)
results = cur.fetchall()
assert len(results) == 1, results
tieoff_site_type_pkey = results[0][0]
cur.execute(
"""
SELECT pkey FROM site_pin WHERE site_type_pkey = ? and name = ?
""", (tieoff_site_type_pkey, "HARD1")
)
vcc_site_pin_pkey = cur.fetchone()[0]
cur.execute(
"""
SELECT pkey FROM wire_in_tile WHERE site_pin_pkey = ?
""", (vcc_site_pin_pkey, )
)
cur.execute(
"""
SELECT pkey FROM wire_in_tile WHERE site_pin_pkey = ?
""", (vcc_site_pin_pkey, )
)
write_cur = conn.cursor()
write_cur.execute("""BEGIN EXCLUSIVE TRANSACTION;""")
for (wire_in_tile_pkey, ) in cur:
write_cur.execute(
"""
UPDATE node SET track_pkey = ? WHERE pkey IN (
SELECT node_pkey FROM wire WHERE wire_in_tile_pkey = ?
)
""", (
vcc_track_pkey,
wire_in_tile_pkey,
)
)
cur.execute(
"""
SELECT pkey FROM site_pin WHERE site_type_pkey = ? and name = ?
""", (tieoff_site_type_pkey, "HARD0")
)
gnd_site_pin_pkey = cur.fetchone()[0]
cur.execute(
"""
SELECT pkey FROM wire_in_tile WHERE site_pin_pkey = ?
""", (gnd_site_pin_pkey, )
)
for (wire_in_tile_pkey, ) in cur:
write_cur.execute(
"""
UPDATE node SET track_pkey = ? WHERE pkey IN (
SELECT node_pkey FROM wire WHERE wire_in_tile_pkey = ?
)
""", (
gnd_track_pkey,
wire_in_tile_pkey,
)
)
write_cur.execute("""COMMIT TRANSACTION""")
def traverse_pip(conn, wire_in_tile_pkey):
""" Given a generic wire, find (if any) the wire on the other side of a pip.
Returns None if no wire or pip connects to this wire.
"""
cur = conn.cursor()
cur.execute(
"""
SELECT src_wire_in_tile_pkey FROM pip_in_tile WHERE
is_pseudo = 0 AND
dest_wire_in_tile_pkey = ?
;""", (wire_in_tile_pkey, )
)
result = cur.fetchone()
if result is not None:
return result[0]
cur.execute(
"""
SELECT dest_wire_in_tile_pkey FROM pip_in_tile WHERE
is_pseudo = 0 AND
src_wire_in_tile_pkey = ?
;""", (wire_in_tile_pkey, )
)
result = cur.fetchone()
if result is not None:
return result[0]
return None
def update_wire_in_tile_types(
cur, write_cur, empty_tile_type_pkey, wire_in_tile_pkey_to_update
):
# Check if each wire in tile pkey can point to one logical tile type.
wire_in_tile_pkey_to_tile_type_pkey = {}
for tile_type_pkey, wire_in_tile_pkeys in wire_in_tile_pkey_to_update.items(
):
for wire_in_tile_pkey in wire_in_tile_pkeys:
if wire_in_tile_pkey not in wire_in_tile_pkey_to_tile_type_pkey:
wire_in_tile_pkey_to_tile_type_pkey[wire_in_tile_pkey] = set()
wire_in_tile_pkey_to_tile_type_pkey[wire_in_tile_pkey].add(
tile_type_pkey
)
wire_in_tile_pkey_to_updates = list(
wire_in_tile_pkey_to_tile_type_pkey.keys()
)
wire_in_tile_pkey_updates = []
for wire_in_tile_pkey in wire_in_tile_pkey_to_updates:
cur.execute(
"SELECT phy_tile_type_pkey FROM wire_in_tile WHERE pkey = ?",
(wire_in_tile_pkey, )
)
phy_tile_type_pkey = cur.fetchone()[0]
if phy_tile_type_pkey == empty_tile_type_pkey:
del wire_in_tile_pkey_to_tile_type_pkey[wire_in_tile_pkey]
continue
tile_type_pkeys = wire_in_tile_pkey_to_tile_type_pkey[wire_in_tile_pkey
]
assert len(tile_type_pkeys) == 1, (wire_in_tile_pkey, tile_type_pkeys)
wire_in_tile_pkey_updates.append(
(list(tile_type_pkeys)[0], wire_in_tile_pkey)
)
write_cur.executemany(
"""
UPDATE wire_in_tile
SET tile_type_pkey = ?
WHERE pkey = ?;""", wire_in_tile_pkey_updates
)
def create_vpr_grid(conn, grid_map_output):
""" Create VPR grid from prjxray grid. """
cur = conn.cursor()
cur2 = conn.cursor()
slice_types = {}
write_cur = conn.cursor()
write_cur.execute("""BEGIN EXCLUSIVE TRANSACTION;""")
# Insert synthetic tile types for CLB sites and iopad sites.
for name in [
'SLICEL',
'SLICEM',
'LIOPAD_M',
'LIOPAD_S',
'LIOPAD_SING',
'RIOPAD_M',
'RIOPAD_S',
'RIOPAD_SING',
]:
write_cur.execute('INSERT INTO tile_type(name) VALUES (?);', (name, ))
slice_types[name] = write_cur.lastrowid
write_cur.execute("""COMMIT TRANSACTION;""")
tiles_to_merge = {
'LIOB33_SING': tile_splitter.grid.EAST,
'LIOB33': tile_splitter.grid.EAST,
'RIOB33_SING': tile_splitter.grid.WEST,
'RIOB33': tile_splitter.grid.WEST,
}
tiles_to_split = {
'LIOI3': tile_splitter.grid.NORTH,
'LIOI3_TBYTESRC': tile_splitter.grid.NORTH,
'LIOI3_TBYTETERM': tile_splitter.grid.NORTH,
'LIOI3_SING': tile_splitter.grid.NORTH,
'RIOI3': tile_splitter.grid.NORTH,
'RIOI3_TBYTESRC': tile_splitter.grid.NORTH,
'RIOI3_TBYTETERM': tile_splitter.grid.NORTH,
'RIOI3_SING': tile_splitter.grid.NORTH,
}
liopad_ms_split = {
1: slice_types['LIOPAD_M'],
0: slice_types['LIOPAD_S'],
}
riopad_ms_split = {
1: slice_types['RIOPAD_M'],
0: slice_types['RIOPAD_S'],
}
split_styles = {
'LIOI3': ('y_split', liopad_ms_split),
'LIOI3_TBYTESRC': ('y_split', liopad_ms_split),
'LIOI3_TBYTETERM': ('y_split', liopad_ms_split),
'RIOI3': ('y_split', riopad_ms_split),
'RIOI3_TBYTESRC': ('y_split', riopad_ms_split),
'RIOI3_TBYTETERM': ('y_split', riopad_ms_split),
'LIOI3_SING': ('y_split', {
0: slice_types['LIOPAD_SING']
}),
'RIOI3_SING': ('y_split', {
0: slice_types['RIOPAD_SING']
}),
}
# Create initial grid using sites and locations from phy_tile's
# Also build up tile_to_tile_type_pkeys, which is a map from original
# tile_type_pkey, to array of split tile type pkeys, (e.g. SLICEL/SLICEM).
tile_to_tile_type_pkeys = {}
split_map = {}
grid_loc_map = {}
for phy_tile_pkey, tile_type_pkey, grid_x, grid_y in progressbar_utils.progressbar(
cur.execute("""
SELECT pkey, tile_type_pkey, grid_x, grid_y FROM phy_tile;
""")):
cur2.execute(
"SELECT name FROM tile_type WHERE pkey = ?;", (tile_type_pkey, )
)
tile_type_name = cur2.fetchone()[0]
sites = []
site_pkeys = set()
for (site_pkey, ) in cur2.execute("""
SELECT site_pkey FROM wire_in_tile WHERE tile_type_pkey = ? AND site_pkey IS NOT NULL;""",
(tile_type_pkey, )):
site_pkeys.add(site_pkey)
for site_pkey in site_pkeys:
cur2.execute(
"""
SELECT x_coord, y_coord, site_type_pkey
FROM site WHERE pkey = ?;""", (site_pkey, )
)
result = cur2.fetchone()
assert result is not None, (tile_type_pkey, site_pkey)
x, y, site_type_pkey = result
cur2.execute(
"SELECT name FROM site_type WHERE pkey = ?;",
((site_type_pkey, ))
)
site_type_name = cur2.fetchone()[0]
sites.append(
tile_splitter.grid.Site(
name=site_type_name,
phy_tile_pkey=phy_tile_pkey,
tile_type_pkey=tile_type_pkey,
site_type_pkey=site_type_pkey,
site_pkey=site_pkey,
x=x,
y=y
)
)
sites = sorted(sites, key=lambda s: (s.x, s.y))
if tile_type_name in tiles_to_split:
tile_type_pkeys = []
tile_split_map = {}
if split_styles[tile_type_name][0] == 'site_as_tile':
for idx, site in enumerate(sites):
tile_type_pkeys.append(slice_types[site.name])
tile_split_map[site.x, site.y] = idx
elif split_styles[tile_type_name][0] == 'y_split':
ys = set()
for site in sites:
ys.add(site.y)
ys = sorted(ys)
tile_type_pkeys = [
split_styles[tile_type_name][1][y] for y in ys
]
for site in sites:
tile_split_map[site.x, site.y] = ys.index(site.y)
else:
assert False, split_styles[tile_type_name]
if tile_type_name in tile_to_tile_type_pkeys:
assert tile_to_tile_type_pkeys[
tile_type_name] == tile_type_pkeys, (tile_type_name, )
assert split_map[tile_type_name] == tile_split_map, (
tile_type_name,
)
else:
tile_to_tile_type_pkeys[tile_type_name] = tile_type_pkeys
split_map[tile_type_name] = tile_split_map
grid_loc_map[(grid_x, grid_y)] = tile_splitter.grid.Tile(
root_phy_tile_pkeys=[phy_tile_pkey],
phy_tile_pkeys=[phy_tile_pkey],
tile_type_pkey=tile_type_pkey,
sites=sites
)
cur.execute('SELECT pkey FROM tile_type WHERE name = "NULL";')
empty_tile_type_pkey = cur.fetchone()[0]
tile_types = {}
tile_type_names = {}
for tile_type, _ in tiles_to_merge.items():
cur.execute(
'SELECT pkey FROM tile_type WHERE name = ?;', (tile_type, )
)
tile_type_pkey = cur.fetchone()
if tile_type_pkey is not None:
tile_type_pkey = tile_type_pkey[0]
tile_types[tile_type] = tile_type_pkey
tile_type_names[tile_type_pkey] = tile_type
for tile_type, _ in tiles_to_split.items():
cur.execute(
'SELECT pkey FROM tile_type WHERE name = ?;', (tile_type, )
)
tile_type_pkey = cur.fetchone()
if tile_type_pkey is not None:
tile_type_pkey = tile_type_pkey[0]
tile_types[tile_type] = tile_type_pkey
tile_type_names[tile_type_pkey] = tile_type
vpr_grid = tile_splitter.grid.Grid(
grid_loc_map=grid_loc_map, empty_tile_type_pkey=empty_tile_type_pkey
)
# Merge tiles first, so any splits account for sites the show up after a
# merge.
for tile_type, merge_direction in progressbar_utils.progressbar(
tiles_to_merge.items()):
if tile_type in tile_types:
vpr_grid.merge_tile_type(
tile_type_pkey=tile_types[tile_type],
merge_direction=merge_direction,
)
for tile_type, split_direction in progressbar_utils.progressbar(
tiles_to_split.items()):
if tile_type in tile_types:
vpr_grid.split_tile_type(
tile_type_pkey=tile_types[tile_type],
tile_type_pkeys=tile_to_tile_type_pkeys[tile_type],
split_direction=split_direction,
split_map=split_map[tile_type],
)
new_grid = vpr_grid.output_grid()
shifted_grid = {}
for (grid_x, grid_y), tile in new_grid.items():
# Shift grid away from 0 edges, which have limitations in VPR that
# complicate the rrgraph import process.
grid_x += 1
grid_y += 1
shifted_grid[(grid_x, grid_y)] = tile
new_grid = shifted_grid
write_cur.execute("""BEGIN EXCLUSIVE TRANSACTION;""")
# Create tile rows for each tile in the VPR grid. As provide map entries
# to physical grid and alias map from split tile type to original tile
# type.
for (grid_x, grid_y), tile in new_grid.items():
if tile.split_sites and len(tile.sites) == 1:
write_cur.execute(
"""
SELECT pkey, parent_tile_type_pkey FROM site_as_tile WHERE tile_type_pkey = ? AND site_pkey = ?""",
(tile.sites[0].tile_type_pkey, tile.sites[0].site_pkey)
)
result = write_cur.fetchone()
if result is None:
write_cur.execute(
"""
INSERT INTO
site_as_tile(parent_tile_type_pkey, tile_type_pkey, site_pkey)
VALUES
(?, ?, ?);""", (
tile.tile_type_pkey, tile.sites[0].tile_type_pkey,
tile.sites[0].site_pkey
)
)
site_as_tile_pkey = write_cur.lastrowid
else:
site_as_tile_pkey, parent_tile_type_pkey = result
assert parent_tile_type_pkey == tile.tile_type_pkey
# Mark that this tile is split by setting the site_as_tile_pkey.
write_cur.execute(
"""
INSERT INTO tile(phy_tile_pkey, tile_type_pkey, site_as_tile_pkey, grid_x, grid_y) VALUES (
?, ?, ?, ?, ?)""", (
tile.phy_tile_pkeys[0], tile.tile_type_pkey,
site_as_tile_pkey, grid_x, grid_y
)
)
else:
phy_tile_pkey = None
if len(tile.phy_tile_pkeys) > 0:
phy_tile_pkey = tile.phy_tile_pkeys[0]
write_cur.execute(
"""
INSERT INTO tile(phy_tile_pkey, tile_type_pkey, grid_x, grid_y) VALUES (
?, ?, ?, ?)""", (phy_tile_pkey, tile.tile_type_pkey, grid_x, grid_y)
)
tile_pkey = write_cur.lastrowid
# Build the phy_tile <-> tile map.
for phy_tile_pkey in tile.phy_tile_pkeys:
write_cur.execute(
"""
INSERT INTO tile_map(tile_pkey, phy_tile_pkey) VALUES (?, ?)
""", (tile_pkey, phy_tile_pkey)
)
# First assign all wires at the root_phy_tile_pkeys to this tile_pkey.
# This ensures all wires, (including wires without sites) have a home.
for root_phy_tile_pkey in tile.root_phy_tile_pkeys:
write_cur.execute(
"""
UPDATE
wire
SET
tile_pkey = ?
WHERE
phy_tile_pkey = ?
;""", (tile_pkey, root_phy_tile_pkey)
)
write_cur.execute(
"CREATE INDEX tile_location_index ON tile(grid_x, grid_y);"
)
write_cur.execute("CREATE INDEX tile_to_phy_map ON tile_map(tile_pkey);")
write_cur.execute(
"CREATE INDEX phy_to_tile_map ON tile_map(phy_tile_pkey);"
)
write_cur.execute("""COMMIT TRANSACTION;""")
write_cur.execute("""BEGIN EXCLUSIVE TRANSACTION;""")
# Track wire_in_tile_pkey's to update to new tile types.
wire_in_tile_pkey_to_update = {}
# At this point all wires have a tile_pkey that corrisponds to the old root
# tile. Wires belonging to sites need to be reassigned to their respective
# tiles.
for (grid_x, grid_y), tile in new_grid.items():
cur2.execute(
"SELECT pkey, tile_type_pkey FROM tile WHERE grid_x = ? AND grid_y = ?;",
(grid_x, grid_y)
)
tile_pkey, tile_type_pkey = cur2.fetchone()
for site in tile.sites:
# Find all wires that belong to the new tile location.
for wire_pkey, wire_in_tile_pkey in cur2.execute("""
WITH wires(wire_pkey, wire_in_tile_pkey) AS (
SELECT
pkey, wire_in_tile_pkey
FROM
wire
WHERE
phy_tile_pkey = ?
)
SELECT
wires.wire_pkey, wires.wire_in_tile_pkey
FROM
wires
INNER JOIN
wire_in_tile
ON
wire_in_tile.pkey = wires.wire_in_tile_pkey
WHERE
wire_in_tile.site_pkey = ?
;""", (site.phy_tile_pkey, site.site_pkey)):
# Move the wire to the new tile_pkey.
write_cur.execute(
"""
UPDATE
wire
SET
tile_pkey = ?
WHERE
pkey = ?;""", (
tile_pkey,
wire_pkey,
)
)
if tile_type_pkey not in wire_in_tile_pkey_to_update:
wire_in_tile_pkey_to_update[tile_type_pkey] = set()
wire_in_tile_pkey_to_update[tile_type_pkey].add(
wire_in_tile_pkey
)
# Wires connected to the site via a pip require traversing the
# pip.
other_wire_in_tile_pkey = traverse_pip(conn, wire_in_tile_pkey)
if other_wire_in_tile_pkey is not None:
cur.execute(
"""
SELECT classification
FROM node
WHERE pkey = (
SELECT node_pkey
FROM wire
WHERE
phy_tile_pkey = ?
AND
wire_in_tile_pkey = ?
)
;""", (site.phy_tile_pkey, other_wire_in_tile_pkey)
)
classification = NodeClassification(cur.fetchone()[0])
if classification != NodeClassification.CHANNEL:
continue
# A wire was found connected to the site via pip, reassign
# tile_pkey.
write_cur.execute(
"""
UPDATE
wire
SET
tile_pkey = ?
WHERE
phy_tile_pkey = ?
AND
wire_in_tile_pkey = ?
;""", (tile_pkey, site.phy_tile_pkey, other_wire_in_tile_pkey)
)
# Now that final wire <-> tile assignments are made, create the index.
write_cur.execute(
"CREATE INDEX tile_wire_index ON wire(wire_in_tile_pkey, tile_pkey, node_pkey);"
)
write_cur.execute(
"CREATE INDEX node_tile_wire_index ON wire(node_pkey, tile_pkey, wire_in_tile_pkey);"
)
# Update tile_type_pkey in wire_in_tile table.
update_wire_in_tile_types(
cur, write_cur, empty_tile_type_pkey, wire_in_tile_pkey_to_update
)
write_cur.execute("""COMMIT TRANSACTION;""")
write_cur.execute("""BEGIN EXCLUSIVE TRANSACTION;""")
write_cur.execute("ANALYZE")
write_cur.execute("""COMMIT TRANSACTION;""")
# Now that the final VPR grid is generated, we need a fast lookup to easily
# access to the canonical to VPR grid mapping.
#
# Furthermore, information on the internal tile connections between sites belonging
# to the same tile, which are treated as heterogeneous tiles. These connections are
# required to correctly instruct VPR on the presence of direct connections between
# sites at the same X, Y coordinate, but with different sub tile coordinates.
fieldnames = [
"site_name",
"site_type",
"physical_tile",
"vpr_x",
"vpr_y",
"canon_x",
"canon_y",
"clock_region",
"connected_to_site",
]
csv_writer = csv.DictWriter(grid_map_output, fieldnames=fieldnames)
csv_writer.writeheader()
# Find all sites that have direct connections with other sites in the same tile.
sites_with_direct = dict()
for src_wire_pkey, dest_wire_pkey, pip_in_tile_pkey in \
progressbar_utils.progressbar(
cur.execute("""
SELECT
src_wire_pkey,
dest_wire_pkey,
pip_in_tile_pkey
FROM
edge_with_mux""")):
cur2.execute(
"""
SELECT node_pkey FROM wire WHERE pkey = ?""", (src_wire_pkey, )
)
(src_node_pkey, ) = cur2.fetchone()
# Find the wire connected to the source.
src_wire = list(node_to_site_pins(conn, src_node_pkey))
assert len(src_wire) == 1
_, src_tile_pkey, src_wire_in_tile_pkey = src_wire[0]
cur2.execute(
"""
SELECT tile_type_pkey, grid_x, grid_y FROM tile WHERE pkey = ?""",
(src_tile_pkey, )
)
res = cur2.fetchone()
src_tile_type_pkey, src_grid_x, src_grid_y = res
# Get the node that is attached to the sink.
cur2.execute(
"""
SELECT node_pkey FROM wire WHERE pkey = ?""", (dest_wire_pkey, )
)
(dest_node_pkey, ) = cur2.fetchone()
# Find the wire connected to the sink.
dest_wire = list(node_to_site_pins(conn, dest_node_pkey))
assert len(dest_wire) == 1
_, dest_tile_pkey, dest_wire_in_tile_pkey = dest_wire[0]
cur2.execute(
"""
SELECT tile_type_pkey, grid_x, grid_y FROM tile WHERE pkey = ?;""",
(dest_tile_pkey, )
)
res = cur2.fetchone()
dest_tile_type_pkey, dest_grid_x, dest_grid_y = res
if dest_grid_x == src_grid_x and dest_grid_y == src_grid_y:
tile = new_grid[(dest_grid_x, dest_grid_y)]
cur2.execute(
"SELECT site_pkey FROM wire_in_tile WHERE pkey = ?",
(src_wire_in_tile_pkey, )
)
src_site_pkey = cur2.fetchone()[0]
cur2.execute(
"SELECT site_pkey FROM wire_in_tile WHERE pkey = ?",
(dest_wire_in_tile_pkey, )
)
dest_site_pkey = cur2.fetchone()[0]
src_site_instance = None
dest_site_instance = None
for site in tile.sites:
cur2.execute(
"SELECT name FROM site_instance WHERE site_pkey = ? AND phy_tile_pkey = ?"
"", (
site.site_pkey,
site.phy_tile_pkey,
)
)
res = cur2.fetchone()[0]
if site.site_pkey == src_site_pkey:
src_site_instance = res
elif site.site_pkey == dest_site_pkey:
dest_site_instance = res
assert src_site_instance and dest_site_instance
sites_with_direct[src_site_instance] = dest_site_instance
# Build the Canonical to VPR grid mapping
for (grid_x, grid_y), tile in new_grid.items():
for site in tile.sites:
cur.execute(
"SELECT name FROM site_instance WHERE site_pkey = ? AND phy_tile_pkey = ?",
(
site.site_pkey,
site.phy_tile_pkey,
)
)
site_name = cur.fetchone()[0]
cur.execute(
"SELECT name, clock_region_pkey, grid_x, grid_y FROM phy_tile WHERE pkey = ?",
(site.phy_tile_pkey, )
)
phy_tile_name, clock_region, canon_x, canon_y = cur.fetchone()
cur.execute(
"SELECT name FROM site_type WHERE pkey = ?",
(site.site_type_pkey, )
)
site_type = cur.fetchone()[0]
# This is a site which is directly connected to the current site
# and will be implemented as a sub_tile. This information is relevant
# to generate correct placement constraints for sub_tiles directly
# connected within the same physical tile
connected_to_site = sites_with_direct.get(site_name, None)
csv_writer.writerow(
{
"site_name": site_name,
"site_type": site_type,
"physical_tile": phy_tile_name,
"vpr_x": grid_x,
"vpr_y": grid_y,
"canon_x": canon_x,
"canon_y": canon_y,
"clock_region": clock_region,
"connected_to_site": connected_to_site
}
)
def create_constant_tracks(conn):
""" Create two tracks that go to all TIEOFF sites to route constants.
Returns (vcc_track_to_insert, gnd_track_to_insert), suitable for insert
via insert_tracks function.
"""
# Make constant track available to all tiles.
write_cur = conn.cursor()
unique_pos = set()
write_cur.execute('SELECT grid_x, grid_y FROM tile')
for grid_x, grid_y in write_cur:
if grid_x == 0 or grid_y == 0:
continue
unique_pos.add((grid_x, grid_y))
write_cur.execute(
"""
INSERT INTO node(classification) VALUES (?)
""", (NodeClassification.CHANNEL.value, )
)
vcc_node = write_cur.lastrowid
write_cur.execute(
"""
INSERT INTO node(classification) VALUES (?)
""", (NodeClassification.CHANNEL.value, )
)
gnd_node = write_cur.lastrowid
conn.commit()
return create_track(vcc_node,
unique_pos), create_track(gnd_node, unique_pos)
def import_segments(conn, db):
""" Create segment table, use segment definitions from SegmentWireMap.
Parameters
----------
conn : sqlite3.Connection
Connection to channels.db
db : prjxray.Database
Project X-Ray database object.
Returns
-------
SegmentWireMap
SegmentWireMap can be used to detect which segment a wire belongs too.
"""
write_cur = conn.cursor()
default_segment = "unknown"
segments = SegmentWireMap(default_segment=default_segment, db=db)
# Add some additional useful segments that are not part of the wire map
# (e.g. the global constant networks).
for extra_segment in [default_segment, VCC_NET, GND_NET]:
if extra_segment not in segments.get_segments():
write_cur.execute(
"""
INSERT INTO segment(name) VALUES (?)
""", (extra_segment, )
)
for segment in segments.get_segments():
write_cur.execute(
"""
INSERT INTO segment(name) VALUES (?)
""", (segment, )
)
write_cur.execute("CREATE INDEX segment_name_map ON segment(name);")
conn.commit()
return segments
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'--db_root', help='Project X-Ray Database', required=True
)
parser.add_argument('--part', help='FPGA part', required=True)
parser.add_argument(
'--connection_database', help='Connection database', required=True
)
parser.add_argument(
'--grid_map_output',
help='Location of the grid map output',
required=True
)
args = parser.parse_args()
if os.path.exists(args.connection_database):
os.remove(args.connection_database)
with DatabaseCache(args.connection_database) as conn:
create_tables(conn)
print("{}: About to load database".format(datetime.datetime.now()))
db = prjxray.db.Database(args.db_root, args.part)
grid = db.grid()
get_switch, get_switch_timing = create_get_switch(conn)
import_phy_grid(db, grid, conn, get_switch, get_switch_timing)
segments = import_segments(conn, db)
print("{}: Initial database formed".format(datetime.datetime.now()))
import_nodes(db, grid, conn)
print("{}: Connections made".format(datetime.datetime.now()))
count_sites_and_pips_on_nodes(conn)
print("{}: Counted sites and pips".format(datetime.datetime.now()))
classify_nodes(conn, get_switch_timing)
print("{}: Create VPR grid".format(datetime.datetime.now()))
with open(args.grid_map_output, 'w') as f:
create_vpr_grid(conn, f)
print("{}: Nodes classified".format(datetime.datetime.now()))
form_tracks(conn, segments)
print("{}: Tracks formed".format(datetime.datetime.now()))
print(
'{} Flushing database back to file "{}"'.format(
datetime.datetime.now(), args.connection_database
)
)
if __name__ == '__main__':
main()