File size: 4,726 Bytes
198fb2a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 | import argparse
import json
import sys
def find_top_modules(data):
top_module = []
instantiations = set(
[
cell["type"]
for minfo2 in data["modules"].values()
for cell in minfo2["cells"].values()
]
)
for mname in data["modules"].keys():
if mname not in instantiations:
top_module.append(mname)
return top_module
def find_cells_by_type_in_module(
module_name, data, target_type, current_path, matching_cells
):
for cell_name, cell in data["modules"][module_name]["cells"].items():
cell_path = (
f"{current_path}.{module_name}.{cell_name}"
if current_path
else f"{module_name}.{cell_name}"
)
if cell["type"] == target_type:
matching_cells.append(cell_path)
elif cell["type"] in data["modules"]:
matching_cells.extend(
find_cells_by_type_in_module(
cell["type"], data, target_type, cell_path, []
)
)
return matching_cells
def find_cells_by_type(top_modules, data, module_name, current_path=""):
names = []
for top_module in top_modules:
names.extend(
find_cells_by_type_in_module(
top_module, data, module_name, current_path, []
)
)
return names
def format_ram_table_from_json(data, max_bits=None):
top_modules = find_top_modules(data)
formatting = "{:>5} | {:>5} | {:>6} | {:<20} | {:<80}\n"
table = formatting.format("Rows", "Width", "Bits", "Module", "Instances")
table += "-" * len(table) + "\n"
max_ok = True
entries = []
for module_name, module_info in data["modules"].items():
for cell in module_info["cells"].values():
if not cell["type"].startswith("$mem"):
continue
parameters = cell["parameters"]
size = int(parameters["SIZE"], 2)
width = int(parameters["WIDTH"], 2)
instances = find_cells_by_type(top_modules, data, module_name)
instance_bits = size * width
bits = instance_bits * len(instances)
entries.append((size, width, bits, module_name, ", ".join(instances)))
if max_bits is not None and instance_bits > max_bits:
max_ok = False
entries.sort(key=lambda x: x[2], reverse=True)
for entry in entries:
table += formatting.format(*entry)
# ---- Summary statistics ----
total_bits = sum(e[2] for e in entries)
largest_instance_bits = 0
largest_instance_module = None
for size, width, _, module, _ in entries:
instance_bits = size * width
if instance_bits > largest_instance_bits:
largest_instance_bits = instance_bits
largest_instance_module = module
summary = {
"memory_count": len(entries),
"largest_instance_bits": largest_instance_bits,
"largest_instance_module": largest_instance_module,
"largest_total_bits": entries[0][2] if entries else 0,
"total_bits": total_bits,
}
return table, max_ok, summary
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("file")
parser.add_argument("-m", "--max-bits", type=int, default=None)
args = parser.parse_args()
with open(args.file, "r") as file:
json_data = json.load(file)
src_files = set()
for module_name, module_info in json_data["modules"].items():
for cell in list(module_info["cells"].values()) + [module_info]:
if "src" not in cell["attributes"]:
continue
src_file = cell["attributes"]["src"].split(":")[0]
src_files.add(src_file)
print("Source files actually used in the design:")
print(" " + "\n ".join(src_files))
print("Memories found in the design:")
formatted_table, max_ok, summary = format_ram_table_from_json(
json_data, args.max_bits
)
print(formatted_table)
print("Summary:")
print(f"- Total inferred memories: {summary['memory_count']}")
print(
f"- Largest single memory instance: "
f"{summary['largest_instance_bits']} bits "
f"(module {summary['largest_instance_module']})"
)
print(f"- Total inferred memory bits (all instances): {summary['total_bits']}")
if args.max_bits is not None:
status = "OK" if max_ok else "FAIL"
print(f"- SYNTH_MEMORY_MAX_BITS: {args.max_bits}")
print(f"- Status: {status}")
if not max_ok:
sys.exit(
f"Error: Synthesized memory size {args.max_bits} exceeds SYNTH_MEMORY_MAX_BITS"
)
|