[oharboe]

make memory printed the inferred-memory table of the last synthesis from mem.json. It is obsolete: nothing in ORFS documents or calls it, and its mem_hierarchical.json branch has read a file nothing writes since hierarchical synthesis moved to estimates (d07d6d9). What is in use is the SYNTH_MEMORY_MAX_BITS check, which stops a doomed synthesis early.

That check needed mem.json, a JSON dump of the whole design written on every synthesis, only so that mem_dump.py could find the memories in it. synth.tcl already loops over the same memories in Tcl for SYNTH_MOCK_LARGE_MEMORIES. The check now runs in that loop, synth_memory_max_bits in flow/scripts/memories/max_bits.tcl, and mem.json, mem_dump.py and make memory go.

What changes

• Every synthesis logs each inferred memory, Memory <path> has dimensions <rows> x <width> = <bits>, with , a ROM for a ROM. Before, the line was written only with SYNTH_MOCK_LARGE_MEMORIES=1. That line and Shrunk memory <path> from <rows> rows to 1 are unchanged.
• A read/write memory over the limit stops synthesis with an error that names each one, its size and the limit. The old error printed the limit where the size belonged.
• A ROM is not counted, as in synth: a ROM is not counted against SYNTH_MEMORY_MAX_BITS #4744.
• The design is still sorted where json -o mem.json sorted it: a yosys backend sorts the design by name before it writes, and the passes after it depend on that order. write_json /dev/null keeps the sort without the file; dropping it changes results and would be its own change.
• Breaking: mem.json is no longer written to RESULTS_DIR, and make memory is gone.
• No longer reported: the list of source files, the instance paths of each memory, and the summary from mem_dump: add summary of inferred memory usage #3855.

Tests

flow/test/test_memory_max_bits.py runs the proc in yosys on a RAM and a ROM twice its size: a RAM over the limit stops synthesis and is named, a ROM over the limit passes and is logged as a ROM, and a mock shrinks the RAM instead of stopping. Counting ROMs again fails two of the three tests.

The loop now runs memory_collect on every synthesis, not only with SYNTH_MOCK_LARGE_MEMORIES=1. CI's QoR check shows whether that moves any design.

Builds on #4744 and is a draft until it merges.

🤖 Generated with Claude Code

[gemini-code-assist]

Code Review

This pull request replaces the Python-based memory size reporting with an early-failing Tcl check during synthesis, ensuring that ROMs (read-only memories) are excluded from the SYNTH_MEMORY_MAX_BITS limit. It also updates the documentation and adds a comprehensive test suite. The review feedback is highly constructive, pointing out a potential crash in the Tcl script if path parsing fails, and suggesting an assertion in the test suite to prevent an uninformative IndexError when tests fail unexpectedly. Both recommendations should be addressed to improve robustness.

[gemini-code-assist]

If select -list returns any unexpected output (such as warnings, info messages, or empty lines), the path may not contain a / character. In such cases, string first will return -1, which causes string range to extract invalid module and instance names, leading to a hard crash in rtlil::get_param. Adding a defensive check to skip paths without a / ensures robustness against unexpected output.

    set index [string first "/" $path]
    if { $index == -1 } {
      continue
    }
    set module [string range $path 0 [expr { $index - 1 }]]
    set instance [string range $path [expr { $index + 1 }] end]

[gemini-code-assist]

If the test fails for an unexpected reason (e.g., Yosys syntax error or file not found), the output will not contain the string "over SYNTH_MEMORY_MAX_BITS=2048". Attempting to split and access index 1 will then raise an IndexError: list index out of range, masking the actual failure output. Adding an assertion to verify the presence of the error message before splitting ensures a clear and helpful test failure message.

Suggested change

	error = output.split("over SYNTH_MEMORY_MAX_BITS=2048")[1]
	self.assertIn("over SYNTH_MEMORY_MAX_BITS=2048", output)
	error = output.split("over SYNTH_MEMORY_MAX_BITS=2048")[1]