gen_globals.py

import pytrellis
import database
import itertools
import json
import argparse

# This mirrors center_map in libtrellis. Somehow expose center_map.
center_map = {
    # 256HC
    (7, 9): (3, 4),
    # 640HC
    (8, 17): (3, 7),
    # 1200HC
    (12, 21): (6, 12),
    # 2000HC
    (15, 25): (8, 13),
    # 4000HC
    (22, 31): (11, 15),
    # 7000HC
    (26, 40): (13, 18),
}

row_spans = {
    # 1200HC
    (12, 21): (5, 5),
}

start_stride = {
    # 256HC
    (7, 9): (0, 4),
    # 640HC
    (8, 17): (1, 5),
    # 1200HC
    (12, 21): (0, 4),
    # 2000HC
    (15, 25): (3, 7),
    # 4000HC
    (22, 31): (1, 5),
    # 7000HC
    (26, 40): (2, 6),
}

# There are 8 global nets. For a given column, globals are routed in pairs.
# Convert from a pair to an index of global pairs.
global_group = {
    (0, 4): 0,
    (1, 5): 1,
    (2, 6): 2,
    (3, 7): 3
}

inv_global_group = [(0, 4), (1, 5), (2, 6), (3, 7)]

# Generate which columns route which globals.
def column_routing(num_cols, col_1=(0, 4)):
    i = 1
    stride = (0, 4, 1, 5, 2, 6, 3, 7)

    # Find which globals in column 0 will be routed, given which globals
    # are routed in column 1.
    #
    # Column "0" in prjtrellis ("1" in Lattice numbering) always has six of
    # the globals routed. The explanation for the final column applies here,
    # except we are missing the four globals that would span from the right
    # side of the U/D routing connection (and thus approach column 0 from the
    # left).
    col_0 = []

    for g in stride:
        if g not in col_1:
            col_0.append(g)

    yield tuple(col_0)

    # Rotate the stride so the correct pair of globals are at the beginning
    # of the list.
    idx = global_group[col_1]*2
    rotated_stride = stride[idx:] + stride[:idx]

    # Take two at a time: https://docs.python.org/3/library/functions.html#zip
    col_iter = itertools.cycle(zip(*[iter(rotated_stride)]*2))

    for c in col_iter:
        yield c

        i = i + 1
        if i >= num_cols:
            break

    # The final column will have 4 globals routed- the two expected globals
    # for the column as well as the next two globals in the stride. This is
    # because BRANCH wires that connect globals to CIBs span two columns to the
    # right and one column to the left from where they connect to U/D routing.
    # Since we are at the right bound of the chip, the globals we would expect
    # to span from the left side of the U/D routing (and thus approach the
    # final column from the right) don't physically exist! So we take care
    # of them here.
    yield next(col_iter) + next(col_iter)

# Generate how far branches span (exclusive span, in tiles) from u/d column
# routing.
def branch_spans(num_cols, col_1=(0, 4)):
    i = 1
    col_0 = [None, (0, 0), (0, 1), (0, 2)]
    default = {
        (0, 4): [(1, 2), None, None, None],
        (1, 5): [None, (1, 2), None, None],
        (2, 6): [None, None, (1, 2), None],
        (3, 7): [None, None, None, (1, 2)]
    }

    idx = global_group[col_1]
    # This works, somehow...
    rotated_col0 = col_0[-idx:] + col_0[:-idx]

    yield rotated_col0

    col_iter = itertools.islice(column_routing(num_cols, col_1), 1, None)
    for c in col_iter:
        yield default[c]

        i = i + 1
        if i > (num_cols - 2):
            break

    # At the second-to-last row of the chip, the branch, which spans two
    # columns to the right, will be truncated by the chip's edge.
    second_last = [None, None, None, None]
    curr_idx = global_group[next(col_iter)]
    second_last[curr_idx] = (1, 1)
    yield second_last

    # At the last row of the chip, BRANCHES connecting to U/D routing (which
    # which normally span two column to the right) will be truncated by the
    # chip's edge.
    last = [None, None, None, None]
    curr_idx = (curr_idx + 1) % 4
    last[curr_idx] = (1, 0)

    # The remaining two globals should come from BRANCHES from the right.
    # But since we run into the chip's edge, we route them to the current
    # column (and only the current column!) here.
    curr_idx = (curr_idx + 1) % 4
    last[curr_idx] = (0, 0)
    yield last

# 256: 9, (0, 4): L: 3, 7 has DCCs R: 0, 4 has DCCs
# 640: 17, (1, 5): L: 0, 4 has DCCs R: 1, 5 has DCCs
# 1200: 21, (0, 4): L: 3, 7 has DCCs R: 0, 4 has DCCs
# 2000: 25, (3, 7), L: 2, 6 has DCCs R: 3, 7 has DCCs
# 4000: 31, (1, 5), L: 0, 4 has DCCs R: 3, 7 has DCCs
# 7000: 40, (2, 6), L: 1, 5 has DCCs R: 1, 5 has DCCs (both top and bottom)
def main(args):
    pytrellis.load_database(database.get_db_root())
    ci = pytrellis.get_chip_info(pytrellis.find_device_by_name(args.device))
    chip_size = (ci.max_row, ci.max_col)

    globals_json = dict()
    globals_json["lr-conns"] = {
        "lr1" : {
            "row" : center_map[chip_size][0],
            "row-span" : row_spans[chip_size]
        }
    }

    globals_json["ud-conns"] = {}

    for n, c in enumerate(column_routing(chip_size[1], start_stride[chip_size])):
        globals_json["ud-conns"][str(n)] = c
        if n == chip_size[1] - 1:
            last_stride = c

    globals_json["branch-spans"] = {}

    for col, grps in enumerate(branch_spans(chip_size[1], start_stride[chip_size])):
        span_dict = {}
        for gn, span in enumerate(grps):
            if span:
                for glb_no in inv_global_group[gn]:
                    span_dict[str(glb_no)] = span

        globals_json["branch-spans"][str(col)] = span_dict


    # For the first and last columns, globals at the stride's current
    # position have DCCs when viewed in EPIC. These DCCs don't appear to
    # physically exist on-chip. See minitests/machxo2/dcc/dcc2.v. However,
    # in the bitstream (for the first and last columns) global conns going
    # into "DCCs" have different bits controlling them as opposed to globals
    # without DCC connections.
    zero_col_dccs = set(inv_global_group[(global_group[start_stride[chip_size]] - 1) % 4])
    zero_col_conns = set(globals_json["ud-conns"]["0"])
    missing_dccs_l = tuple(zero_col_conns.difference(zero_col_dccs))

    last_col_dccs = set(inv_global_group[(global_group[last_stride] + 1) % 4])
    last_col_conns = set(globals_json["ud-conns"][str(chip_size[1])])
    missing_dccs_r = tuple(last_col_conns.difference(last_col_dccs))

    globals_json["missing-dccs"] = {
        "0" : missing_dccs_l,
        str(chip_size[1]) : missing_dccs_r
    }

    with args.outfile as jsonf:
        jsonf.write(json.dumps(globals_json, indent=4, separators=(',', ': ')))


if __name__ == "__main__":
    parser = argparse.ArgumentParser("Store MachXO2 global information into globals.json.")
    parser.add_argument('device', type=str,
                        help="Device for which to generate globals.json.")
    parser.add_argument('outfile', type=argparse.FileType('w'),
                        help="Output json file (globals.json in the database).")
    args = parser.parse_args()

    main(args)