utils/lib/connection_database.py - symbiflow-arch-defs - Git at Google

 import enum
 import os
 from lib.rr_graph import graph2
 from lib.rr_graph import tracks


 class NodeClassification(enum.Enum):
     NULL = 1
     CHANNEL = 2
     EDGES_TO_CHANNEL = 3
     EDGE_WITH_MUX = 4


 def create_tables(conn):
     """ Create connection database scheme. """
     connection_database_sql_file = os.path.join(
         os.path.dirname(__file__), "connection_database.sql"
     )
     with open(connection_database_sql_file, 'r') as f:
         c = conn.cursor()
         c.executescript(f.read())
         conn.commit()

     c = conn.cursor()
     c.execute(
         """
 INSERT INTO
     switch(name, internal_capacitance, drive_resistance, intrinsic_delay, switch_type)
 VALUES
     ("__vpr_delayless_switch__", 0.0, 0.0, 0.0, "mux"),
     ("short", 0.0, 0.0, 0.0, "short")
 """
     )
     conn.commit()


 def get_wire_pkey(conn, tile_name, wire):
     c = conn.cursor()
     c.execute(
         """
 WITH selected_tile(phy_tile_pkey, tile_type_pkey) AS (
   SELECT
     pkey,
     tile_type_pkey
   FROM
     phy_tile
   WHERE
     name = ?
 )
 SELECT
   wire.pkey
 FROM
   wire
 WHERE
   wire.phy_tile_pkey = (
     SELECT
       selected_tile.phy_tile_pkey
     FROM
       selected_tile
   )
   AND wire.wire_in_tile_pkey = (
     SELECT
       wire_in_tile.pkey
     FROM
       wire_in_tile
     WHERE
       wire_in_tile.name = ?
       AND wire_in_tile.tile_type_pkey = (
         SELECT
           tile_type_pkey
         FROM
           selected_tile
       )
   );
 """, (tile_name, wire)
     )

     results = c.fetchone()
     assert results is not None, (tile_name, wire)
     return results[0]


 def get_track_model(conn, track_pkey):
     assert track_pkey is not None

     track_list = []
     track_nodes = []
     c2 = conn.cursor()
     graph_node_pkey = {}
     for idx, (pkey, graph_node_type, x_low, x_high, y_low,
               y_high) in enumerate(c2.execute("""
     SELECT pkey, graph_node_type, x_low, x_high, y_low, y_high
       FROM graph_node WHERE track_pkey = ?""", (track_pkey, ))):
         node_type = graph2.NodeType(graph_node_type)
         if node_type == graph2.NodeType.CHANX:
             direction = 'X'
         elif node_type == graph2.NodeType.CHANY:
             direction = 'Y'

         graph_node_pkey[pkey] = idx
         track_nodes.append(pkey)
         track_list.append(
             tracks.Track(
                 direction=direction,
                 x_low=x_low,
                 x_high=x_high,
                 y_low=y_low,
                 y_high=y_high
             )
         )

     track_connections = set()
     for src_graph_node_pkey, dest_graph_node_pkey in c2.execute("""
     SELECT src_graph_node_pkey, dest_graph_node_pkey
         FROM graph_edge WHERE track_pkey = ?""", (track_pkey, )):

         src_idx = graph_node_pkey[src_graph_node_pkey]
         dest_idx = graph_node_pkey[dest_graph_node_pkey]

         track_connections.add(tuple(sorted((src_idx, dest_idx))))

     tracks_model = tracks.Tracks(track_list, list(track_connections))

     return tracks_model, track_nodes


 def yield_wire_info_from_node(conn, node_pkey):
     """ Yield tile types and wires attached to specified node.

     Parameters
     ----------
     conn : sqlite3.Connection
         Connection database object.
     node_pkey : int
         Primary key into node table

     Yields
     -------
     tile_type : str
         Name of tile type for wire being yielded.
     wire : str
         Name of wire for wire being yielded.

     Note: This function yields the prjxray tile_type and wire name.  This
     function does NOT tile_type's and wire names coorsponding to the VPR tiles.

     """
     c2 = conn.cursor()
     for tile_type, wire in c2.execute("""
 WITH wires_in_node(phy_tile_pkey, wire_in_tile_pkey) AS (
   SELECT
     phy_tile_pkey,
     wire_in_tile_pkey
   FROM
     wire
   WHERE
     node_pkey = ?
 ),
 tile_for_wire(
   wire_in_tile_pkey, tile_type_pkey
 ) AS (
   SELECT
     wires_in_node.wire_in_tile_pkey,
     phy_tile.tile_type_pkey
   FROM
     phy_tile
     INNER JOIN wires_in_node ON phy_tile.pkey = wires_in_node.phy_tile_pkey
 ),
 tile_type_for_wire(
   wire_in_tile_pkey, tile_type_name
 ) AS (
   SELECT
     tile_for_wire.wire_in_tile_pkey,
     tile_type.name
   FROM
     tile_type
     INNER JOIN tile_for_wire ON tile_type.pkey = tile_for_wire.tile_type_pkey
 )
 SELECT
   tile_type_for_wire.tile_type_name,
   wire_in_tile.name
 FROM
   wire_in_tile
   INNER JOIN tile_type_for_wire ON tile_type_for_wire.wire_in_tile_pkey = wire_in_tile.pkey;
     """, (node_pkey, )):
         yield tile_type, wire


 def yield_logical_wire_info_from_node(conn, node_pkey):
     """ Yield tile types and wires attached to specified node.

     Parameters
     ----------
     conn : sqlite3.Connection
         Connection database object.
     node_pkey : int
         Primary key into node table

     Yields
     -------
     tile_type : str
         Name of tile type for wire being yielded.
     wire : str
         Name of wire for wire being yielded.

     Note: This function yields the prjxray tile_type and wire name.  This
     function does NOT tile_type's and wire names coorsponding to the VPR tiles.

     """
     c2 = conn.cursor()
     for tile_type, wire in c2.execute("""
 WITH wires_in_node(tile_pkey, wire_in_tile_pkey) AS (
   SELECT
     tile_pkey,
     wire_in_tile_pkey
   FROM
     wire
   WHERE
     node_pkey = ?
 ),
 tile_for_wire(
   wire_in_tile_pkey, tile_type_pkey
 ) AS (
   SELECT
     wires_in_node.wire_in_tile_pkey,
     tile.tile_type_pkey
   FROM
     tile
     INNER JOIN wires_in_node ON tile.pkey = wires_in_node.tile_pkey
 ),
 tile_type_for_wire(
   wire_in_tile_pkey, tile_type_name
 ) AS (
   SELECT
     tile_for_wire.wire_in_tile_pkey,
     tile_type.name
   FROM
     tile_type
     INNER JOIN tile_for_wire ON tile_type.pkey = tile_for_wire.tile_type_pkey
 )
 SELECT
   tile_type_for_wire.tile_type_name,
   wire_in_tile.name
 FROM
   wire_in_tile
   INNER JOIN tile_type_for_wire ON tile_type_for_wire.wire_in_tile_pkey = wire_in_tile.pkey;
     """, (node_pkey, )):
         yield tile_type, wire


 def node_to_site_pins(conn, node_pkey):
     FIND_WIRE_WITH_SITE_PIN = """
 WITH wires_in_node(
   pkey, tile_pkey, wire_in_tile_pkey
 ) AS (
   SELECT
     pkey,
     tile_pkey,
     wire_in_tile_pkey
   FROM
     wire
   WHERE
     node_pkey = ?
 )
 SELECT
   wires_in_node.pkey,
   wires_in_node.tile_pkey,
   wire_in_tile.pkey
 FROM
   wires_in_node
   INNER JOIN wire_in_tile ON wires_in_node.wire_in_tile_pkey = wire_in_tile.pkey
 WHERE
   wire_in_tile.site_pin_pkey IS NOT NULL;
 """

     c = conn.cursor()
     for wire_pkey, tile_pkey, wire_in_tile_pkey in c.execute(
             FIND_WIRE_WITH_SITE_PIN, (node_pkey, )):
         yield wire_pkey, tile_pkey, wire_in_tile_pkey


 def get_pin_name_of_wire(conn, wire_pkey):
     """ Returns pin name of wire.

     For unsplit tiles, this is the name of the wire.
     For split tiles with only 1 site, this is the name of the site pin
     connected to this wire.
     For wires that are not a pin, returns None.

     Parameters
     ----------
     conn : sqlite3.Connection
         Connection database object.
     wire_pkey : int
         Primary key into wire table

     Returns
     -------
     pin : str
         VPR pin name for given wire_pkey.
         Returns none if this wire is not a pin.

     """
     c = conn.cursor()
     c.execute(
         """
 SELECT wire_in_tile_pkey, tile_pkey FROM wire WHERE pkey = ?
         """, (wire_pkey, )
     )
     wire_in_tile_pkey, tile_pkey = c.fetchone()

     c.execute(
         """
 SELECT site_as_tile_pkey FROM tile WHERE pkey = ?
         """, (tile_pkey, )
     )
     site_as_tile_pkey = c.fetchone()[0]

     c.execute(
         """
 SELECT name, site_pin_pkey FROM wire_in_tile WHERE pkey = ?;
     """, (wire_in_tile_pkey, )
     )
     wire_name, site_pin_pkey = c.fetchone()

     if site_pin_pkey is None:
         return None

     if site_as_tile_pkey is not None:
         c.execute(
             "SELECT name FROM site_pin WHERE pkey = ?", (site_pin_pkey, )
         )
         return c.fetchone()[0]
     else:
         return wire_name


 def get_wire_in_tile_from_pin_name(conn, tile_type_str, wire_str):
     """ Returns wire_in_tile rows match specified tile type and pin name.

     Because a split tile type can appear in multiple tiles (e.g. SLICEL in
     CLBLL_L, CLBLL_R, etc), multiple wire_in_tile rows may be returned. The
     site table primary key disambiguates which row to use.

     Parameters
     ----------
     conn : sqlite3.Connection
         Connection database object.
     tile_type_str : str
         Name of tile_type this pin belongs to.
     wire_str : str
         Name of pin to get wire_in_tile rows for.

     Returns
     -------
     wire_in_tile_pkeys : dict of int to int
         Map of site table primary keys to wire_in_tile primary keys.  Unsplit
         tiles will always have only one dictionary entry.  Split tiles may have
         more than one.
     site_pin_pkey : int
         Row into site_pin table for this pin.

     """
     # Find the generic wire_in_tile_pkey for the specified tile_type name and
     # wire name.
     c = conn.cursor()

     # Find if this tile_type is a split tile.
     c.execute(
         """
 SELECT
   site_pkey
 FROM
   site_as_tile
 WHERE
   parent_tile_type_pkey = (
     SELECT
       pkey
     FROM
       tile_type
     WHERE
       name = ?
   );
         """, (tile_type_str, )
     )
     result = c.fetchone()
     wire_is_pin = result is not None

     if wire_is_pin:
         # This tile is a split tile, lookup for the wire_in_tile_pkey is based
         # on the site pin name, rather than the wire name.
         site_pkey = result[0]
         c.execute(
             """
 SELECT
   pkey,
   site_pin_pkey,
   site_pkey
 FROM
   wire_in_tile
 WHERE
   site_pin_pkey = (
     SELECT
       pkey
     FROM
       site_pin
     WHERE
       site_type_pkey = (
         SELECT
           site_type_pkey
         FROM
           site
         WHERE
           pkey = ?
       )
       AND name = ?
   );""", (site_pkey, wire_str)
         )
     else:
         c.execute(
             """
 SELECT
   pkey,
   site_pin_pkey,
   site_pkey
 FROM
   wire_in_tile
 WHERE
   name = ?
   and tile_type_pkey = (
     SELECT
       pkey
     FROM
       tile_type
     WHERE
       name = ?
   );
 """, (wire_str, tile_type_str)
         )

     wire_in_tile_pkeys = {}
     the_site_pin_pkey = None
     for wire_in_tile_pkey, site_pin_pkey, site_pkey in c:
         wire_in_tile_pkeys[site_pkey] = wire_in_tile_pkey

         if the_site_pin_pkey is not None:
             assert the_site_pin_pkey == site_pin_pkey, (
                 tile_type_str, wire_str
             )
         else:
             the_site_pin_pkey = site_pin_pkey

     assert the_site_pin_pkey is not None, (tile_type_str, wire_str)

     return wire_in_tile_pkeys, the_site_pin_pkey
	import enum
	import os
	from lib.rr_graph import graph2
	from lib.rr_graph import tracks


	class NodeClassification(enum.Enum):
	NULL = 1
	CHANNEL = 2
	EDGES_TO_CHANNEL = 3
	EDGE_WITH_MUX = 4


	def create_tables(conn):
	""" Create connection database scheme. """
	connection_database_sql_file = os.path.join(
	os.path.dirname(__file__), "connection_database.sql"
	)
	with open(connection_database_sql_file, 'r') as f:
	c = conn.cursor()
	c.executescript(f.read())
	conn.commit()

	c = conn.cursor()
	c.execute(
	"""
	INSERT INTO
	switch(name, internal_capacitance, drive_resistance, intrinsic_delay, switch_type)
	VALUES
	("__vpr_delayless_switch__", 0.0, 0.0, 0.0, "mux"),
	("short", 0.0, 0.0, 0.0, "short")
	"""
	)
	conn.commit()


	def get_wire_pkey(conn, tile_name, wire):
	c = conn.cursor()
	c.execute(
	"""
	WITH selected_tile(phy_tile_pkey, tile_type_pkey) AS (
	SELECT
	pkey,
	tile_type_pkey
	FROM
	phy_tile
	WHERE
	name = ?
	)
	SELECT
	wire.pkey
	FROM
	wire
	WHERE
	wire.phy_tile_pkey = (
	SELECT
	selected_tile.phy_tile_pkey
	FROM
	selected_tile
	)
	AND wire.wire_in_tile_pkey = (
	SELECT
	wire_in_tile.pkey
	FROM
	wire_in_tile
	WHERE
	wire_in_tile.name = ?
	AND wire_in_tile.tile_type_pkey = (
	SELECT
	tile_type_pkey
	FROM
	selected_tile
	)
	);
	""", (tile_name, wire)
	)

	results = c.fetchone()
	assert results is not None, (tile_name, wire)
	return results[0]


	def get_track_model(conn, track_pkey):
	assert track_pkey is not None

	track_list = []
	track_nodes = []
	c2 = conn.cursor()
	graph_node_pkey = {}
	for idx, (pkey, graph_node_type, x_low, x_high, y_low,
	y_high) in enumerate(c2.execute("""
	SELECT pkey, graph_node_type, x_low, x_high, y_low, y_high
	FROM graph_node WHERE track_pkey = ?""", (track_pkey, ))):
	node_type = graph2.NodeType(graph_node_type)
	if node_type == graph2.NodeType.CHANX:
	direction = 'X'
	elif node_type == graph2.NodeType.CHANY:
	direction = 'Y'

	graph_node_pkey[pkey] = idx
	track_nodes.append(pkey)
	track_list.append(
	tracks.Track(
	direction=direction,
	x_low=x_low,
	x_high=x_high,
	y_low=y_low,
	y_high=y_high
	)
	)

	track_connections = set()
	for src_graph_node_pkey, dest_graph_node_pkey in c2.execute("""
	SELECT src_graph_node_pkey, dest_graph_node_pkey
	FROM graph_edge WHERE track_pkey = ?""", (track_pkey, )):

	src_idx = graph_node_pkey[src_graph_node_pkey]
	dest_idx = graph_node_pkey[dest_graph_node_pkey]

	track_connections.add(tuple(sorted((src_idx, dest_idx))))

	tracks_model = tracks.Tracks(track_list, list(track_connections))

	return tracks_model, track_nodes


	def yield_wire_info_from_node(conn, node_pkey):
	""" Yield tile types and wires attached to specified node.

	Parameters
	----------
	conn : sqlite3.Connection
	Connection database object.
	node_pkey : int
	Primary key into node table

	Yields
	-------
	tile_type : str
	Name of tile type for wire being yielded.
	wire : str
	Name of wire for wire being yielded.

	Note: This function yields the prjxray tile_type and wire name. This
	function does NOT tile_type's and wire names coorsponding to the VPR tiles.

	"""
	c2 = conn.cursor()
	for tile_type, wire in c2.execute("""
	WITH wires_in_node(phy_tile_pkey, wire_in_tile_pkey) AS (
	SELECT
	phy_tile_pkey,
	wire_in_tile_pkey
	FROM
	wire
	WHERE
	node_pkey = ?
	),
	tile_for_wire(
	wire_in_tile_pkey, tile_type_pkey
	) AS (
	SELECT
	wires_in_node.wire_in_tile_pkey,
	phy_tile.tile_type_pkey
	FROM
	phy_tile
	INNER JOIN wires_in_node ON phy_tile.pkey = wires_in_node.phy_tile_pkey
	),
	tile_type_for_wire(
	wire_in_tile_pkey, tile_type_name
	) AS (
	SELECT
	tile_for_wire.wire_in_tile_pkey,
	tile_type.name
	FROM
	tile_type
	INNER JOIN tile_for_wire ON tile_type.pkey = tile_for_wire.tile_type_pkey
	)
	SELECT
	tile_type_for_wire.tile_type_name,
	wire_in_tile.name
	FROM
	wire_in_tile
	INNER JOIN tile_type_for_wire ON tile_type_for_wire.wire_in_tile_pkey = wire_in_tile.pkey;
	""", (node_pkey, )):
	yield tile_type, wire


	def yield_logical_wire_info_from_node(conn, node_pkey):
	""" Yield tile types and wires attached to specified node.

	Parameters
	----------
	conn : sqlite3.Connection
	Connection database object.
	node_pkey : int
	Primary key into node table

	Yields
	-------
	tile_type : str
	Name of tile type for wire being yielded.
	wire : str
	Name of wire for wire being yielded.

	Note: This function yields the prjxray tile_type and wire name. This
	function does NOT tile_type's and wire names coorsponding to the VPR tiles.

	"""
	c2 = conn.cursor()
	for tile_type, wire in c2.execute("""
	WITH wires_in_node(tile_pkey, wire_in_tile_pkey) AS (
	SELECT
	tile_pkey,
	wire_in_tile_pkey
	FROM
	wire
	WHERE
	node_pkey = ?
	),
	tile_for_wire(
	wire_in_tile_pkey, tile_type_pkey
	) AS (
	SELECT
	wires_in_node.wire_in_tile_pkey,
	tile.tile_type_pkey
	FROM
	tile
	INNER JOIN wires_in_node ON tile.pkey = wires_in_node.tile_pkey
	),
	tile_type_for_wire(
	wire_in_tile_pkey, tile_type_name
	) AS (
	SELECT
	tile_for_wire.wire_in_tile_pkey,
	tile_type.name
	FROM
	tile_type
	INNER JOIN tile_for_wire ON tile_type.pkey = tile_for_wire.tile_type_pkey
	)
	SELECT
	tile_type_for_wire.tile_type_name,
	wire_in_tile.name
	FROM
	wire_in_tile
	INNER JOIN tile_type_for_wire ON tile_type_for_wire.wire_in_tile_pkey = wire_in_tile.pkey;
	""", (node_pkey, )):
	yield tile_type, wire


	def node_to_site_pins(conn, node_pkey):
	FIND_WIRE_WITH_SITE_PIN = """
	WITH wires_in_node(
	pkey, tile_pkey, wire_in_tile_pkey
	) AS (
	SELECT
	pkey,
	tile_pkey,
	wire_in_tile_pkey
	FROM
	wire
	WHERE
	node_pkey = ?
	)
	SELECT
	wires_in_node.pkey,
	wires_in_node.tile_pkey,
	wire_in_tile.pkey
	FROM
	wires_in_node
	INNER JOIN wire_in_tile ON wires_in_node.wire_in_tile_pkey = wire_in_tile.pkey
	WHERE
	wire_in_tile.site_pin_pkey IS NOT NULL;
	"""

	c = conn.cursor()
	for wire_pkey, tile_pkey, wire_in_tile_pkey in c.execute(
	FIND_WIRE_WITH_SITE_PIN, (node_pkey, )):
	yield wire_pkey, tile_pkey, wire_in_tile_pkey


	def get_pin_name_of_wire(conn, wire_pkey):
	""" Returns pin name of wire.

	For unsplit tiles, this is the name of the wire.
	For split tiles with only 1 site, this is the name of the site pin
	connected to this wire.
	For wires that are not a pin, returns None.

	Parameters
	----------
	conn : sqlite3.Connection
	Connection database object.
	wire_pkey : int
	Primary key into wire table

	Returns
	-------
	pin : str
	VPR pin name for given wire_pkey.
	Returns none if this wire is not a pin.

	"""
	c = conn.cursor()
	c.execute(
	"""
	SELECT wire_in_tile_pkey, tile_pkey FROM wire WHERE pkey = ?
	""", (wire_pkey, )
	)
	wire_in_tile_pkey, tile_pkey = c.fetchone()

	c.execute(
	"""
	SELECT site_as_tile_pkey FROM tile WHERE pkey = ?
	""", (tile_pkey, )
	)
	site_as_tile_pkey = c.fetchone()[0]

	c.execute(
	"""
	SELECT name, site_pin_pkey FROM wire_in_tile WHERE pkey = ?;
	""", (wire_in_tile_pkey, )
	)
	wire_name, site_pin_pkey = c.fetchone()

	if site_pin_pkey is None:
	return None

	if site_as_tile_pkey is not None:
	c.execute(
	"SELECT name FROM site_pin WHERE pkey = ?", (site_pin_pkey, )
	)
	return c.fetchone()[0]
	else:
	return wire_name


	def get_wire_in_tile_from_pin_name(conn, tile_type_str, wire_str):
	""" Returns wire_in_tile rows match specified tile type and pin name.

	Because a split tile type can appear in multiple tiles (e.g. SLICEL in
	CLBLL_L, CLBLL_R, etc), multiple wire_in_tile rows may be returned. The
	site table primary key disambiguates which row to use.

	Parameters
	----------
	conn : sqlite3.Connection
	Connection database object.
	tile_type_str : str
	Name of tile_type this pin belongs to.
	wire_str : str
	Name of pin to get wire_in_tile rows for.

	Returns
	-------
	wire_in_tile_pkeys : dict of int to int
	Map of site table primary keys to wire_in_tile primary keys. Unsplit
	tiles will always have only one dictionary entry. Split tiles may have
	more than one.
	site_pin_pkey : int
	Row into site_pin table for this pin.

	"""
	# Find the generic wire_in_tile_pkey for the specified tile_type name and
	# wire name.
	c = conn.cursor()

	# Find if this tile_type is a split tile.
	c.execute(
	"""
	SELECT
	site_pkey
	FROM
	site_as_tile
	WHERE
	parent_tile_type_pkey = (
	SELECT
	pkey
	FROM
	tile_type
	WHERE
	name = ?
	);
	""", (tile_type_str, )
	)
	result = c.fetchone()
	wire_is_pin = result is not None

	if wire_is_pin:
	# This tile is a split tile, lookup for the wire_in_tile_pkey is based
	# on the site pin name, rather than the wire name.
	site_pkey = result[0]
	c.execute(
	"""
	SELECT
	pkey,
	site_pin_pkey,
	site_pkey
	FROM
	wire_in_tile
	WHERE
	site_pin_pkey = (
	SELECT
	pkey
	FROM
	site_pin
	WHERE
	site_type_pkey = (
	SELECT
	site_type_pkey
	FROM
	site
	WHERE
	pkey = ?
	)
	AND name = ?
	);""", (site_pkey, wire_str)
	)
	else:
	c.execute(
	"""
	SELECT
	pkey,
	site_pin_pkey,
	site_pkey
	FROM
	wire_in_tile
	WHERE
	name = ?
	and tile_type_pkey = (
	SELECT
	pkey
	FROM
	tile_type
	WHERE
	name = ?
	);
	""", (wire_str, tile_type_str)
	)

	wire_in_tile_pkeys = {}
	the_site_pin_pkey = None
	for wire_in_tile_pkey, site_pin_pkey, site_pkey in c:
	wire_in_tile_pkeys[site_pkey] = wire_in_tile_pkey

	if the_site_pin_pkey is not None:
	assert the_site_pin_pkey == site_pin_pkey, (
	tile_type_str, wire_str
	)
	else:
	the_site_pin_pkey = site_pin_pkey

	assert the_site_pin_pkey is not None, (tile_type_str, wire_str)

	return wire_in_tile_pkeys, the_site_pin_pkey