| #!/usr/bin/env python3 |
| |
| import os, sys, json, re |
| from io import StringIO |
| |
| import argparse |
| |
| parser = argparse.ArgumentParser( |
| description="Generate a pretty HTML version of the documentation.") |
| parser.add_argument( |
| '--output', |
| default=os.path.join(os.path.curdir, 'html'), |
| help='Put the generated files in this directory (default current dir).') |
| parser.add_argument( |
| '--settings', |
| default=None, |
| help='Read the settings from file (default to environment).') |
| |
| args = parser.parse_args() |
| |
| if args.settings: |
| settings_filename = args.settings |
| |
| settings = { |
| 'XRAY_DATABASE_DIR': |
| os.path.abspath( |
| os.path.join(os.path.dirname(settings_filename), '..')), |
| } |
| with open(settings_filename) as f: |
| for line in f: |
| line = line.strip() |
| if not line.startswith("export "): |
| continue |
| key, value = line[7:].split('=', 1) |
| settings[key] = value[1:-1] |
| |
| def get_setting(name): |
| return settings[name] |
| else: |
| |
| def get_setting(name): |
| return os.getenv(name) |
| |
| |
| db_dir = os.path.join( |
| get_setting("XRAY_DATABASE_DIR"), get_setting("XRAY_DATABASE")) |
| |
| |
| def db_open(fn): |
| filename = os.path.join(db_dir, fn) |
| if not os.path.exists(filename): |
| return StringIO("") |
| return open(os.path.join(db_dir, fn)) |
| |
| |
| def out_open(fn): |
| out_dir = os.path.join(args.output, get_setting("XRAY_DATABASE")) |
| os.makedirs(out_dir, exist_ok=True) |
| fp = os.path.join(out_dir, fn) |
| print("Writing %s" % fp) |
| return open(fp, "w") |
| |
| |
| clb_bitgroups_db = [ |
| # copy&paste from zero_db in dbfixup.py |
| "00_21 00_22 00_26 01_28|00_25 01_20 01_21 01_24", |
| "00_23 00_30 01_22 01_25|00_27 00_29 01_26 01_29", |
| "01_12 01_14 01_16 01_18|00_10 00_11 01_09 01_10", |
| "00_13 01_17 00_15 00_17|00_18 00_19 01_13 00_14", |
| "00_34 00_38 01_33 01_37|00_35 00_39 01_38 01_40", |
| "00_33 00_41 01_32 01_34|00_37 00_42 01_36 01_41", |
| |
| # other manual groupings for individual bits |
| "00_02 00_05 00_09 01_04|00_07 01_05 01_06", |
| "00_01 00_06 01_00 01_08|00_03 01_01 01_02", |
| "00_59 01_54 01_58 01_61|00_57 00_58 01_56", |
| "00_55 00_63 01_57 01_62|00_61 00_62 01_60", |
| "00_43 00_47 00_50 00_53 00_54 01_42|00_51 01_50 01_52", |
| "00_49 01_44 01_45 01_48 01_49 01_53|00_45 00_46 01_46", |
| ] |
| |
| hclk_bitgroups_db = [ |
| # manual groupings |
| "03_14 03_15 04_14 04_15|00_15 00_16 01_14 01_15", |
| "02_16 03_16 04_16 05_16|02_14 02_15 05_14 05_15", |
| "02_18 02_19 05_18 05_19|00_17 00_18 01_16 01_17", |
| "03_18 03_19 04_18 04_19|02_17 03_17 04_17 05_17", |
| "02_20 02_21 05_20 05_21|02_22 03_22 04_22 05_22", |
| "02_29 03_29 04_29 05_29|03_30 03_31 04_30 04_31", |
| "02_26 02_27 05_26 05_27|02_28 03_28 04_28 05_28", |
| "02_23 03_23 04_23 05_23|03_24 03_25 04_24 04_25", |
| ] |
| |
| # groupings for SNWE bits in frames 2..7 |
| for i in range(0, 64, 4): |
| clb_bitgroups_db.append( |
| "02_%02d 03_%02d 05_%02d 06_%02d 07_%02d|05_%02d 03_%02d 04_%02d 04_%02d" |
| % (i + 1, i, i, i, i + 1, i + 3, i + 1, i + 1, i + 2)) |
| clb_bitgroups_db.append( |
| "02_%02d 04_%02d 05_%02d 05_%02d 06_%02d|02_%02d 03_%02d 04_%02d 07_%02d" |
| % (i + 2, i, i + 1, i + 2, i + 2, i + 3, i + 2, i + 3, i + 3)) |
| |
| clb_left_bits = set() |
| clb_right_bits = set() |
| |
| for entry in clb_bitgroups_db: |
| a, b = entry.split("|") |
| for bit in a.split(): |
| clb_left_bits.add(bit) |
| for bit in b.split(): |
| clb_right_bits.add(bit) |
| |
| hclk_left_bits = set() |
| hclk_right_bits = set() |
| |
| for entry in hclk_bitgroups_db: |
| a, b = entry.split("|") |
| for bit in a.split(): |
| hclk_left_bits.add(bit) |
| for bit in b.split(): |
| hclk_right_bits.add(bit) |
| |
| |
| class UnionFind: |
| def __init__(self): |
| self.parents = dict() |
| |
| def make(self, value): |
| if value not in self.parents: |
| self.parents[value] = value |
| |
| def find(self, value): |
| self.make(value) |
| if self.parents[value] != value: |
| retval = self.find(self.parents[value]) |
| self.parents[value] = retval |
| return self.parents[value] |
| |
| def union(self, v1, v2): |
| a = self.find(v1) |
| b = self.find(v2) |
| if a != b: |
| self.parents[a] = b |
| |
| |
| ################################################# |
| # Loading Raw Source Data |
| |
| grid = None |
| cfgbits = dict() |
| cfgbits_r = dict() |
| maskbits = dict() |
| ppips = dict() |
| routebits = dict() |
| routezbits = dict() |
| |
| print("Loading tilegrid.") |
| with db_open("tilegrid.json") as f: |
| data = f.read() |
| if not data: |
| grid = { |
| "NULL": { |
| "grid_x": 0, |
| "grid_y": 0, |
| "type": "NULL", |
| } |
| } |
| else: |
| grid = json.loads(data) |
| |
| |
| def db_read(tiletype): |
| cfgbits[tiletype] = dict() |
| cfgbits_r[tiletype] = dict() |
| maskbits[tiletype] = set() |
| ppips[tiletype] = dict() |
| routebits[tiletype] = dict() |
| routezbits[tiletype] = dict() |
| |
| def add_pip_bits(tag, bits): |
| if tag not in routebits[tiletype]: |
| routebits[tiletype][tag] = set() |
| routezbits[tiletype][tag] = set() |
| for bit in bits: |
| if bit[0] == "!": |
| if bit[1:] not in routezbits[tiletype]: |
| routezbits[tiletype][bit[1:]] = set() |
| routezbits[tiletype][bit[1:]].add(tag) |
| else: |
| if bit not in routebits[tiletype]: |
| routebits[tiletype][bit] = set() |
| routebits[tiletype][bit].add(tag) |
| |
| def add_cfg_bits(tag, bits): |
| if tag not in cfgbits[tiletype]: |
| cfgbits[tiletype][tag] = set() |
| for bit in bits: |
| cfgbits[tiletype][tag].add(bit) |
| if bit not in cfgbits_r[tiletype]: |
| cfgbits_r[tiletype][bit] = set() |
| cfgbits_r[tiletype][bit].add(tag) |
| |
| with db_open("segbits_%s.db" % tiletype) as f: |
| for line in f: |
| line = line.split() |
| tag, bits = line[0], line[1:] |
| |
| if tiletype in ["int_l", "int_r", "hclk_l", "hclk_r"]: |
| add_pip_bits(tag, bits) |
| |
| elif tiletype in ["clbll_l", "clbll_r", "clblm_l", "clblm_r"] and \ |
| re.search(r"(\.[ABCD]MUX\.)|(\.PRECYINIT\.)", tag): |
| add_pip_bits(tag, bits) |
| |
| else: |
| add_cfg_bits(tag, bits) |
| |
| with db_open("ppips_%s.db" % tiletype) as f: |
| for line in f: |
| tag, typ = line.split() |
| ppips[tiletype][tag] = typ |
| |
| if tiletype not in ["int_l", "int_r"]: |
| with db_open("mask_%s.db" % tiletype) as f: |
| for line in f: |
| tag, bit = line.split() |
| assert tag == "bit" |
| maskbits[tiletype].add(bit) |
| else: |
| for t in ["clbll_l", "clbll_r", "clblm_l", "clblm_r", "dsp_l", "dsp_r", |
| "bram_l", "bram_r"]: |
| with db_open("mask_%s.db" % t) as f: |
| for line in f: |
| tag, bit = line.split() |
| assert tag == "bit" |
| frameidx, bitidx = bit.split("_") |
| maskbits[tiletype].add( |
| "%02d_%02d" % (int(frameidx), int(bitidx) % 64)) |
| |
| |
| db_read("int_l") |
| db_read("int_r") |
| |
| db_read("hclk_l") |
| db_read("hclk_r") |
| |
| db_read("clbll_l") |
| db_read("clbll_r") |
| |
| db_read("clblm_l") |
| db_read("clblm_r") |
| |
| db_read("dsp_l") |
| db_read("dsp_r") |
| |
| db_read("bram_l") |
| db_read("bram_r") |
| |
| ################################################# |
| # Create Tilegrid Page |
| |
| grid_range = None |
| grid_map = dict() |
| |
| with out_open("index.html") as f: |
| print( |
| "<html><title>X-Ray %s Database</title><body>" % |
| get_setting("XRAY_DATABASE").upper(), |
| file=f) |
| print( |
| "<h3>X-Ray %s Database</h3>" % get_setting("XRAY_DATABASE").upper(), |
| file=f) |
| |
| print( |
| "<p><b>Part: %s<br/>ROI: %s<br/>ROI Frames: %s</b></p>" % ( |
| get_setting("XRAY_PART"), get_setting("XRAY_ROI"), |
| get_setting("XRAY_ROI_FRAMES")), |
| file=f) |
| |
| for tilename, tiledata in grid.items(): |
| grid_x = tiledata["grid_x"] |
| grid_y = tiledata["grid_y"] |
| grid_map[(grid_x, grid_y)] = tilename |
| |
| if grid_range is None: |
| grid_range = [grid_x, grid_y, grid_x, grid_y] |
| else: |
| grid_range[0] = min(grid_range[0], grid_x) |
| grid_range[1] = min(grid_range[1], grid_y) |
| grid_range[2] = max(grid_range[2], grid_x) |
| grid_range[3] = max(grid_range[3], grid_y) |
| |
| print("<table border>", file=f) |
| |
| for grid_y in range(grid_range[1], grid_range[3] + 1): |
| print("<tr>", file=f) |
| |
| for grid_x in range(grid_range[0], grid_range[2] + 1): |
| tilename = grid_map[(grid_x, grid_y)] |
| tiledata = grid[tilename] |
| segdata = None |
| |
| bgcolor = "#aaaaaa" |
| if tiledata["type"] in ["INT_L", "INT_R"]: bgcolor = "#aaaaff" |
| if tiledata["type"] in ["CLBLL_L", "CLBLL_R"]: bgcolor = "#ffffaa" |
| if tiledata["type"] in ["CLBLM_L", "CLBLM_R"]: bgcolor = "#ffaaaa" |
| if tiledata["type"] in ["HCLK_L", "HCLK_R"]: bgcolor = "#aaffaa" |
| |
| if tiledata["type"] in ["BRAM_INT_INTERFACE_L", "BRAM_L"]: |
| bgcolor = "#aaffff" |
| if tiledata["type"] in ["BRAM_INT_INTERFACE_R", "BRAM_R"]: |
| bgcolor = "#aaffff" |
| |
| if tiledata["type"] in ["INT_INTERFACE_L", "DSP_L"]: |
| bgcolor = "#ffaaff" |
| if tiledata["type"] in ["INT_INTERFACE_R", "DSP_R"]: |
| bgcolor = "#ffaaff" |
| |
| title = [tilename] |
| |
| if "segment" in tiledata: |
| segdata = grid["segments"][tiledata["segment"]] |
| title.append(tiledata["segment"]) |
| |
| title.append("GRID_POSITION: %d %d" % (grid_x, grid_y)) |
| |
| if "sites" in tiledata: |
| for sitename, sitetype in tiledata["sites"].items(): |
| title.append("%s site: %s" % (sitetype, sitename)) |
| |
| if "segment" in tiledata: |
| if "baseaddr" in segdata: |
| title.append( |
| "Baseaddr: %s %d" % tuple(segdata["baseaddr"])) |
| else: |
| print( |
| "Warning: no baseaddr in segment %s (via tile %s)." % |
| (tiledata["segment"], tilename)) |
| |
| tilename = tilename.replace("INT_INTERFACE_", "INTF_") |
| tilename = tilename.replace("_X", "<br/>X") |
| tilename = tilename.replace("B_TERM", "B<br/>TERM") |
| |
| print( |
| "<td bgcolor=\"%s\" align=\"center\" title=\"%s\"><span style=\"font-size:10px\">" |
| % (bgcolor, "\n".join(title)), |
| file=f) |
| if tiledata["type"].lower() in cfgbits: |
| print( |
| "<a style=\"text-decoration: none; color: black\" href=\"tile_%s.html\">%s</a></span></td>" |
| % ( |
| tiledata["type"].lower(), |
| tilename.replace("_X", "<br/>X")), |
| file=f) |
| else: |
| print( |
| "%s</span></td>" % tilename.replace( |
| "_X", "<br/>X").replace("B_TERM", "B<br/>TERM"), |
| file=f) |
| |
| print("</tr>", file=f) |
| |
| print("</table>", file=f) |
| print("</body></html>", file=f) |
| |
| ################################################# |
| # Create Segment Pages |
| |
| |
| def get_bit_info(frameidx, bitidx, tiletype): |
| bit_pos = "%02d_%02d" % (frameidx, bitidx) |
| bit_name = cfgbits_r[tiletype][bit_pos] if bit_pos in cfgbits_r[ |
| tiletype] else None |
| |
| if bit_name is None and bit_pos in routebits[tiletype]: |
| bit_name = routebits[tiletype][bit_pos] |
| |
| if bit_name is None and bit_pos in routezbits[tiletype]: |
| bit_name = routezbits[tiletype][bit_pos] |
| |
| if bit_name is None and tiletype in ["clbll_l", "clbll_r", "clblm_l", |
| "clblm_r", "dsp_l", "dsp_r", "bram_l", |
| "bram_r"]: |
| int_tile_type = "int_" + tiletype[-1] |
| bit_int_pos = "%02d_%02d" % (frameidx, bitidx % 64) |
| bit_name = cfgbits_r[int_tile_type][ |
| bit_int_pos] if bit_int_pos in cfgbits_r[int_tile_type] else None |
| |
| if bit_name is None and bit_int_pos in routebits[int_tile_type]: |
| bit_name = routebits[int_tile_type][bit_int_pos] |
| |
| if bit_name is None and bit_int_pos in routezbits[int_tile_type]: |
| bit_name = routezbits[int_tile_type][bit_int_pos] |
| |
| if bit_name is not None: |
| return bit_pos, "INT", [bit_pos], "#88aaff" |
| |
| if bit_name is not None: |
| if len(bit_name) <= 1: |
| bit_name = "".join(bit_name) |
| else: |
| for n in bit_name: |
| bit_name = ".".join(n.split(".")[:-1]) |
| |
| label = None |
| title = [bit_pos] |
| bgcolor = "#aaaaaa" |
| |
| if bit_pos not in maskbits[tiletype]: |
| label = " " |
| bgcolor = "#444444" |
| title.append("UNUSED ?") |
| |
| if (tiletype in ["hclk_l", "hclk_r"]) and bitidx < 13: |
| label = "ECC" |
| bgcolor = "#44aa44" |
| |
| if bit_name is not None: |
| bgcolor = "#ff0000" |
| title.append(bit_name) |
| |
| if "LUT.INIT" in bit_name: |
| bgcolor = "#ffffaa" |
| m = re.search(r"(.)LUT.INIT\[(..)\]", bit_name) |
| label = m.group(1) + m.group(2) |
| |
| m = re.search(r"\.([ABCD])LUT\.([A-Z]+)$", bit_name) |
| if m: |
| bgcolor = "#ffffaa" |
| if m.group(2) == "RAM": |
| label = m.group(1) + "LR" |
| elif m.group(2) == "SMALL": |
| label = m.group(1) + "LS" |
| elif m.group(2) == "SRL": |
| label = m.group(1) + "SR" |
| else: |
| bgcolor = "#ff0000" |
| |
| m = re.search(r"\.([ABCD])LUT\.([A-Z]+)$", bit_name) |
| if m: |
| bgcolor = "#ffffaa" |
| if m.group(2) == "RAM": |
| label = m.group(1) + "LR" |
| elif m.group(2) == "SMALL": |
| label = m.group(1) + "LS" |
| elif m.group(2) == "SRL": |
| label = m.group(1) + "SR" |
| else: |
| bgcolor = "#ff0000" |
| |
| m = re.search(r"\.([ABCD]5?)FF\.([A-Z]+(\.A|\.B)?)$", bit_name) |
| if m: |
| bgcolor = "#aaffaa" |
| if m.group(2) == "ZINI": |
| label = m.group(1) + "ZI" |
| elif m.group(2) == "ZRST": |
| label = m.group(1) + "ZR" |
| elif m.group(2) == "MUX.A": |
| label = m.group(1) + "MA" |
| elif m.group(2) == "MUX.B": |
| label = m.group(1) + "MB" |
| else: |
| bgcolor = "#ff0000" |
| |
| m = re.search(r"\.([ABCD])DI1MUX\.", bit_name) |
| if m: |
| bgcolor = "#ffffaa" |
| label = m.group(1) + "DI1" |
| |
| m = re.search(r"\.(WA[78])USED$", bit_name) |
| if m: |
| bgcolor = "#ffffaa" |
| label = m.group(1) |
| |
| if ".WEMUX." in bit_name: |
| bgcolor = "#ffffaa" |
| label = "WE" |
| |
| m = re.search(r"\.CARRY4\.([A-Z0-9]+)$", bit_name) |
| if m: |
| bgcolor = "#88cc00" |
| label = m.group(1) |
| |
| if re.search(r"\.LATCH$", bit_name): |
| bgcolor = "#aaffaa" |
| label = "LAT" |
| |
| if re.search(r"\.FFSYNC$", bit_name): |
| bgcolor = "#aaffaa" |
| label = "SYN" |
| |
| if re.search(r"\.[ABCD]LUT5$", bit_name): |
| bgcolor = "#cccc88" |
| label = bit_name[-5] + "5" |
| |
| if re.search(r"\.(CE|SR)USEDMUX$", bit_name): |
| bgcolor = "#ffaa00" |
| label = bit_name[-9:-7] + "M" |
| |
| if re.search(r"\.CLKINV$", bit_name): |
| bgcolor = "#ffaa00" |
| label = "CLKI" |
| |
| if ".ENABLE_BUFFER." in bit_name: |
| bgcolor = "#ffaa00" |
| label = "BUF" |
| |
| if re.match("^INT_[LR].[SNWE][SNWERL]", bit_name): |
| if bit_name[8] == "1": |
| bgcolor = "#4466bb" |
| elif bit_name[8] == "2": |
| bgcolor = "#aa88ff" |
| elif bit_name[6:9] in "SS6 SE6 NN6 NW6".split(): |
| bgcolor = "#7755ff" |
| else: |
| bgcolor = "#88aaff" |
| label = bit_name[6:9] |
| |
| if re.match("^INT_[LR].IMUX", bit_name): |
| m = re.match("^INT_[LR].IMUX(_L)?(\d+)", bit_name) |
| bgcolor = "#88aaff" |
| label = "IM" + m.group(2) |
| |
| if re.match("^INT_[LR].BYP_ALT", bit_name): |
| bgcolor = "#7755ff" |
| label = "BA" + bit_name[13] |
| |
| if re.match("^INT_[LR].FAN_ALT", bit_name): |
| bgcolor = "#4466bb" |
| label = "FA" + bit_name[13] |
| |
| if re.match("^INT_[LR].CLK", bit_name): |
| bgcolor = "#4466bb" |
| label = "CLK" |
| |
| if re.match("^INT_[LR].CTRL", bit_name): |
| bgcolor = "#7755ff" |
| label = "CTRL" |
| |
| if re.match("^INT_[LR].GFAN", bit_name): |
| bgcolor = "#7755ff" |
| label = "GFAN" |
| |
| if re.match("^INT_[LR].LVB", bit_name): |
| bgcolor = "#88aaff" |
| label = "LVB" |
| |
| if re.match("^INT_[LR].LV", bit_name): |
| bgcolor = "#88aaff" |
| label = "LV" |
| |
| if re.match("^INT_[LR].LH", bit_name): |
| bgcolor = "#4466bb" |
| label = "LH" |
| |
| if re.match("^CLBL[LM]_[LR].SLICE[LM]_X[01].[ABCD]FF.DMUX", bit_name): |
| bgcolor = "#88aaff" |
| label = "DMX" |
| |
| if re.match("^CLBL[LM]_[LR].SLICE[LM]_X[01].[ABCD]MUX", bit_name): |
| bgcolor = "#aa88ff" |
| label = "OMX" |
| |
| if re.match("^CLBL[LM]_[LR].SLICE[LM]_X[01].PRECYINIT", bit_name): |
| bgcolor = "#88aaff" |
| label = "CYI" |
| |
| if re.match("^HCLK_[LR]", bit_name) and "_B_BOT" in bit_name: |
| bgcolor = "#4466bb" |
| label = "BOT" |
| |
| if re.match("^HCLK_[LR]", bit_name) and "_B_TOP" in bit_name: |
| bgcolor = "#7755ff" |
| label = "TOP" |
| |
| if re.match("^DSP_[LR].DSP_[01].(PATTERN|MASK)", bit_name): |
| bgcolor = "#ffffaa" |
| label = bit_name[12] + bit_name[10] |
| |
| return bit_pos, label, title, bgcolor |
| |
| |
| def gen_table(tiletype, f): |
| print( |
| """ |
| <script><!-- |
| var grp2bits = { }; |
| var bit2grp = { } |
| var highlight_bits = [ ]; |
| var highlight_cache = { }; |
| |
| function ome(bit) { |
| // console.log("ome: " + bit); |
| if (bit in bit2grp) { |
| grp = bit2grp[bit]; |
| for (i in grp2bits[grp]) { |
| b = grp2bits[grp][i]; |
| // console.log(" -> " + b); |
| if (!(b in highlight_cache)) { |
| el = document.getElementById("bit" + b); |
| highlight_cache[b] = el.bgColor; |
| el.bgColor = "#ffffff"; |
| highlight_bits.push(b); |
| } |
| } |
| } |
| } |
| |
| function oml() { |
| // console.log("oml"); |
| for (i in highlight_bits) { |
| b = highlight_bits[i]; |
| el = document.getElementById("bit" + b); |
| el.bgColor = highlight_cache[b]; |
| delete highlight_cache[b]; |
| el.style.fontWeight = "normal"; |
| } |
| highlight_bits.length = 0; |
| } |
| //--></script> |
| """, |
| file=f) |
| |
| num_frames = 36 |
| unused_bits = 0 |
| unknown_bits = 0 |
| known_bits = 0 |
| hideframes = set() |
| |
| if tiletype in ["int_l", "int_r", "hclk_l", "hclk_r"]: |
| num_frames = 26 |
| |
| if tiletype in ["bram_l", "bram_r", "dsp_l", "dsp_r"]: |
| for i in range(5, 25): |
| hideframes.add(i) |
| num_frames = 28 |
| |
| height = 2 |
| if tiletype in ["hclk_l", "hclk_r"]: |
| height = 1 |
| if tiletype in ["dsp_l", "dsp_r", "bram_l", "bram_r"]: |
| height = 10 |
| |
| if height > 2: |
| print("<table><tr><td>", file=f) |
| |
| def print_table_header(): |
| print("<table border>", file=f) |
| print("<tr>", file=f) |
| print("<th width=\"30\"></th>", file=f) |
| for frameidx in range(num_frames): |
| if frameidx in hideframes: |
| continue |
| print( |
| "<th width=\"30\"><span style=\"font-size:10px\">%d</span></th>" |
| % frameidx, |
| file=f) |
| print("</tr>", file=f) |
| |
| print_table_header() |
| |
| for bitidx in range(32 * height - 1, -1, -1): |
| print("<tr>", file=f) |
| print( |
| "<th align=\"right\"><span style=\"font-size:10px\">%d</span></th>" |
| % bitidx, |
| file=f) |
| for frameidx in range(num_frames): |
| if frameidx in hideframes: |
| continue |
| |
| bit_pos, label, title, bgcolor = get_bit_info( |
| frameidx, bitidx, tiletype) |
| |
| if label is None: |
| label = " " |
| onclick = "" |
| |
| if label == "INT": |
| onclick = " onmousedown=\"location.href = 'tile_int_%s.html#b%s'\"" % ( |
| tiletype[-1], bit_pos) |
| else: |
| onclick = " onmousedown=\"location.href = '#b%s'\"" % bit_pos |
| |
| if bgcolor == "#aaaaaa": |
| unknown_bits += 1 |
| elif bgcolor == "#444444": |
| unused_bits += 1 |
| else: |
| known_bits += 1 |
| |
| print( |
| "<td id=\"bit%s\" onmouseenter=\"ome('%s');\" onmouseleave=\"oml();\" bgcolor=\"%s\" align=\"center\" title=\"%s\"%s><span style=\"font-size:10px\">%s</span></td>" |
| % |
| (bit_pos, bit_pos, bgcolor, "\n".join(title), onclick, label), |
| file=f) |
| print("</tr>", file=f) |
| |
| if bitidx > 0 and bitidx % 80 == 0: |
| print("</table></td><td>", file=f) |
| print_table_header() |
| |
| print("</table>", file=f) |
| |
| if height > 2: |
| print("</td></tr></table>", file=f) |
| |
| print( |
| " unused: %d, unknown: %d, known: %d, total: %d, percentage: %.2f%% (%.2f%%)" |
| % ( |
| unused_bits, unknown_bits, known_bits, |
| unused_bits + unknown_bits + known_bits, |
| 100 * known_bits / (unknown_bits + unused_bits + known_bits), |
| 100 * (known_bits + unused_bits) / |
| (unknown_bits + unused_bits + known_bits))) |
| |
| |
| for tiletype in sorted(cfgbits.keys()): |
| with out_open("tile_%s.html" % tiletype) as f: |
| print( |
| "<html><title>X-Ray %s Database: %s</title><body>" % |
| (get_setting("XRAY_DATABASE").upper(), tiletype.upper()), |
| file=f) |
| print( |
| "<h3><a href=\"index.html\">X-Ray %s Database</a>: %s Segment</h3>" |
| % (get_setting("XRAY_DATABASE").upper(), tiletype.upper()), |
| file=f) |
| |
| gen_table(tiletype, f) |
| |
| print("<div>", file=f) |
| |
| bits_by_prefix = dict() |
| |
| for bit_name, bits_pos in cfgbits[tiletype].items(): |
| prefix = ".".join(bit_name.split(".")[0:-1]) |
| |
| if prefix not in bits_by_prefix: |
| bits_by_prefix[prefix] = set() |
| |
| for bit_pos in bits_pos: |
| bits_by_prefix[prefix].add((bit_name, bit_pos)) |
| |
| for prefix, bits in sorted(bits_by_prefix.items()): |
| for bit_name, bit_pos in sorted(bits): |
| print("<a id=\"b%s\"/>" % bit_pos, file=f) |
| |
| print("<p/>", file=f) |
| print("<h4>%s</h4>" % prefix, file=f) |
| print("<table cellspacing=0>", file=f) |
| print( |
| "<tr><th width=\"400\" align=\"left\">Bit Name</th><th>Position</th></tr>", |
| file=f) |
| |
| trstyle = "" |
| for bit_name, bit_pos in sorted(bits): |
| trstyle = " bgcolor=\"#dddddd\"" if trstyle == "" else "" |
| print( |
| "<tr%s><td>%s</td><td>%s</td></tr>" % |
| (trstyle, bit_name, bit_pos), |
| file=f) |
| |
| print("</table>", file=f) |
| |
| ruf = UnionFind() |
| routebits_routezbits = list(routebits[tiletype].items()) |
| routebits_routezbits += list(routezbits[tiletype].items()) |
| |
| for bit, pips in routebits_routezbits: |
| for pip in pips: |
| grp = ".".join(pip.split('.')[:-1]) |
| ruf.union(grp, bit) |
| |
| rgroups = dict() |
| rgroup_names = dict() |
| |
| for bit, pips in routebits_routezbits: |
| for pip in pips: |
| grp_name = ".".join(pip.split('.')[:-1]) |
| grp = ruf.find(grp_name) |
| if grp not in rgroup_names: |
| rgroup_names[grp] = set() |
| rgroup_names[grp].add(grp_name) |
| if grp not in rgroups: |
| rgroups[grp] = dict() |
| if pip not in rgroups[grp]: |
| rgroups[grp][pip] = set() |
| rgroups[grp][pip].add(bit) |
| |
| shared_bits = dict() |
| for bit, pips in routebits_routezbits: |
| for pip in pips: |
| grp_name = ".".join(pip.split('.')[:-1]) |
| if bit not in shared_bits: |
| shared_bits[bit] = set() |
| shared_bits[bit].add(grp_name) |
| |
| rgroups_with_title = list() |
| |
| for grp, gdata in sorted(rgroups.items()): |
| title = "PIPs driving " + ", ".join(sorted(rgroup_names[grp])) |
| rgroups_with_title.append((title, grp, gdata)) |
| |
| for title, grp, gdata in sorted(rgroups_with_title): |
| grp_bits = set() |
| for pip, bits in gdata.items(): |
| grp_bits |= bits |
| |
| def bit_key(b): |
| if tiletype in ["hclk_l", "hclk_r"]: |
| if b in hclk_left_bits: |
| return "a" + b |
| if b in hclk_right_bits: |
| return "c" + b |
| if tiletype in ["clblm_l", "clblm_r", "clbll_l", "clbll_r", |
| "int_l", "int_r"]: |
| if b in clb_left_bits: |
| return "a" + b |
| if b in clb_right_bits: |
| return "c" + b |
| return "b" + b |
| |
| grp_bits = sorted(grp_bits, key=bit_key) |
| |
| for bit in grp_bits: |
| print("<a id=\"b%s\"/>" % bit, file=f) |
| |
| print("<script><!--", file=f) |
| print( |
| "grp2bits['%s'] = ['%s'];" % |
| (grp_bits[0], "', '".join(grp_bits)), |
| file=f) |
| for bit in grp_bits: |
| print("bit2grp['%s'] = '%s';" % (bit, grp_bits[0]), file=f) |
| print("//--></script>", file=f) |
| |
| print("<p/>", file=f) |
| print("<h4>%s</h4>" % title, file=f) |
| print("<table cellspacing=0>", file=f) |
| print("<tr><th width=\"400\" align=\"left\">PIP</th>", file=f) |
| |
| for bit in grp_bits: |
| print("<th> %s </th>" % bit, file=f) |
| print("</tr>", file=f) |
| |
| lines = list() |
| for pip, bits in sorted(gdata.items()): |
| line = " --><td>%s</td>" % (pip) |
| for bit in grp_bits: |
| c = "-" |
| if bit in routebits[tiletype] and pip in routebits[tiletype][bit]: |
| c = "1" |
| if bit in routezbits[tiletype] and pip in routezbits[tiletype][bit]: |
| c = "0" |
| line = "%s%s<td align=\"center\">%s</td>" % (c, line, c) |
| lines.append(line) |
| |
| trstyle = "" |
| for line in sorted(lines): |
| trstyle = " bgcolor=\"#dddddd\"" if trstyle == "" else "" |
| print("<tr%s><!-- %s</tr>" % (trstyle, line), file=f) |
| |
| print("</table>", file=f) |
| |
| first_note = True |
| for bit in grp_bits: |
| if len(shared_bits[bit]) > 1: |
| if first_note: |
| print("<p><b>Note(s):</b><br/>", file=f) |
| print( |
| "Warning: Groups sharing bit %s: %s." % |
| (bit, ", ".join(sorted(shared_bits[bit])))) |
| print( |
| "Groups sharing bit <b>%s</b>: %s.<br/>" % |
| (bit, ", ".join(sorted(shared_bits[bit]))), |
| file=f) |
| first_note = False |
| if not first_note: |
| print("</p>", file=f) |
| |
| if len(ppips[tiletype]) > 0: |
| print("<h4>Pseudo PIPs</h4>", file=f) |
| print("<table cellspacing=0>", file=f) |
| print( |
| "<tr><th width=\"500\" align=\"left\">PIP</th><th>Type</th></tr>", |
| file=f) |
| trstyle = "" |
| for typ, tag in sorted( |
| [(b, a) for a, b in ppips[tiletype].items()]): |
| trstyle = " bgcolor=\"#dddddd\"" if trstyle == "" else "" |
| print( |
| "<tr%s><td>%s</td><td>%s</td></tr>" % (trstyle, tag, typ), |
| file=f) |
| print("</table>", file=f) |
| |
| print("</div>", file=f) |
| print("</body></html>", file=f) |
