Debian Codegraph @

himbaechel/uarch/xilinx/gen/xilinx_device.py

raw
1 import json
2 import os
3 import re
4 from enum import Enum
5 from tileconn import apply_tileconn
6 from parse_sdf import parse_sdf_file
7 from dataclasses import dataclass
8 from typing import Optional
9 # Represents Xilinx device data from PrjXray etc
10
11 @dataclass
12 class WireData:
13 index: int
14 name: str
15 intent: str = ""
16 tied_value: Optional[int] = None
17 resistance: float = 0
18 capacitance: float = 0
19
20 @dataclass
21 class PIPData:
22 index: int
23 from_wire: int
24 to_wire: int
25 is_bidi: bool = False
26 is_route_thru: bool = False
27 is_buffered: bool = False
28 min_delay: float = 0
29 max_delay: float = 0
30 resistance: float = 0
31 capacitance: float = 0
32
33 @dataclass
34 class SiteWireData:
35 name: str
36 is_pin: bool = False
37
38 @dataclass
39 class SiteBELPinData:
40 name: str
41 pindir: str
42 site_wire_idx: int
43
44 @dataclass
45 class SiteBELData:
46 name: str
47 bel_type: str
48 bel_class: str
49 pins: list[SiteBELPinData]
50
51 @dataclass
52 class SitePIPData:
53 bel_idx: int
54 bel_input: str
55 from_wire_idx: int
56 to_wire_idx: int
57
58 @dataclass
59 class SitePinData:
60 name: str
61 pindir: str
62 site_wire_idx: int
63 prim_pin_name: str
64
65 class SiteData:
66 def __init__(self, site_type):
67 self.site_type = site_type
68 self.wires = []
69 self.bels = []
70 self.pips = []
71 self.pins = []
72 self.variants = {}
73
74 class TileSitePinData:
75 def __init__(self, wire_idx):
76 self.wire_idx = wire_idx
77 self.min_delay = 0
78 self.max_delay = 0
79 self.resistance = 0
80 self.capacitance = 0
81
82 class TileData:
83 def __init__(self, tile_type):
84 self.tile_type = tile_type
85 self.wires = []
86 self.wires_by_name = {}
87 self.pips = []
88 self.sitepin_data = {} # (type, relxy, pin) -> TileSitePinData
89 self.cell_timing = None
90
91 class PIP:
92 def __init__(self, tile, index):
93 self.tile = tile
94 self.index = index
95 self.data = tile.get_pip_data(index)
96 def src_wire(self):
97 return Wire(self.tile, self.data.from_wire)
98 def dst_wire(self):
99 return Wire(self.tile, self.data.to_wire)
100 def is_route_thru(self):
101 return self.data.is_route_thru
102 def is_bidi(self):
103 return self.data.is_bidi
104 def is_buffered(self):
105 return self.data.is_buffered
106 def min_delay(self):
107 return self.data.min_delay
108 def max_delay(self):
109 return self.data.max_delay
110 def resistance(self):
111 return self.data.resistance
112 def capacitance(self):
113 return self.data.capacitance
114
115 class Wire:
116 def __init__(self, tile, index):
117 self.tile = tile
118 self.index = index
119 self.data = tile.get_wire_data(index)
120 def name(self):
121 return self.data.name
122 def intent(self):
123 return self.data.intent
124 def node(self):
125 if self.index not in self.tile.wire_to_node:
126 self.tile.wire_to_node[self.index] = Node(self.tile, [self])
127 return self.tile.wire_to_node[self.index]
128 def is_gnd(self):
129 return "GND_WIRE" in self.name()
130 def is_vcc(self):
131 return "VCC_WIRE" in self.name()
132 def resistance(self):
133 return self.data.resistance
134 def capacitance(self):
135 return self.data.capacitance
136
137 class SiteWire:
138 def __init__(self, site, index):
139 self.site = site
140 self.index = index
141 self.data = self.site.get_wire_data(index)
142 def name(self):
143 return self.data.name
144
145 class SiteBELPin:
146 def __init__(self, bel, name):
147 self.bel = bel
148 self.name = name
149 self.data = self.bel.data.pins[name]
150 def name(self):
151 return self.name
152 def dir(self):
153 return self.data.pindir
154 def site_wire(self):
155 return SiteWire(self.bel.site, self.data.site_wire_idx)
156
157 class SiteBEL:
158 def __init__(self, site, index):
159 self.site = site
160 self.index = index
161 self.data = site.get_bel_data(index)
162 def name(self):
163 return self.data.name
164 def bel_type(self):
165 return self.data.bel_type
166 def bel_class(self):
167 return self.data.bel_class
168 def pins(self):
169 return (SiteBELPin(self, n) for n in self.data.pins.keys())
170
171 class SitePIP:
172 def __init__(self, site, index):
173 self.site = site
174 self.index = index
175 self.data = site.get_pip_data(index)
176 def bel(self):
177 return SiteBEL(self.site, self.data.bel_idx)
178 def bel_input(self):
179 return self.data.bel_input
180 def src_wire(self):
181 return SiteWire(self.site, self.data.from_wire_idx)
182 def dst_wire(self):
183 return SiteWire(self.site, self.data.to_wire_idx)
184
185 class SitePin:
186 def __init__(self, site, index):
187 self.site = site
188 self.index = index
189 self.data = site.data.pins[index]
190 def name(self):
191 return self.data.name
192 def dir(self):
193 return self.data.pindir
194 def site_wire(self):
195 return SiteWire(self.site, self.data.site_wire_idx)
196 def tile_wire(self):
197 return self.site.tile.site_pin_wire(self.site.primary.site_type(), self.site.rel_xy(), self.data.prim_pin_name)
198 def min_delay(self):
199 return self.site.tile.site_pin_timing(self.site.primary.site_type(), self.site.rel_xy(), self.data.prim_pin_name).min_delay
200 def max_delay(self):
201 return self.site.tile.site_pin_timing(self.site.primary.site_type(), self.site.rel_xy(), self.data.prim_pin_name).max_delay
202 def resistance(self):
203 return self.site.tile.site_pin_timing(self.site.primary.site_type(), self.site.rel_xy(), self.data.prim_pin_name).resistance
204 def capacitance(self):
205 return self.site.tile.site_pin_timing(self.site.primary.site_type(), self.site.rel_xy(), self.data.prim_pin_name).capacitance
206
207 class Site:
208 def __init__(self, tile, name, index, grid_xy, data, primary=None):
209 self.tile = tile
210 self.name = name
211 self.index = index
212 self.prefix = name[0:name.rfind('_')]
213 self.grid_xy = grid_xy
214 self.data = data
215 self.primary = primary if primary is not None else self
216 self._rel_xy = None # filled later
217 self._variants = None #filled later
218 def get_bel_data(self, index):
219 return self.data.bels[index]
220 def get_wire_data(self, index):
221 return self.data.wires[index]
222 def get_pip_data(self, index):
223 return self.data.pips[index]
224 def site_type(self):
225 return self.data.site_type
226 def rel_xy(self):
227 if self._rel_xy is None:
228 base_x = 999999
229 base_y = 999999
230 for site in self.tile.sites():
231 if site.prefix != self.prefix:
232 continue
233 base_x = min(base_x, site.grid_xy[0])
234 base_y = min(base_y, site.grid_xy[1])
235 self._rel_xy = (self.grid_xy[0] - base_x, self.grid_xy[1] - base_y)
236 return self._rel_xy
237 def bels(self):
238 return (SiteBEL(self, i) for i in range(len(self.data.bels)))
239 def wires(self):
240 return (SiteWire(self, i) for i in range(len(self.data.wires)))
241 def pips(self):
242 return (SitePIP(self, i) for i in range(len(self.data.pips)))
243 def pins(self):
244 return (SitePin(self, i) for i in range(len(self.data.pins)))
245 def pin(self, p):
246 for i in range(len(self.data.pins)):
247 if self.data.pins[i].name == p:
248 return SitePin(self, i)
249 return None
250 def available_variants(self):
251 # Make sure primary type is first
252 if self._variants is None:
253 self._variants = []
254 self._variants.append(self.site_type())
255 for var in sorted(self.data.variants.keys()):
256 if var != self.site_type():
257 self._variants.append(var)
258 return self._variants
259 def variant(self, vtype):
260 vsite = Site(self.tile, self.name, self.index, self.grid_xy, self.data.variants[vtype], self)
261 return vsite
262 def rel_name(self):
263 x, y = self.rel_xy()
264 return f"{self.prefix}_X{x}Y{y}"
265
266 class Tile:
267 def __init__(self, x, y, name, data, interconn_xy, site_insts):
268 self.x = x
269 self.y = y
270 self.name = name
271 self.data = data
272 self.interconn_xy = interconn_xy
273 self.site_insts = site_insts
274 self.wire_to_node = {}
275 self.node_autoidx = 0
276 self.used_wires = None
277 def get_pip_data(self, i):
278 return self.data.pips[i]
279 def get_wire_data(self, i):
280 return self.data.wires[i]
281 def tile_type(self):
282 return self.data.tile_type
283 def wires(self):
284 return (Wire(self, i) for i in range(len(self.data.wires)))
285 def wire(self, name):
286 return Wire(self, self.data.wires_by_name[name].index)
287 def pips(self):
288 return (PIP(self, i) for i in range(len(self.data.pips)))
289 def sites(self):
290 return self.site_insts
291 def site_pin_wire(self, sitetype, rel_xy, pin):
292 wire_idx = self.data.sitepin_data[(sitetype, rel_xy, pin)].wire_idx
293 return Wire(self, wire_idx) if wire_idx is not None else None
294 def site_pin_timing(self, sitetype, rel_xy, pin):
295 return self.data.sitepin_data[(sitetype, rel_xy, pin)]
296 def cell_timing(self):
297 return self.data.cell_timing
298 def used_wire_indices(self):
299 if self.used_wires is None:
300 self.used_wires = set()
301 for pip in self.pips():
302 self.used_wires.add(pip.src_wire().index)
303 self.used_wires.add(pip.dst_wire().index)
304 for site in self.sites():
305 for v in site.available_variants():
306 variant = site.variant(v)
307 for pin in variant.pins():
308 if pin.tile_wire() is not None:
309 self.used_wires.add(pin.tile_wire().index)
310 return self.used_wires
311 def split_name(self):
312 prefix, xy = self.name.rsplit("_", 1)
313 xy_m = re.match(r"X(\d+)Y(\d+)", xy)
314 return prefix, int(xy_m.group(1)), int(xy_m.group(2))
315
316 class Node:
317 def __init__(self, tile, wires=[]):
318 self.tile = tile
319 self.index = tile.node_autoidx
320 tile.node_autoidx += 1
321 self.wires = wires
322 def unique_index(self):
323 return (self.tile.y << 48) | (self.tile.x << 32) | self.index
324 def is_vcc(self):
325 for wire in self.wires:
326 if wire.is_vcc():
327 return True
328 return False
329 def is_gnd(self):
330 for wire in self.wires:
331 if wire.is_gnd():
332 return True
333 return False
334
335 class Package:
336 def __init__(self, name):
337 self.name = name
338 self.pin_map = {}
339
340 class Device:
341 def __init__(self, name):
342 self.name = name
343 self.tiles = []
344 self.tiles_by_name = {}
345 self.tiles_by_xy = {}
346 self.sites_by_name = {}
347 self.width = 0
348 self.height = 0
349 self.packages = {}
350 def tile(self, name):
351 return self.tiles_by_name[name]
352 def site(self, name):
353 return self.sites_by_name[name]
354
355 def import_device(fabricname, prjxray_root, metadata_root):
356 site_type_cache = {}
357 tile_type_cache = {}
358 tile_json_cache = {}
359 def parse_xy(xy):
360 xpos = xy.rfind("X")
361 ypos = xy.rfind("Y")
362 return int(xy[xpos+1:ypos]), int(xy[ypos+1:])
363
364 def get_site_type_data(sitetype):
365 if sitetype not in site_type_cache:
366 sd = SiteData(sitetype)
367 sp = metadata_root + "/site_type_" + sitetype + ".json"
368 if os.path.exists(sp):
369 with open(sp, "r") as jf:
370 sj = json.load(jf)
371 for vtype, vdata in sorted(sj.items()): # Consider all site variants
372 if vtype == sitetype:
373 vd = sd # primary variant
374 else:
375 vd = SiteData(vtype)
376 site_wire_by_name = {}
377 def wire_index(name):
378 if name not in site_wire_by_name:
379 idx = len(vd.wires)
380 vd.wires.append(SiteWireData(name=name))
381 site_wire_by_name[name] = idx
382 return site_wire_by_name[name]
383 # Import bels
384 bel_idx_by_name = {}
385 for bel, beldata in sorted(vdata["bels"].items()):
386 belpins = {}
387 for pin, pindata in sorted(beldata["pins"].items()):
388 belpins[pin] = SiteBELPinData(name=pin, pindir=pindata["dir"], site_wire_idx=wire_index(pindata["wire"]))
389 bd = SiteBELData(name=bel, bel_type=beldata["type"], bel_class=beldata["class"], pins=belpins)
390 bel_idx_by_name[bel] = len(vd.bels)
391 vd.bels.append(bd)
392 # Import pips
393 for pipdata in vdata["pips"]:
394 bel_idx = bel_idx_by_name[pipdata["bel"]]
395 bel_data = vd.bels[bel_idx]
396 vd.pips.append(SitePIPData(bel_idx=bel_idx_by_name[pipdata["bel"]], bel_input=pipdata["from_pin"],
397 from_wire_idx=bel_data.pins[pipdata["from_pin"]].site_wire_idx,
398 to_wire_idx=bel_data.pins[pipdata["to_pin"]].site_wire_idx))
399 # Import pins
400 for pin, pindata in sorted(vdata["pins"].items()):
401 vd.pins.append(SitePinData(name=pin, pindir=pindata["dir"], site_wire_idx=wire_index(pindata["wire"]),
402 prim_pin_name=pindata["primary"]))
403 sd.variants[vtype] = vd
404 else:
405 sd.variants[sitetype] = sd
406 site_type_cache[sitetype] = sd
407 return site_type_cache[sitetype]
408
409 def read_tile_type_json(tiletype):
410 if tiletype not in tile_json_cache:
411 if not os.path.exists(prjxray_root + "/tile_type_" + tiletype + ".json"):
412 tile_json_cache[tiletype] = dict(wires={}, pips={}, sites=[])
413 else:
414 with open(prjxray_root + "/tile_type_" + tiletype + ".json", "r") as jf:
415 tile_json_cache[tiletype] = json.load(jf)
416 return tile_json_cache[tiletype]
417
418 def get_tile_type_data(tiletype):
419 if tiletype not in tile_type_cache:
420 td = TileData(tiletype)
421 # Import wires and pips
422 tj = read_tile_type_json(tiletype)
423 for wire, wire_data in sorted(tj["wires"].items()):
424 wire_id = len(td.wires)
425 wd = WireData(index=wire_id, name=wire, tied_value=None) # FIXME: tied_value
426 wd.intent = get_wire_intent(tiletype, wire)
427 if wire_data is not None:
428 if "res" in wire_data:
429 wd.resistance = float(wire_data["res"])
430 if "cap" in wire_data:
431 wd.capacitance = float(wire_data["cap"])
432 td.wires.append(wd)
433 td.wires_by_name[wire] = wd
434 for pip, pipdata in sorted(tj["pips"].items()):
435 # FIXME: pip/wire delays
436 pip_id = len(td.pips)
437 pd = PIPData(index=pip_id,
438 from_wire=td.wires_by_name[pipdata["src_wire"]].index, to_wire=td.wires_by_name[pipdata["dst_wire"]].index,
439 is_bidi=(not bool(int(pipdata["is_directional"]))), is_route_thru=bool(int(pipdata["is_pseudo"])))
440 if "is_pass_transistor" in pipdata:
441 pd.is_buffered = (not bool(int(pipdata["is_pass_transistor"])))
442 if "src_to_dst" in pipdata:
443 s2d = pipdata["src_to_dst"]
444 if "delay" in s2d and s2d["delay"] is not None:
445 pd.min_delay = min(float(s2d["delay"][0]), float(s2d["delay"][1]))
446 pd.max_delay = max(float(s2d["delay"][2]), float(s2d["delay"][3]))
447 if "res" in s2d and s2d["res"] is not None:
448 pd.resistance = float(s2d["res"])
449 if "in_cap" in s2d and s2d["in_cap"] is not None:
450 pd.capacitance = float(s2d["in_cap"])
451 td.pips.append(pd)
452 for sitedata in tj["sites"]:
453 rel_xy = parse_xy(sitedata["name"])
454 sitetype = sitedata["type"]
455 for sitepin, pindata in sorted(sitedata["site_pins"].items()):
456 if pindata is None:
457 tspd = TileSitePinData(None)
458 else:
459 pinwire = td.wires_by_name[pindata["wire"]].index
460 tspd = TileSitePinData(pinwire)
461 if "delay" in pindata:
462 tspd.min_delay = min(float(pindata["delay"][0]), float(pindata["delay"][1]))
463 tspd.max_delay = max(float(pindata["delay"][2]), float(pindata["delay"][3]))
464 if "res" in pindata:
465 tspd.resistance = float(pindata["res"])
466 if "cap" in pindata:
467 tspd.capacitance = float(pindata["cap"])
468 td.sitepin_data[(sitetype, rel_xy, sitepin)] = tspd
469 if os.path.exists(prjxray_root + "/timings/" + tiletype + ".sdf"):
470 td.cell_timing = parse_sdf_file(prjxray_root + "/timings/" + tiletype + ".sdf")
471
472 tile_type_cache[tiletype] = td
473
474 return tile_type_cache[tiletype]
475
476 def get_wire_intent(tiletype, wirename):
477 if tiletype not in ij["tiles"]:
478 return "GENERIC"
479 if wirename not in ij["tiles"][tiletype]:
480 return "GENERIC"
481 return ij["intents"][str(ij["tiles"][tiletype][wirename])]
482
483 d = Device(fabricname)
484
485 # Load intent JSON
486 with open(metadata_root + "/wire_intents.json", "r") as ijf:
487 ij = json.load(ijf)
488 with open(prjxray_root + "/" + fabricname + "/tilegrid.json") as gf:
489 tgj = json.load(gf)
490 for tile, tiledata in sorted(tgj.items()):
491 x = int(tiledata["grid_x"])
492 y = int(tiledata["grid_y"])
493 d.width = max(d.width, x + 1)
494 d.height = max(d.height, y + 1)
495 tiletype = tiledata["type"]
496 t = Tile(x, y, tile, get_tile_type_data(tiletype), (-1, -1), [])
497 for idx, (site, sitetype) in enumerate(sorted(tiledata["sites"].items())):
498 si = Site(t, site, idx, parse_xy(site), get_site_type_data(sitetype))
499 t.site_insts.append(si)
500 d.sites_by_name[site] = si
501 d.tiles_by_name[tile] = t
502 d.tiles_by_xy[x, y] = t
503 d.tiles.append(t)
504
505 # Resolve interconnect tile coordinates
506 for t in d.tiles:
507 for delta in range(0, 30):
508 if t.interconn_xy != (-1, -1):
509 break # found, done
510 for direction in (-1, +1):
511 nxy = (t.x + direction * delta, t.y)
512 if nxy not in d.tiles_by_xy:
513 continue
514 if d.tiles_by_xy[nxy].tile_type not in ("INT", "INT_L", "INT_R"):
515 continue
516 t.interconn_xy = nxy
517 break
518 # Read package pins
519 for entry in os.scandir(prjxray_root):
520 if not entry.is_dir() or not entry.name.startswith(fabricname):
521 continue
522 device_postfix = entry.name[len(fabricname):]
523 if len(device_postfix) == 0:
524 continue
525 package_name = device_postfix.split("-")[0]
526 if package_name in d.packages:
527 continue # already seen in a different speed grade
528 with open(prjxray_root + "/" + entry.name + "/package_pins.csv") as ppf:
529 pkg = Package(name=package_name)
530 for line in ppf:
531 sl = line.strip().split(",")
532 if len(sl) < 3:
533 continue
534 if sl[2] == "site":
535 continue # header
536 pkg.pin_map[sl[0]] = sl[2]
537 d.packages[package_name] = pkg
538 with open(prjxray_root + "/" + fabricname + "/tileconn.json", "r") as tcf:
539 apply_tileconn(tcf, d)
540 return d
541
542 if __name__ == '__main__':
543 import sys
544 import_device(*sys.argv[1:])