Beacon counts the logic levels of every register-to-register path
of a Vortex design the way Vivado counts them, and the LUTs, flip-flops,
distributed and block RAM and DSPs it maps to, in seconds and without
Vivado. It names the RTL units whose paths are too deep for the target clock,
gates their depth and the design's area on every RTL change (logic_gate),
and is the first step of RTL timing work: run Beacon, fix the deep units,
then confirm with one Vivado run.
| § | contents |
|---|---|
| 1 | Overview and how to run it |
| 2 | System architecture: where each piece lives |
| 3 | Compiler architecture: the two passes |
| 4 | The model: levels per element, devices, area (§4.5) |
| 5 | Outputs |
| 6 | Integration: the DUT flow, logic_gate, timing work |
| 7 | Validation against Vivado; the learned calibration (§7.1); area (§7.2) |
| 8 | Diagnostics beyond levels |
| 9 | Invariants and limitations |
It answers one question per register: how many logic levels is its worst input path? At 300 MHz on the V80, failing end points have a median of 7–8 levels, and between half and four fifths of the registers at 12 or more levels fail, depending on the gate (§7). So Beacon reports:
- fix list: units with end points at ≥ 12 levels;
- watch list: ≥ 8 levels.
It does not predict slack, because it does not see wires (§9).
One DUT of the synthesis catalog, from a configured build tree:
make -C hw/syn/xilinx/dut tcu-beacon
# build_tcu/beacon_paths.txt every path at >= 8 levels, op by op, by unit
# build_tcu/beacon_units.json deepest end point per RTL unit, area per unit
# build_tcu/beacon_area.txt LUTs, FFs, memories and DSPs, by unit; each memory's placementThe whole catalog as a gate, on the FPGA and the ASIC flow, against the merge base as a pull request is judged, and a baseline update (a human step):
ci/logic_gate.py -j 2
ci/logic_gate.py --tool beacon_asic -j 2
ci/logic_gate.py -j 2 --against-rev $(git merge-base HEAD origin/master)
ci/logic_gate.py -b om --update-baselineAny CIRCT netlist, with ci/beacon.py (subcommands run,
summarize, paths, validate, retime-split, ports, buffers,
calibrate, score, diff, asic-summary, ties;
foldsim-opt from the PATH or FOLDSIM_OPT):
ci/beacon.py run design.mlir runs/full # map, then count levels and area
ci/beacon.py run runs/full/mapped.mlirbc runs/socket \
top=VX_socket__lift black-boxes=VX_core__lift # one unit of a mapped design
ci/beacon.py summarize runs/full --min-levels 12 # deep end points by RTL unit
ci/beacon.py paths runs/full --unit lsu_unit # its paths, op by op (§5)
ci/beacon.py validate runs/socket ep.csv --native VX_socket__lift=dutOr the passes directly:
foldsim-opt design.mlir --emit-bytecode -o mapped.mlirbc \
--pass-pipeline='builtin.module(foldsim-beacon-map{target=virtexuplusHBM})'
foldsim-opt mapped.mlirbc -o /dev/null --pass-pipeline='builtin.module(
foldsim-estimate-timing{top=VX_core_top target=virtexuplusHBM
output=endpoints.csv instances=instances.csv report=report.txt
top-paths=50 trace=lsu_unit})'
foldsim-opt design.mlir -o /dev/null --pass-pipeline='builtin.module(
foldsim-beacon-map{target=virtexuplusHBM area},
foldsim-estimate-area{top=VX_core_top target=virtexuplusHBM
output=area.csv memories=area_memories.csv report=area.txt})'foldsim-estimate-timing option |
meaning |
|---|---|
top= |
the top module (default: the one nothing instantiates) |
target= |
the Beacon target (§4.2): versal (V80, default), virtexuplus, virtexuplusHBM (U55C), zynquplus, or asap7 (ASIC, §4.3); map with foldsim-beacon-map for the same target |
black-boxes= |
modules to treat as external, as a harness stubs them |
output=, instances=, report= |
the files of §5 |
min-levels= |
write only end points at or above this many levels |
top-paths= |
deepest paths to print op by op (default 50) |
trace= |
also print the deepest path of each end point whose name contains this |
paths=, path-levels= |
every path of at least path-levels (12) levels, one per pair of registers, op by op (§5) |
retime-levels= |
also estimate the depth after Vivado's retiming to this period (§4.4) |
ports=, port-modules= |
the depth at each port of the named modules' instances (§8) |
foldsim-estimate-area option |
meaning |
|---|---|
top=, target=, black-boxes= |
as for foldsim-estimate-timing; map with foldsim-beacon-map{area} for the same target |
output= |
the instance table of §5 (area.csv) |
memories= |
every memory, its shape and where it goes (area_memories.csv) |
report= |
the design's totals, the mapping's LUTs by op, the vendor IP |
lut-scale= |
device LUTs per mapped LUT (default: the target's, §4.5) |
modules=, state-threads= |
per module, its totals and its state's cost folded over that many threads (JSON; foldsim's fold-degree search prices copies with it) |
The engine is two compiler passes of foldsim (foldsim-opt), built on
CIRCT like the rest of foldsim, and shipped in the foldsim prebuilt. Vortex
never builds it. The integration is in Vortex:
| Piece | Where | Role |
|---|---|---|
foldsim-beacon-map, foldsim-estimate-timing, foldsim-estimate-area |
foldsim lib/Transforms/Beacon.cpp, EstimateTiming.cpp, EstimateArea.cpp |
map to the target's cells; count levels; count area |
ci/beacon.py |
ci/ |
run Beacon on any netlist; read it by unit; compare with Vivado |
xilinx_cone_dump.tcl, xilinx_cone_probe.tcl, xilinx_wire_probe.tcl |
hw/scripts |
Vivado probes for what levels cannot show (§8) |
target beacon |
hw/syn/xilinx/dut/common.mk |
one DUT: sources → netlist → levels and area → summary |
circt_elaborate.sh |
hw/scripts |
the lowered HW/Comb/Seq netlist, no firtool |
gen_platform.py --emit=family |
hw/scripts |
the family of DEVICE, from hw/syn/xilinx/platforms |
beacon_summary.py |
hw/scripts |
beacon_summary.csv, per-unit beacon_units.json, beacon_area.txt |
Beacon backend, logic_gate.py |
ci/synth_gate.py, ci/ |
the gate, beside fpga_gate and asic_gate |
logic_gate.yml |
.github/workflows |
runs it on pull requests that touch RTL |
Beacon reads the same CIRCT import that foldsim
uses (circt-verilog --ir-hw), elaborated from the sources and defines
gen_sources.sh writes for Vivado, with the Xilinx floating-point IPs as
black boxes (xilinx_ip_stubs.sv).
Every pass loads the same target from foldsim's target table
(foldsim/Beacon.h): its cells for the mapping, its DSPs and delays for the
level count, its LUT scale for the area (§4.5). A target is named after its FPGA family or its PDK, so every
flow passes the name it already has: the DUT flow the family
gen_platform.py --emit=family gives for DEVICE, the ASIC flow PDK,
ci/beacon.py run its target=. The mapping is a pipeline of CIRCT's
synthesis passes plus three of foldsim's, per module:
- Inline small modules (
hw-flatten-modules, < 300 ops) so LUTs pack across buffers, arbiters and switches, as Vivado's flattened synthesis does. Larger modules stay instances; the estimator elaborates them. - Canonicalize and balance mux chains (
comb-balance-mux). - foldsim passes:
foldsim-lower-equality: an equality compare is XORs and an OR tree, which pack into LUTs;foldsim-lower-constant-division: a division by a constant is an extract (power of two) or a table (dividend of ≤ 10 bits), as synthesis writes it;foldsim-fold-zero-width: zero-width values are constants, which CIRCT's lowering otherwise rejects.
- Lower to an and-inverter graph (
convert-comb-to-synth). Adders, subtracters, compares, multipliers, dividers and remainders stay word-level: the estimator models them as the carry chains, DSPs and tables Vivado builds, which a LUT mapping of their gates would not reproduce. - Depth-optimize the graph: timing-aware variadic lowering, maximum AND cover, SOP balancing, structural hashing.
- Map to the target's cells (
synth-generic-lut-mapper, timing strategy): 6-input LUTs on the FPGA families, 3-input cuts on ASAP7.
The full GPU maps in about a minute and 18–20 GB.
With area, the same lowering maps the design for foldsim-estimate-area
instead. A depth-oriented cover duplicates logic to save levels, so its
cells are no measure of area; the area mapping is what Vivado does off the
critical paths:
- every module stays an instance, so each one's resources stay its own (inlining moves the count by 1–4 %), and each module maps once however many instances it has;
- no mux balancing, no maximum AND cover and no SOP balancing;
- variadic logic lowered sharing common subsets (
reuse-subsets), and the cut mapper's area strategy.
A DUT of the catalog maps for area in 1–16 s.
The estimator works on the elaborated design: one context per instance, and one node per (context, value, bit). It never enumerates paths:
- Collect end points by walking the instance tree from
top. - Resolve each end point bit through wires, extracts, concatenations, replicates and instance ports to the op that drives it.
- Evaluate with an iterative depth-first walk: a node's levels are the maximum over its inputs of the input's levels plus the edge's (§4), and it keeps its one worst predecessor. An input still being evaluated closes a combinational loop; that edge is left out and counted.
- Report: each end point's start point is found by walking the worst predecessors back; the walk also yields the path's largest fanout and its module crossings.
Time and memory are linear in the design's bits: the full GPU runs in 16–21 s and 2.7 GB, a DUT of the catalog in seconds.
The area estimator counts each module's own ops once (§4.5), then sums the
instance tree from top: a module's total is its own resources and its
instances' totals. It writes one row per instance, depth first, with the
instance's own resources and its subtree's, and one row per memory with the
placement chosen for it. It takes under a second on a DUT.
| Element | Levels |
|---|---|
LUT (comb.truth_table) |
1 |
| Adder or subtracter, input bit j to output bit i | 2 + ⌊i/8⌋ − ⌊j/8⌋: a LUT, then the 8-bit carry blocks; 1 if the output bit reads ≤ 6 input bits (one LUT6) |
| Order compare | as an adder, up to the highest bit not constant in both operands |
| Equality compare | lowered to LUTs by the mapping |
| Multiply, ≤ 10 variable operand bits | a table of constants: 1 + ⌈(bits − 6)/2⌉ |
| Multiply, wider | a DSP cascade over the significant bits (§4.2) |
| Divide or remainder | a table over the bits its operand cones depend on, if ≤ 10; else a ripple of one subtracter per quotient bit |
Distributed-RAM read (seq.firmem, latency 0) |
1, plus 1 per doubling past 64 words (MUXF7, MUXF8, LUT), from the address |
| Other ops | 1 per op, listed in the report |
Significant bits exclude constant bits on top and copies of the bit below (a sign extension). A table is a LUT6 for six inputs and a level of 4:1 multiplexers per two more.
Versal and the UltraScale+ families all have LUT6s, 8-bit carry blocks
(LOOKAHEAD8, CARRY8) and 64-word distributed RAMs; they differ in their DSPs.
The target is selected by target=, with the family names of
hw/syn/xilinx/platforms:
target= |
Device | DSP multiplier | fabric → registered product | product → fabric | per cascaded DSP |
|---|---|---|---|---|---|
versal |
V80 | DSP58, 27 × 24 | 1 | 6 | 3 |
virtexuplus |
U200, U250 | DSP48E2, 27 × 18 | 1 | 5 | 2 |
virtexuplusHBM |
U50, U55C, U280 | DSP48E2, 27 × 18 | 1 | 5 | 2 |
zynquplus |
Zynq UltraScale+ | DSP48E2, 27 × 18 | 1 | 5 | 2 |
A product takes ⌈a/A⌉·⌈b/B⌉ DSPs (the better orientation). The cell counts are Vivado's: on Versal, M_DATA, ALUMUX, ALUADD and OUTPUT out of a DSP, and ALUMUX, ALUADD and OUTPUT through each cascaded one. A register fed by the product is the DSP's own (MREG or PREG), and so is a LUT that reads that register back, its clock enable or feedback; any other load pays the output stage. The fabric-to-product value is fitted on the V80 data. A name that is not a target is an error that lists the targets.
For the ASIC flow (hw/syn/yosys, ASAP7 7.5-track RVT, TT corner)
Beacon counts cell stages, not LUT levels. target=asap7
maps the same balanced and-inverter graph to 3-input cuts, each one cell
(NAND, AOI, MAJ, XOR), and models the word-level operators
as an ASIC builds them:
| Element | Stages |
|---|---|
cell (comb.truth_table, 3 inputs) or unmapped and-inverter gate |
1 |
| adder, input bit j to output bit i | 2 + ⌈log₂(i − j + 1)⌉: a prefix adder |
| order compare | 1 + ⌈log₂ span⌉ |
| multiply | partial products, a Dadda tree of full adders (2 stages each), a prefix adder |
| table of k inputs (small products and dividers) | k (a multiplexer tree) |
| memory of flops (no macro) | 1 + ⌈log₂ depth⌉: a decoder and a multiplexer tree |
SRAM macros (VX_dp_ram_asic, VX_sp_ram_asic) are black boxes, as in the
flow's synthesis: their pins end and start paths. The report converts the
deepest path to a period:
deepest path 45 stages: 58 + 167 + 45 x 24 + 6 = 1311 ps (763 MHz)
clk→Q path stages × cell setup
The cell (24 ps at fanout 3 and its own slew), clock-to-output (58 ps) and
setup (6 ps) delays come from the Liberty, by hw/syn/yosys/liberty_stage.py;
the path term (167 ps: the inverter after a DFFHQN's QN, buffering, slew) is
fitted on OpenSTA (§7). Re-derive them for another corner or threshold
voltage.
All of Vortex's Vivado runs retime. With retime-levels=N, the retimed
column estimates each end point's depth after one hop of balancing to a
period of N levels. The end register moves backward into the room its
output stage leaves, and the start register moves forward into the room its
input stage leaves. Neither crosses a distributed RAM or a DSP, and only a
register Vivado can retime (synchronous reset) moves. Top ports and
black-box pins count as registers with empty neighbour stages, as a gate
harness makes them. It ranks no better than plain levels, so levels stays
the ranking; retimed ≥ 12 at retime-levels=10 is a short list of fix
candidates retiming is unlikely to absorb.
The area mapping (§3.1) first takes out of the netlist what Vivado keeps out of LUTs:
- Clock enables and synchronous resets (
foldsim-register-enables). A select between a register's next value and the register itself is the flip-flop's CE pin, and a select of a constant under it the R or S pin; neither takes a LUT (Vivado'sVX_pipe_registers with reset and enable have none). The register becomes aseq.compreg.ce; its enable and reset are one gate per register, not per bit. - Register bits that never leave 0 (
foldsim-constant-registers). A flip-flop powers up at 0, so a bit that only loads 0 or itself, and resets to 0 if at all, is the constant 0, and the register narrows to its other bits (VX_cache_amo's write-back offset, of which only bit 5 varies, makes its shift a select of two amounts). - Bits a select passes through (
foldsim-narrow-muxes). A procedural write of part of a vector in a loop elaborates to a select per iteration of the whole vector, whose arms agree on every bit outside that part; lowered to and-inverter gates, each such bit stays a pair of gates and every iteration's condition reaches it.VX_cache_amo's read-forward loop over the L2's 512-bit word (64 bytes of 4 write-back slots and the settling entry) is a chain of 320 whole-word selects, every one reaching every bit. Each select narrows to the runs where its arms differ. - Styled ROMs (
foldsim-styled-roms). A constant table on a wire withrom_styleblockordistributedbecomes a memory of its shape, placed as below (VX_tfu's table: one block RAM, as Vivado places it, instead of 12,321 mapped LUTs of logic).
Then, per op:
| Element | FPGA | ASAP7 |
|---|---|---|
LUT (comb.truth_table) |
1 LUT | 1 cell |
| Adder or subtracter | a LUT per bit into the carry chain | a prefix adder: w · (2 + ⌈log₂ w⌉) cells |
| Order compare | a LUT per two bits | 2 cells per bit |
| Multiply by a constant | a LUT per bit (shifts and adders) | 3 cells per bit |
| Multiply, ≤ 10 variable operand bits | a table: a LUT per output bit (at most as many as the operands' variable bits), per 64 entries past six bits | the same in cells |
| Multiply, wider | DSPs: the fewer of ⌈a/A⌉·⌈b/B⌉ in either orientation over the significant bits (§4.2) | partial products and a Dadda tree: 3·a·b cells |
| Divide or remainder (output bits: at most the dividend's) | a table over ≤ 10 variable bits; a constant divisor, 2 LUTs per bit; else a subtracter per quotient bit, a LUT per result bit | the same, but 3 cells per subtracter bit |
| Register | a flip-flop per bit | a flip-flop per bit |
Vendor IP (xil_*) |
its logic LUTs, flip-flops and DSPs: for xil_fma, xil_fdiv and xil_fsqrt the medians of their routed instances in the U55C builds (616, 743, 412 LUTs; 1,064, 1,360, 786 flip-flops) |
— |
| SRAM macro (black box) | — | a macro |
Memories go where Vivado infers them. A ram_style the RTL asks for wins
(VX_dp_ram writes block for FORCE_BRAM sizes and distributed for
LUTRAM; the RAM fold, ram_fold.py, registers the read of the RAMs it
folds, so VX_dp_ram writes block for them too). Otherwise a
read of latency 0 is distributed RAM, and a registered read of at least 32
words and 2 Kb is block RAM. The shapes are the same on every FPGA family:
| Placement | Cost |
|---|---|
| distributed RAM | 0.57 LUTs per bit up to 32 words (RAM32M16), 1.14 per 64 words beyond (RAM64M8), per read port, plus a multiplexer tree over the 64-word LUTs |
| block RAM | the fewest 36 Kb blocks of any shape (512 × 72 … 32K × 1) or 18 Kb halves; a copy per two ports, a read-write port one of them |
UltraRAM (ultra) |
4096 × 72 each |
registers |
flip-flops and a read multiplexer |
Two shapes override the inference:
- A memory distributed RAM cannot hold is flip-flops: one read of
latency 0 at each of its words, at constant addresses (an associative
lookup, as the MSHR's
addr_table,word_tableandsector_tableare), or more than seven read ports besides a read-write port. Its constant-address reads are wires (in a copy folded over threads, a multiplexer over the threads), every other read a multiplexer per bit, and each word a write enable on its flip-flops' CE pins. The L2 MSHR goes from 629 to 348 distributed RAM LUTs and from 167 to 567 flip-flops per bank, against Vivado's 352 and 579. - A block RAM writes 8- or 9-bit bytes under a mask, so a memory masked in lanes that are not whole bytes (neither a multiple of 8 nor of 9 bits) is a block RAM per lane: the L2 tag store (64 × 136 in eight 17-bit lanes) is eight 18 Kb halves, the I-cache's (64 × 80 in four 20-bit lanes) four, as Vivado builds them.
- A memory without a write port is a ROM: in distributed form, logic (a table over the address per bit and read, nothing for one word), not distributed RAM, which is how Vivado reports it. A memory nothing reads costs nothing.
On ASAP7, a memory without a macro is flip-flops, a write decoder and a read multiplexer tree.
The LUT scale. The cut mapper has none of Vivado's LUT combining or
wide multiplexers (MUXF7/F8), and maps module by module, without the logic
Vivado trims across module boundaries, so it covers a design with 2.6× the
logic LUTs Vivado leaves at the geometric mean, from 1.4× (lmem) to 7.5×
(rtu) (§7.2). The target's lutScale
converts the mapping's LUTs to Vivado's: 0.391 on the LUT6 families, the
geometric mean over the 14 routed U55C fpga_gate DUTs of Vivado's logic
LUTs, less what Beacon prices outside the mapping (vendor IP, memory
multiplexers), over Beacon's mapped LUTs (§7.2). The V80 shares that value
without a fit of its own, and asap7 has none (1.0): its cell counts are
not yet compared with Yosys. Vendor IP and distributed RAM, and the
memories' read multiplexers, are not scaled; lut-scale=1 gives the raw cover.
| File | Contents |
|---|---|
endpoints.csv |
one row per end point bit: levels,retimed,kind,start_kind,fanout,crossings,start_inst,start,end_inst,end |
instances.csv |
the instance tree: id,parent,instance,module (the *_inst columns' ids) |
report.txt |
counts, combinational loops, ops without a model, the histogram of end points by levels, the top-paths deepest paths op by op, and the deepest path of each trace= match |
beacon_summary.csv |
the DUT flow's one row: max levels, end points ≥ 12, ≥ 8, all, and the area |
paths.jsonl |
paths=: one JSON line per pair of start and end registers whose deepest bit has at least path-levels levels: that bit's levels, the pair's bit count, start, end, and ops, the path from the end back to the start as [levels, kind, fanout, instance id, name, source] |
beacon_units.json |
the deepest end point of every unit at ≥ 8 levels, and the 10 deepest paths |
beacon_paths.txt |
the DUT flow's paths.jsonl at ≥ 8 levels, by unit (ci/beacon.py paths for any run) |
area.csv |
one row per instance, depth first: depth,path,module, its own lut,lutram,ff,bram,uram,dsp,macros, then its subtree's (total_*); lut is logic LUTs, scaled (§4.5) |
area_memories.csv |
one row per memory: its instance, name, depth, width, read, write and read-write ports, read latency, ram_style, placement and cost |
area.txt |
the design's totals, the mapping's LUTs by op before scaling, and the vendor IP |
beacon_area.txt |
area.txt, the units with ≥ 1 % of the LUTs (one copy's subtree, × copies), and every memory with its placement |
beacon_summary.csv also holds the design's lut (distributed RAM
included, as Vivado's utilization counts it), ff, lutram, bram,
uram and dsp, and beacon_units.json an area map of every unit's
resources (one copy's subtree) and copy count.
A path in report.txt, deepest first, one op per line: levels at the op,
its kind, the fanout of its bit, and its instance path and name:
#1 levels 20: .../mem_req_queue/pending_size/used_r.d[0] (VX_socket__lift)
20 lut fo 0 .../comb.truth_table[0]
19 carry fo 1 .../comb.add[0]
...
0 reg fo 59 .../req_pending/in_fire_r[13]
report.txt's deepest paths are often one pair of registers, bit after bit.
The path list has every deep path once:
- one per pair of start and end registers, its deepest bit, with the number of bits it stands for;
- pairs whose names differ only in generate indices (
g_banks_0,g_banks_1) and bits fold into one, as units fold them, so a unit the gate names is a heading of the list; - units deepest first, and in each unit its paths deepest first;
- each op with the source line it came from. Mapped LUTs have no name
of their own, so the file and line are what locate them in the RTL. The
DUT flow elaborates
hw/rtlitself (not preprocessed copies), so the lines are the repository's.
== cache/g_cache_cache/g_banks_*_bank/g_amo_amo: 24 levels, 23 paths
24 levels, 1024 d bits in 4 copies
from cache/g_cache.cache/g_banks_0.bank/g_amo.amo/g_commit.chain_match_r[0]
to cache/g_cache.cache/g_banks_0.bank/g_amo.amo/g_commit.wbq_data.d[6]
24 lut fo 0 VX_cache_amo.sv:211 .../g_amo.amo/comb.truth_table[0]
22 lut fo 1 VX_cache_amo.sv:700 .../g_amo.amo/comb.truth_table[0]
...
10 carry fo 839 VX_cache_amo.sv:689 .../g_amo.amo/comb.sub[1]
...
0 reg fo 2 VX_cache_amo.sv:773 .../g_commit.chain_match_r[0]
On the full GPU, the 3,283 pairs at ≥ 12 levels fold into 169 paths in 69 units.
hw/syn/xilinx/dut builds every DUT of catalog.mk for Vivado; its
beacon target runs Beacon on the same DUT with the same sources, defines and
DEVICE (the U55C by default):
gen_sources.shintobeacon/sources.f, a filelist ofhw/rtlwith the defines (not preprocessed copies, so source lines are the repository's);circt_elaborate.shintobeacon/netlist.mlir, the FP IPs as black boxes, with every op's source location;foldsim-beacon-map, thenfoldsim-estimate-timing; andfoldsim-beacon-map{area}, thenfoldsim-estimate-area; all withtarget=the familygen_platform.py --device=$(DEVICE) --emit=familynames;beacon_summary.py:beacon_summary.csv,beacon_units.json,beacon_paths.txtandbeacon_area.txt(§5).
The ASIC flow has the same target, with the same sources, defines and SRAM
black boxes as its synthesis, and target=$(PDK):
make -C hw/syn/yosys/dut om TARGET=beacon
# om_VX_om_core_top/beacon/report.txt: the deepest paths and the periodThe third synthesis gate, beside fpga_gate (Vivado, nightly) and
asic_gate (Yosys + OpenSTA, nightly); see
continuous_integration.md §3.5. It runs Beacon on
fpga_gate's builds (ci/testcases/logic_gate.yaml; top as its Vortex
core, top_vortex, since VX_cp_core keeps LLHD reference ports) in about
four minutes, and checks each against ci/baselines/synthesis/beacon/:
-
a unit that gets deeper fails, by name;
-
a new unit at or above the fix threshold (12) fails;
-
a unit that gets shallower, or leaves the watch list, is an improvement to lock in by re-recording;
-
end point counts are recorded, not gated (they grow with lanes and warps);
-
a resource of the design (
lut,ff,lutram,bram,uram,dsp) more than 5 % above its baseline fails,fpga_gate's LUT tolerance (catalogthresholdsand--metric-thresholdoverride it); 5 % below is an improvement to lock in. A memory that moves between distributed and block RAM shows as both columns moving. -
the harness: the instance-input bits the DUT top ties to constants (
ci/beacon.py ties, columntied) must not change from the baseline. Vivado and Yosys fold the logic behind a tied input; Beacon maps module by module and does not, so a harness edit makes the synthesis gates measure a different design while Beacon's numbers stay put. A tied count that moves needs a reviewed look at the synthesis budgets, then a re-record. (A tex wrapper that zero-extended 128 LOD bits read 129 tied bits, the corrected one 1; Vivado's LUTs moved 28 % and Beacon's not at all.)
A failing build names its beacon_paths.txt, where the failing unit is a
heading with its paths op by op, its beacon_area.txt, and its
beacon_risk.txt, the registers the learned calibration (§7.1) predicts
slowest; CI uploads them with the build's logs. The calibration's Fmax and
count of likely failures are columns of the report (p_fmax, risk), not
gated: a wire-dominated path that levels rank low shows there first. A
p_fmax below the build's clock is printed as an advisory line, never a
verdict: held to the clock (2 % below), it failed 7 builds Vivado closed
against 3 it did not, among them the known-good core, at 285.6 MHz on both
sides of a fix that took Vivado from 286 to 298 MHz.
Depth is deterministic, so the tolerance is zero. Area is as
deterministic, but a feature adds some by design, so it has the Fmax gate's
tolerance. The baseline fingerprint
is the CIRCT and foldsim versions, DEVICE and XLEN: a new foldsim reads
as STALE, not as a regression. Baselines are golden data, re-recorded only
by a human (--update-baseline), as for the other gates.
ASIC (--tool beacon_asic). The same gate on asic_gate.yaml's builds,
through the ASIC flow's beacon target (§6.1, ASAP7, §4.3), with its own
baselines (ci/baselines/synthesis/beacon_asic/). The FPGA builds use the
DSP FPU and a DSP multiplier, so the STD FPU and the ASIC multiplier tree,
where asic_gate misses timing, are only elaborated here. The 14 builds take
7 minutes at -j 2 (the FPGA catalog 9), with at most 5.4 GB per process.
- flip-flops and cells within 5 % of the baseline, both ways, as the FPGA
area. A memory without a macro is priced as flip-flops (Yosys builds it
so): an asynchronous read that left an SRAM macro read +17 % flip-flops on
the cache, named
g_mask_async.byteen_store, whereasic_gatemeasured +22 % area the next night. SRAM macros are reported, not gated: a memory that moves into a macro adds one and removes its flip-flops (the fix of that cache took it from 32 to 36). - predicted Fmax no more than 32 % below
clock_mhz. Beacon's period runs 0.59–1.05 × OpenSTA's (it prices vm's L2 TLB MRU update at 46 stages, 749 MHz, where STA closes at 1266 MHz), so the band is a backstop for a path no model error explains, not a timing verdict. Over every validated pair of a design and a target, the lowest prediction of a design STA closes is 0.749 of its target (vm, and top after the FPU fix, at 1 GHz), the highest of one that misses badly 0.615 (core and top before it, 492 MHz at 800); 32 % sits between them with about 10 % margin each side, at both the 800 MHz and the 1 GHz target. A prediction below the target but inside the band is printed as an advisory line. - the harness's constant ties, as above.
clock_mhz is not in the ASIC fingerprint: Beacon reads no clock, so a new
target moves the band and the stage thresholds, not the measurements. The
borrowed builds bring their designs and targets, not asic_gate's
known_issue or thresholds, which describe Yosys's numbers.
Against the merge base (--against-rev REV). A baseline recorded on a
change's own head cannot see that change: when Beacon arrived together with
the RTL it should have flagged, its baselines were recorded on that RTL and
the gate compared the head with itself (+0 % by construction). So a pull
request is also judged against its merge base. The reference is REV's
design (hw/rtl, hw/unittest, hw/dpi, hw/syn/libs/no_mem, the
configuration TOMLs, and the submodules at the commits REV pins) under this
checkout's flow (CI, scripts, catalog), so both sides are measured by the
same Beacon. It is staged and built in <cache>/<sha>/ (--ref-cache,
default .beacon_ref/, the four most recently used kept), under a lock on
<sha>.lock, and reused while the flow is unchanged. Each build is then
compared with the same build there by beacon.py diff (§6.3), and its
tied bits with the reference's. Only registers at or above the watch
threshold in either run count (8 levels; on the ASIC flow the stages that
fit 90 % of the period, 38 at 800 MHz and 28 at 1 GHz):
| verdict | meaning | fails |
|---|---|---|
DEEPER |
a watched register 4 or more levels (stages) deeper, or newly at the fix threshold | yes |
AREA |
a resource of the design past the 5 % tolerance (on the ASIC flow cells and flip-flops) | yes |
HARNESS |
the tied bits changed | yes |
REF-FAIL |
the reference did not measure the build: it failed, timed out, or ran under another configuration; the run exits 2, as for a build error | yes |
ACCEPTED |
every regression is one the baseline's re-record accepted | no |
NO-REFERENCE |
REV has no such DUT, neither in its catalog nor its top module: a DUT the change adds, judged against its baseline alone. A DUT REV has under another top (a renamed harness) is REF-FAIL |
no |
A change to the flow itself (source generation, include lists, a pyslang
rule) can leave the merge base's RTL unable to elaborate under it, and then
every build reads REF-FAIL. The way out is a pull-request label,
beacon-skip-reference, which only a maintainer grants, as a reviewed
decision: ci.yml then leaves the merge base unset, and the cell says so in
its log and job summary; the verdict is against the baselines alone.
On the ASIC flow the thresholds come from the clock: the fix threshold is the stages that fit the target period with the run's own delays (43 at 800 MHz, 33 at 1 GHz), the watch threshold those that fit 90 % of it.
A baseline re-record in a pull request ships its beacon_diff against
the merge base. Re-record with --update-baseline --against-rev <merge base>: the regressions against it are written into each baseline entry
(accepted), so the baseline diff under review lists, register by register
and resource by resource, what the change accepts, and CI reads them as
ACCEPTED. A later regression the re-record did not see still fails, and
a re-record without --against-rev accepts nothing. An acceptance holds
until it lands: once the reference revision's own baseline carries the
same accepted entry, the change it accepted is part of the reference, and
it is ignored.
Beacon is the inner loop of any RTL change that can move timing. A DUT takes minutes in Beacon and hours in Vivado or Yosys, so a deeper path is found and fixed while the change is still open, and synthesis runs once, to confirm.
-
Reference and change. Beacon on the parent revision, built once per base under
.beacon_ref/<sha>/, and the same builds on the working tree, each compared with the reference register by register:ci/logic_gate.py -b core -b lmem --against-rev HEAD ci/logic_gate.py --tool beacon_asic -b core --against-rev HEAD # the ASIC flow--against <build tree>compares with a reference run anywhere else (e.g.git worktree add ../ref HEADand../ref/ci/logic_gate.py -b core --build-dir $PWD/build32_beacon_ref). -
Iterate. Edit and rerun the same command: the reference is reused.
A change behind a non-default knob is compared at that setting: give both runs the same
--configs="-D...", which appends the flags to every selected build's catalog configuration. The catalog baselines are not gated then, and none can be recorded.Besides the per-unit verdict against the golden baseline, each build writes
beacon_diff.txt(ci/beacon.py diff). Its headline is the deepest register, the mean of the 50 deepest and the count at the watch threshold, before and after; then it lists the registers that got deeper, new deep registers, and the ones that got shallower, then the units whose deepest register moved. With area, the headline adds the LUTs, block RAMs and DSPs (cells, flip-flops and SRAM macros on the ASIC flow) before and after, and a section lists each resource of the design and the units whose own area moved, all copies; a resource more than 5 % larger fails the run (AREA). The run fails (DEEPER) on a register 4 or more levels deeper, one that reaches the fix threshold (12) from below, or a new one at it. These limits come from 13 routed U55C builds: a register 4 or more levels deeper lost slack in Vivado in every case (170 of 170), while 1 to 3 levels is within the placer's noise, so those are listed as "deeper by less" to watch, not failed. Of the headline numbers, the top-50 mean follows Vivado's worst slack (Spearman 0.56) and the single deepest register does not (0.29). A new register below 12 is listed but passes, since a rename looks the same. -
Fix.
ci/beacon.py paths <build>/beacon --unit <unit>prints a deep unit's paths op by op. Edit, and repeat step 2 until nothing got deeper, or until each deeper path is one the change intends. -
Confirm. Run synthesis once per change, not once per edit: the
fpga_gateorasic_gatebuilds of the DUTs whose depth moved. Then feed the result back.ci/beacon.py validate <build>/beacon ep.csvcompares the run with Vivado's end point table, and a disagreement there is a Beacon bug to fix in foldsim.
Beacon counts logic levels and cells; it does not see wire delay,
placement, SLR crossings or congestion. A change that moves those (a wide
fan-out, a floorplan) still needs synthesis before it lands. Compare a fix
against a native gate (hw/syn/xilinx/dut or the OOC gates), not the folded
design (§9).
Against Vivado, per RTL register or memory: Beacon's deepest bit
against Vivado's deepest failing path and worst slack, on seven V80 datasets
with no new Vivado runs (ci/beacon.py validate):
| Dataset | Vivado run | Spearman vs levels | Spearman vs slack | ≥ 12: precision / recall |
|---|---|---|---|---|
| full GPU, folded | 4.0 ns, routed, 270 k end points | 0.75 | 0.45 | — |
| socket | native gate, 4.0 ns, routed | 0.55 | 0.53 | 0.64 / 0.31 |
| D-cache | native, 4.0 ns, routed | 0.71 | 0.55 | 0.67 / 0.38 |
| top | native gate, 3.333 ns, placed | 0.53 | 0.39 | 0.19 / 0.53 |
| socket | native gate, 3.333 ns, placed | 0.50 | 0.33 | 0.52 / 0.18 |
| core | native gate, 3.333 ns, placed | 0.93 | 0.62 | 0.81 / 0.13 |
| compute slice | native gate, 3.333 ns, placed | 0.87 | 0.75 | 0.58 / 0.57 |
Beacon's depths run about 1.25× Vivado's on the native gates. The U55C
profile was checked against fpga_gate's critical paths: it agrees with
the V80 profile wherever no DSP is on the path, and the remaining
disagreement is the same on both devices.
ASAP7, against OpenSTA on fresh syntheses of five DUTs (Yosys + ABC as
hw/syn/yosys builds them, flip-flops named after their registers,
hw/syn/yosys/sta_endpoints.tcl for the slack of each):
| DUT | Registers | Spearman, stages vs arrival | Worst path: OpenSTA → Beacon |
|---|---|---|---|
| om | 93 | 0.91 | 827 → 879 ps |
| cache | 526 | 0.82 | 1450 → 1311 ps |
| dxa | 169 | 0.56 | 1018 → 1215 ps |
| raster | 134 | 0.58 | 879 → 879 ps |
| tex | 1002 | 0.93 | 840 → 807 ps |
Per register, the fitted delay per stage is 17–25 ps, the library's 24. The worst path is within a mean 8 % on these five, from which the path term was fitted; on the six larger DUTs, the predicted Fmax is within a mean 13 % (−32 % to +3 %) of the asic_gate baselines, some of which predate the current RTL. Beacon runs a DUT in 2–52 s, where Yosys and OpenSTA take 2.5–37 min.
Levels rank Vivado's near-critical registers at about half the ceiling set
by one Vivado run predicting another. ci/beacon.py score ranks them with a
calibration learned from routed U55C builds instead: gradient-boosted trees
on 38 per-register features, all from Beacon's own outputs (no Vivado input):
- depth: levels, mean levels over the bits, the share of bits within one level of the deepest;
- width: bits, and bits within one level of the deepest;
- end and start kind: D, RAM write data or control, RAM read; register, port, BRAM, IP;
- fan-out: the deepest start's, the cone's (
in_fanout), the largest along the deepest path, nets of 64 or more loads on it; - span: hierarchy depth, crossings, the bits under the lowest common instance of the register and its deepest start;
- the deepest path's op mix (
paths.jsonl, at 8 levels or more): levels spent in LUT, carry, compare, LUTRAM, BRAM and DSP ops, distinct instances and source files, and the levels with a carry level costed at 0.42 of a LUT level and a compare at 0.15.
The model is three tree ensembles: the worst slack (capped at 1 ns, the
ep.csv horizon), the probability of slack under 0.3 ns (near-critical) and
under 0 ns. A register never ranks safer for being deeper (a monotone
constraint on levels). calibrate trains them with scikit-learn and writes
them as plain JSON trees; score evaluates them in pure Python, in about
4 s for a core. The model trained on the 28 builds below ships as
hw/scripts/beacon_calibration_u55c.json;
it applies to the U55C, its slacks at 300 MHz.
ci/beacon.py score build_core/beacon hw/scripts/beacon_calibration_u55c.json \
--top 30 --csv score.csv
ci/beacon.py calibrate cal.json --holdout \
--build build_core/beacon build_core/ep.csv core \
--build build_cache/beacon build_cache/ep.csv cacheEach --build is a DUT build's Beacon run (path-levels=8, as the DUT flow
writes it) and the end point table of the same sources. --holdout prints
the check below for the given builds.
Validation. 13 routed U55C builds at 3.333 ns: 8 core revisions, 4 lmem, 1 cache, 19 k registers. Each build is held out and scored by a model trained on the builds outside its group. Revisions of one RTL lineage share most of their registers, so they are held out together:
- core with the coretiming lineage (origin, it1, it2, lsuagu);
- core with the lmemwarp lineage (v1, v2, final, p2lsulmem);
- cache;
- lmem.
The stricter test holds out the whole DUT (core trained on cache and lmem only).
| held out | near-critical AP: levels | levels + 0.35·log2(fan-out) | carry/compare cost | model, lineage out | model, DUT out | Spearman vs −slack: levels / model |
|---|---|---|---|---|---|---|
| core origin | 0.36 | 0.38 | 0.41 | 0.72 | 0.65 | 0.15 / 0.64 |
| core it1 | 0.40 | 0.42 | 0.42 | 0.75 | 0.65 | 0.18 / 0.63 |
| core it2 | 0.44 | 0.46 | 0.48 | 0.77 | 0.68 | 0.24 / 0.68 |
| core lsuagu | 0.68 | 0.70 | 0.70 | 0.80 | 0.71 | 0.33 / 0.54 |
| core lmemwarp v1 | 0.37 | 0.40 | 0.48 | 0.75 | 0.56 | 0.27 / 0.66 |
| core lmemwarp v2 | 0.44 | 0.50 | 0.54 | 0.82 | 0.61 | 0.35 / 0.73 |
| core lmemwarp | 0.37 | 0.41 | 0.52 | 0.81 | 0.59 | 0.32 / 0.64 |
| core p2lsulmem | 0.55 | 0.63 | 0.60 | 0.87 | 0.65 | 0.40 / 0.78 |
| cache | 0.47 | 0.57 | 0.52 | 0.65 | 0.65 | 0.50 / 0.56 |
| mean | 0.44 | 0.50 | 0.52 | 0.77 | 0.64 | 0.30 / 0.65 |
On the three lmem builds, with 4–5 near-critical registers each, the AP goes from 0.02–0.03 to 0.63–0.68. One Vivado run predicting another of nearly the same RTL (it1, it2) reaches 0.80. AP for failing registers goes from 0.21 to 0.44; that set is mostly placement noise at a WNS near −0.1 ns.
- Width carries most of it. Shuffling the bit counts costs 0.29 of AP. This is partly selection: a wide register shows the worst of many bits. Within registers of one deep bit, though, the AP still goes from 0.47 to 0.79.
- Span, the op mix and fan-out carry the rest (0.03–0.08 each). The op mix matters most on the cache (0.27).
- The DUT-out column is the honest number for a new DUT. The lineage-out column is the one for a new revision of a DUT already trained on.
- It does not track a whole design's slowdown. The mean of the 50 lowest predicted slacks follows the change in WNS over 10 revision pairs worse than the top-50 mean of levels: Spearman 0.15 (lineage out) or 0.42 (DUT out), against 0.53. The lsuagu regression, −1.3 ns, moves it by 0.02 ns.
Retrained on the gates' DUTs. The shipped model adds the routed
fpga_gate builds of 13 DUTs (cache, core, dxa, gfx, lmem, om, raster, rtu,
tcu, tensor, tex, vm, and top as its Vortex core), 11 of them at 3.333 ns
and four at 4.0 ns, to the 13 builds above: 28 builds. Slacks at 4.0 ns are
moved to 3.333 ns (xilinx_ep_dump.tcl's reference period). Each DUT is
held out (all its builds) and scored by a model trained on the rest:
| held out | near-critical AP: levels / model | Spearman vs −slack: levels / model | Fmax: Vivado / model |
|---|---|---|---|
| cache | 0.61 / 0.75 | 0.54 / 0.64 | 297.3 / 277.5 |
| core | 0.33 / 0.68 | 0.33 / 0.66 | 300.6 / 280.1 |
| dxa | 0.56 / 0.80 | 0.41 / 0.52 | 306.0 / 289.3 |
| gfx | 0.68 / 0.79 | 0.42 / 0.58 | 246.5 / 266.2 |
| lmem | 0.07 / 0.32 | 0.25 / 0.35 | 308.0 / 331.3 |
| rtu | 0.37 / 0.33 | 0.35 / 0.42 | 310.6 / 275.6 |
| tcu | 0.55 / 0.65 | −0.01 / 0.10 | 295.2 / 265.5 |
| tensor | 0.69 / 0.90 | 0.40 / 0.66 | 240.6 / 240.1 |
| tex | 0.23 / 0.24 | 0.25 / 0.18 | 298.2 / 282.8 |
| top (Vortex core) | 0.59 / 0.73 | 0.29 / 0.46 | 243.0 / 265.3 |
| vm | 0.78 / 0.88 | 0.47 / 0.61 | 251.6 / 243.5 |
| mean | 0.50 / 0.64 | 0.34 / 0.47 | ±7 % |
(om and raster have no near-critical register.) Before this retrain, the
shipped model already put the registers that failed tensor and top at
250 MHz first: of 2884 and 2574 registers, the tensor socket arbiter's
output buffer ranks first by P(fail), and top's flush-arbiter output buffer
first and second by predicted slack. Both are wide enables driven across an
instance by a same-cycle lookup (an L2 tag compare, a TLB match), which
levels rank in the hundreds.
The design's Fmax, from its slowest predicted register, is within about 7 % of Vivado's held out, misses top's failure, and on the core lineage moves by nothing where Vivado moved by +4.5 % (it1) or −27 % (lsuagu, held out).
So the model is a ranking for where to look first, not a gate. diff and
logic_gate keep gating on levels; logic_gate records the model's Fmax
and the count of registers at P(fail) ≥ 0.5 (p_fmax, risk, not gated)
and writes each build's 40 lowest predicted slacks to beacon_risk.txt.
More builds. The DUT flow writes every routed build's end point table
(ep.csv, at 3.333 ns, through hw/scripts/xilinx_ep_dump.tcl), and
fpga_gate uploads it. A build's Beacon run is regenerated from its commit
(Beacon is deterministic), so each nightly fpga_gate adds a build of every
DUT to train on; calibrate --holdout is the measure of whether the Fmax
has become good enough to gate.
Against the routed fpga_gate builds of the same sources (U55C, Vivado
2024.2.2, 1 November 2026):
Logic LUTs are Vivado's logic LUTs (without distributed RAM and shift
registers) against Beacon's at the fitted scale; before is the estimator
before the rules of §4.5 above, at its earlier scale of 0.337 and IP costs.
top leaves out the command processor (cp_core) on both sides: CIRCT
elaborates it with LLHD signals Beacon does not read.
| DUT | LUT ratio before | LUT (Beacon / Vivado) | FF | distributed RAM LUTs | block RAM | DSP |
|---|---|---|---|---|---|---|
| cache | 1.19 | 27,313 / 28,317 (0.96) | 34,922 / 25,280 (1.38) | 2,542 / 2,722 | 32 / 32 | 0 / 0 |
| core | 0.86 | 122,879 / 165,478 (0.74) | 158,903 / 146,008 (1.09) | 6,838 / 6,220 | 129 / 137 | 97 / 96 |
| dxa | 1.05 | 8,170 / 9,666 (0.85) | 9,215 / 7,132 (1.29) | 568 / 638 | 0 / 0 | 9 / 7 |
| gfx | 1.45 | 241,768 / 210,879 (1.15) | 379,837 / 236,308 (1.61) | 11,906 / 12,834 | 191.5 / 172.5 | 1,140 / 992 |
| lmem | 0.68 | 14,766 / 26,322 (0.56) | 14,361 / 13,623 (1.05) | 726 / 740 | 16 / 16 | 0 / 0 |
| tfu | 2.92 | 1,387 / 1,966 (0.71) | 1,806 / 1,105 (1.63) | 0 / 0 | 1 / 1 | 5 / 3 |
| om | 2.37 | 4,730 / 2,298 (2.06) | 4,456 / 3,496 (1.27) | 367 / 408 | 0 / 0 | 10 / 22 |
| raster | 1.00 | 5,044 / 7,981 (0.63) | 12,069 / 8,974 (1.34) | 496 / 606 | 8 / 8 | 14 / 14 |
| rtu | 2.01 | 99,325 / 63,721 (1.56) | 146,917 / 94,885 (1.55) | 1,904 / 1,840 | 16.5 / 18.5 | 140 / 140 |
| tcu | 1.04 | 121,388 / 115,727 (1.05) | 49,056 / 42,675 (1.15) | 915 / 1,360 | 0 / 0 | 769 / 768 |
| tensor | 1.12 | 220,251 / 225,309 (0.98) | 166,688 / 138,986 (1.20) | 8,962 / 7,842 | 116.5 / 133.5 | 267 / 265 |
| tex | 1.50 | 71,506 / 55,791 (1.28) | 96,949 / 34,582 (2.80) | 3,241 / 4,208 | 0 / 0 | 896 / 528 |
| top | 1.04 | 104,728 / 125,511 (0.83) | 157,573 / 144,522 (1.09) | 8,551 / 7,836 | 76 / 76 | 50 / 48 |
| vm | 1.55 | 109,070 / 116,552 (0.94) | 151,175 / 121,587 (1.24) | 10,276 / 10,366 | 168 / 172 | 0 / 0 |
- LUTs: the geometric mean error over the 14 DUTs goes from 41 % to
31 %, the range from 0.68–2.92 to 0.56–2.06. The L2 of
vmcame to 105,071 LUTs before (311,783 mapped) and comes to 47,555 now (121,625 mapped), against Vivado's 54,150; each bank'sVX_cache_amoto 14,733 before and 3,608 now, against 5,001. The scale is one number per family, so a DUT whose logic Vivado trims or packs more or less than the average moves by that much;logic_gatecompares a DUT with its own baseline, so the scale cancels there. The largest residues are logic Vivado removes across module boundaries, which Beacon, mapping module by module, keeps:rtu's logic outside its 73 floating-point cores is 19,536 LUTs and 18,088 flip-flops in Vivado against 53,970 LUTs (138,032 mapped) and 68,357 flip-flops in Beacon;texkeeps 2.8× Vivado's flip-flops;om'sVX_om_dcrandVX_om_blendcome to 3,407 LUTs against Vivado's 741.lmem,rasterandcorecome out low. - Flip-flops run 5–63 % high, and 2.8× on
tex, for the same reason: Vivado drops the bits a parent never reads or ties to a constant (the cache DUT's stream buffers, 20,936 flip-flops in Beacon against 12,324), and moves pipeline registers into DSPs and block RAM output registers, none of which a module-by-module count sees. - Distributed RAM is within 15 % on 10 of the 13 DUTs that have any
(
raster0.82,tex0.77,tcu0.67). - Block RAM is exact on 5 of the 10 DUTs that have any; the mask-lane
rule matches Vivado on every masked tag store. The RTU scheduler's
window_store(64 × 512 in eight 64-bit lanes) packs in 7.5 blocks, its lanes being whole bytes, where Vivado builds a 36 Kb block per lane, 8.gfxis 19 high: Beacon places four RTU scheduler memories without aram_style(fbuf_ram,ray_store,xfres_ram,trires_ram, 23.5 blocks) in block RAM by its size and latency rule, and Vivado does not;coreandtensorare short by 8 and 17, not yet traced. - DSPs are within two on 11 DUTs;
gfxandtexare 148 and 368 high andom12 low, where Vivado chooses between DSPs and LUTs for narrow products by a heuristic of its own.
The repository's Vivado baselines (ci/baselines/synthesis/xilinx/) date
from 5 October 2026 and predate later RTL changes, so they are not a
reference for this table.
Port depths. port-modules= names modules whose instances' ports
Beacon reports: the levels at which each input arrives, the levels behind
each output, and through, the bits of each output that a combinational
path from outside the instance reaches. A module that registers its
outgoing interface has through 0 on every output; logic_gate gates it
for the modules a build lists under interfaces (BEACON_INTERFACES in
the DUT flow). Small modules are inlined by the mapping, so keep them with
run --keep:
ci/beacon.py run --keep VX_elastic_buffer design.mlir runs/eb \
port-modules=VX_elastic_buffer
ci/beacon.py buffers runs/eb # the OUT_BUF advisor
ci/beacon.py ports runs/eb # every kept module, by unit- The buffer advisor lists the
VX_elastic_buffers that pass a deep ready chain through combinationally (ready_in, upstream, driven at least as deep asready_outarrives from downstream), where a skid buffer (SIZE 2) orOUT_BUFwould cut it, and those whose output is computed rather than registered, whereOUT_REGwould register it. It is evidence for an RTL review: the change also moves cycles, so it comes with the matching SimX timing update. - For foldsim, the ports of the class modules (
VX_socket__lift,VX_core__lift, ...) show the outputs computed from logic, and how deep, rather than registered: in the fold they cost host cycles on the class's links.
Vivado probes.
hw/scripts has three Vivado Tcl probes for questions
Beacon cannot answer, run on a checkpoint
(vivado -mode batch -source <probe> -tclargs <dcp> ...):
| Probe | Answers |
|---|---|
xilinx_cone_dump.tcl |
the worst path into a register, cell by cell, following retimed start registers back |
xilinx_cone_probe.tcl |
whether paths exist between two register sets, and how deep Vivado built them |
xilinx_wire_probe.tcl |
per path: length in tiles, bounding box and fanout beside logic and net delay |
- Depth, not slack. On the placed 3.333 ns socket gate, wires are 83 %
of the worst paths' delay; levels explain 1 % of net delay, and the real
placement two thirds. No pre-placement wire term ranked slack better than
levels on every held-out gate, so Beacon has none. Route-dominated
failures with few levels are invisible to it: recall at ≥ 12 levels is
0.13–0.57. The learned calibration (§7.1) ranks near-critical registers
better from width, span and fan-out (held out: AP 0.64 against 0.50 over
11 DUTs), and
logic_gatereports it, but its Fmax is within about 7 % of Vivado's, so it is advisory. - Retiming and packing. Vivado retimes and packs across what the RTL separates: a popcount, its adders and a compare become a LUT6 tree with a retimed register inside. Beacon's depths are RTL stage depths, about 1.25× Vivado's.
- The fold. In foldsim's folded designs, the fold turns some registers into LUTRAM and cuts some chains, so its paths differ from the RTL's. The native gates are the reference for native RTL.
- Black boxes. Vendor IPs and
black-boxes=modules end and start paths at their pins: their insides are not timed. Vendor IP's area is its measured cost per instance; ablack-boxes=module's is left out. - Area is a count, not a utilization report. The mapping is a cut mapper's cover scaled to Vivado's average (§4.5, §7.2), memories go by Vivado's inference rules, and what Vivado packs into DSP, block RAM and SRL cells Beacon counts as fabric. Logic that nothing observable reads is counted; Vivado removes it.
- Devices. Every Xilinx family of §4.2 (the gate runs the U55C's, and the
learned calibration exists for it only), and ASAP7 RVT TT (the Yosys
flow). The ASAP7 numbers are Beacon's period estimate, a sizing guide,
not a sign-off: 0.59–1.05 × OpenSTA's Fmax on the 14
asic_gateDUTs. Two known gaps: the 32 × 32 multiplier fed from dispatch reads 28–29 stages (~900 ps) where OpenSTA has 1318 ps, since the partial-product generator and the operand fan-out are not priced; and vm's L2 TLBset_mruupdate reads 46 stages where STA closes it under 800 ps. - Harnesses. A constant on an instance input does not reach the logic
behind it (each module is mapped once), so Beacon measures a unit whole
where Vivado and Yosys fold what a harness ties off. The
tiescount makes such a harness visible; it does not model the folding. - Toolchain. The catalog maps only with three CIRCT Synth fixes (zero-width mux, constant SOP cut, a failing longest-path query), which reach CI through the foldsim prebuilt.