def bits_to_fasm(db_root, part, bits_file, verbose, canonical,
suppress_zero_features):
db = Database(db_root, part)
grid = db.grid()
disassembler = fasm_disassembler.FasmDisassembler(db)
with open(bits_file) as f:
bitdata = bitstream.load_bitdata(f, bitstream.WORD_SIZE_BITS)
model = fasm.output.merge_and_sort(
disassembler.find_features_in_bitstream(bitdata, verbose=verbose),
zero_function=disassembler.is_zero_feature,
sort_key=grid.tile_key,
)
if suppress_zero_features:
output_lines = []
for line in model:
if line.set_feature is None:
output_lines.append(line)
elif not disassembler.is_zero_feature(line.set_feature.feature):
output_lines.append(line)
print(fasm.fasm_tuple_to_string(output_lines, canonical=canonical),
end='')
else:
print(fasm.fasm_tuple_to_string(model, canonical=canonical), end='')
def bit2fasm(db_root, db, grid, bit_file, fasm_file, bitread, part):
""" Convert bitstream to FASM file. """
part_yaml = os.path.join(db_root, '{}.yaml'.format(part))
with tempfile.NamedTemporaryFile() as f:
bits_file = f.name
subprocess.check_output(
'{} --part_file {} -o {} -z -y {}'.format(
bitread, part_yaml, bits_file, bit_file
),
shell=True
)
disassembler = fasm_disassembler.FasmDisassembler(db)
with open(bits_file) as f:
bitdata = bitstream.load_bitdata(f)
model = fasm.output.merge_and_sort(
disassembler.find_features_in_bitstream(bitdata, verbose=True),
zero_function=disassembler.is_zero_feature,
sort_key=grid.tile_key,
)
with open(fasm_file, 'w') as f:
print(
fasm.fasm_tuple_to_string(model, canonical=False), end='', file=f
)
def patch_fasm_with_mem(initfile, fasmfile, outfile, width, depth):
fasm_tuples = fasm.parse_fasm_filename(fasmfile)
mem_tuples = fasm.parse_fasm_filename('memfasm.fasm')
merged_tuples = merge_tuples(fasm_tuples, mem_tuples)
with open(outfile, 'w') as out:
out.write(fasm.fasm_tuple_to_string(merged_tuples))
import os
os.remove('memfasm.fasm')
def bits_to_fasm(db_root, bits_file, verbose, canonical):
disassembler = fasm_disassembler.FasmDisassembler(db.Database(db_root))
with open(bits_file) as f:
bitdata = bitstream.load_bitdata(f)
print(
fasm.fasm_tuple_to_string(disassembler.find_features_in_bitstream(
bitdata, verbose=verbose),
canonical=canonical))
def bits_to_fasm(db_root, bits_file, verbose, canonical):
db = Database(db_root)
grid = db.grid()
disassembler = fasm_disassembler.FasmDisassembler(db)
with open(bits_file) as f:
bitdata = bitstream.load_bitdata(f)
model = fasm.output.merge_and_sort(
disassembler.find_features_in_bitstream(bitdata, verbose=verbose),
zero_function=disassembler.is_zero_feature,
sort_key=grid.tile_key,
)
print(fasm.fasm_tuple_to_string(model, canonical=canonical), end='')
def main():
myargs = parse_args()
assert myargs.fasm is not None
assert myargs.init is not None
assert myargs.width is not None
assert myargs.depth is not None
fasm_to_patch = myargs.fasm
new_init = myargs.init
width = int(myargs.width)
depth = int(myargs.depth)
outfile = myargs.outfile
# init_data = read_meminit(fname=new_init)
fasm_tups = read_fasm(fasm_to_patch)
# cleared_tups = fasmread.clear_init(fasm_tups)
# in_use_tiles = fasmread.get_in_use_tiles(fasm_tups)
# memfasm_tups = initdata_to_memfasm(init_data=init_data, tileorder=in_use_tiles,
# width=width, depth=depth, write_per_block=1, memfasm_name=f'{DIRECTORY}/mem.fasm')
# merged = merge_tuples(cleared_tups=cleared_tups, mem_tups=memfasm_tups)
# with open(outfile, 'w+') as out:
# out.write(fasm.fasm_tuple_to_string(merged))
# print(f'Patched {outfile} successfully (probably)')
# mem_from_reinit = f'{"/".join(new_init.split("/")[0:-1])}/init_frm_reinit.txt'
# os.system(
# f'python3 ../meminit/fasmchange.py -extract_mem -infile {outfile} -outfile {mem_from_reinit}')
# print(f'Memory extracted from {outfile} to {mem_from_reinit}')
# print()
# sorted_tiles = fasmread.get_sorted_tiledata(fasm_tups)
# print()
# rw_widths = fasmread.get_rw_widths(sorted_tiles)
# for tile, width in rw_widths.items():
# print(f'{tile}: {width}')
# print()
# print()
memfasm = initfile_to_memfasm(infile=new_init,
fasm_tups=fasm_tups,
memfasm_name=f'{DIRECTORY}/mem.fasm',
width=width,
depth=depth)
cleared_tups = fasmread.clear_init(fasm_tups)
merged = merge_tuples(cleared_tups=cleared_tups, mem_tups=memfasm)
with open(outfile, 'w+') as out:
out.write(fasm.fasm_tuple_to_string(merged))
def test_one_line_feature(self):
result = list(fasm.parse_fasm_filename(example('feature_only.fasm')))
self.assertEqual(result, [
fasm.FasmLine(
set_feature=fasm.SetFasmFeature(
feature='EXAMPLE_FEATURE.X0.Y0.BLAH',
start=None,
end=None,
value=1,
value_format=None,
),
annotations=None,
comment=None,
)
])
self.assertEqual(fasm.fasm_tuple_to_string(result),
'EXAMPLE_FEATURE.X0.Y0.BLAH\n')
check_round_trip(self, result)
def main():
parser = argparse.ArgumentParser('FASM tool')
parser.add_argument('file', help='Filename to process')
parser.add_argument('--canonical',
action='store_true',
help='Return canonical form of FASM.')
parser.add_argument(
'--parser',
type=nullable_string,
help='Select FASM parser to use. '
'Default is to choose the best implementation available.')
args = parser.parse_args()
try:
fasm_parser = get_fasm_parser(args.parser)
fasm_tuples = fasm_parser.parse_fasm_filename(args.file)
print(fasm_tuple_to_string(fasm_tuples, args.canonical))
except Exception as e:
print('Error: ' + str(e))
def run(db_root, part, fasm_file, canonical):
print(
fasm.fasm_tuple_to_string(process_fasm(db_root, part, fasm_file,
canonical),
canonical=canonical))
def print_tiledata(datatups, outfile):
with open(outfile, 'w') as f:
datatups = fasm.output.merge_and_sort(datatups)
f.write(fasm.fasm_tuple_to_string(datatups))
def run():
"""
Main.
"""
# Parse arguments
parser = argparse.ArgumentParser()
parser.add_argument("--design",
type=str,
required=True,
help="Design JSON file")
parser.add_argument("--fasm",
type=str,
required=True,
help="Decoded fasm file")
parser.add_argument("-o",
type=str,
default="results.csv",
help="Output CSV file")
parser.add_argument("-j", type=str, default=None, help="Output JSON file")
args = parser.parse_args()
# Load IOB features
features = load_iob_segbits()
# Load the design data
with open(args.design, "r") as fp:
design = json.load(fp)
# Load disassembled fasm
fasm_tuples = fasm.parse_fasm_filename(args.fasm)
set_features = fasm.fasm_tuple_to_string(fasm_tuples).split("\n")
# Correlate features for given IOB types
results = []
for region in design:
result = dict(region["iosettings"])
for l in ["input", "output", "inout", "unused_sites"]:
# TODO: Check if this is true eg. for all unused sites, not just
# one random site.
tile, site = random.choice(region[l]).split(".")
matches = correlate_features(features, tile, site, set_features)
result[l] = matches
results.append(result)
# Save results
if args.j:
with open(args.j, "w") as fp:
json.dump(results, fp, indent=2, sort_keys=True)
# Save results to CSV
with open(args.o, "w") as fp:
csv_data = defaultdict(lambda: {})
# Collect data
for result in results:
iostandard = result["iostandard"]
drive = result["drive"]
slew = result["slew"]
if drive is None:
drive = "_FIXED"
iosettings = "{}.I{}.{}".format(iostandard, drive, slew)
is_diff = "DIFF" in iostandard
for feature in sorted(features):
I = [f[1] for f in result["input"] if f[0] == feature and f[1]]
O = [
f[1] for f in result["output"] if f[0] == feature and f[1]
]
T = [f[1] for f in result["inout"] if f[0] == feature and f[1]]
U = [
f[1] for f in result["unused_sites"]
if f[0] == feature and f[1]
]
s = "".join([
"I" if len(I) > 0 else "",
"O" if len(O) > 0 else "",
"T" if len(T) > 0 else "",
"U" if len(U) > 0 else "",
])
csv_data[iosettings][feature] = s
# Write header
line = ["iosettings"] + sorted(features)
fp.write(",".join(line) + "\n")
# Write data
for iosettings in sorted(csv_data.keys()):
data = csv_data[iosettings]
line = [iosettings
] + [data[feature] for feature in sorted(features)]
fp.write(",".join(line) + "\n")
def main():
parser = argparse.ArgumentParser(
description=
"Creates design.json from output of ROI generation tcl script.")
parser.add_argument('--design_txt', required=True)
parser.add_argument('--design_info_txt', required=True)
parser.add_argument('--pad_wires', required=True)
parser.add_argument('--design_fasm', required=True)
args = parser.parse_args()
design_json = {}
design_json['ports'] = []
design_json['info'] = {}
with open(args.design_txt) as f:
for d in csv.DictReader(f, delimiter=' '):
if d['name'].startswith('dout['):
d['type'] = 'out'
elif d['name'].startswith('din['):
d['type'] = 'in'
elif d['name'].startswith('clk'):
d['type'] = 'clk'
else:
assert False, d
design_json['ports'].append(d)
with open(args.design_info_txt) as f:
for l in f:
name, value = l.strip().split(' = ')
design_json['info'][name] = int(value)
db = Database(get_db_root(), get_part())
grid = db.grid()
roi = Roi(
db=db,
x1=design_json['info']['GRID_X_MIN'],
y1=design_json['info']['GRID_Y_MIN'],
x2=design_json['info']['GRID_X_MAX'],
y2=design_json['info']['GRID_Y_MAX'],
)
with open(args.pad_wires) as f:
for l in f:
parts = l.strip().split(' ')
name = parts[0]
pin = parts[1]
wires = parts[2:]
wires_outside_roi = []
for wire in wires:
tile = wire.split('/')[0]
loc = grid.loc_of_tilename(tile)
if not roi.tile_in_roi(loc):
wires_outside_roi.append(wire)
set_port_wires(design_json['ports'], name, pin, wires_outside_roi)
frames_in_use = set()
for tile in roi.gen_tiles():
gridinfo = grid.gridinfo_at_tilename(tile)
for bit in gridinfo.bits.values():
frames_in_use.add(bit.base_address)
required_features = []
for fasm_line in fasm.parse_fasm_filename(args.design_fasm):
if fasm_line.annotations:
for annotation in fasm_line.annotations:
if annotation.name != 'unknown_segment':
continue
unknown_base_address = int(annotation.value, 0)
assert False, "Found unknown bit in base address 0x{:08x}".format(
unknown_base_address)
if not fasm_line.set_feature:
continue
tile = fasm_line.set_feature.feature.split('.')[0]
loc = grid.loc_of_tilename(tile)
gridinfo = grid.gridinfo_at_tilename(tile)
not_in_roi = not roi.tile_in_roi(loc)
if not_in_roi:
required_features.append(fasm_line)
design_json['required_features'] = sorted(
fasm.fasm_tuple_to_string(required_features,
canonical=True).split('\n'),
key=extract_numbers)
design_json['ports'].sort(key=lambda x: extract_numbers(x['name']))
xjson.pprint(sys.stdout, design_json)
def check_round_trip(test, result):
s = fasm.fasm_tuple_to_string(result)
test.assertEqual(list(fasm.parse_fasm_string(s)), result)
def write_fasm(outfile, merged_tups):
with open(outfile, 'w+') as out:
out.write(fasm.fasm_tuple_to_string(merged_tups))
