Skip to content

Latest commit

 

History

History
262 lines (245 loc) · 56 KB

CHANGELOG.md

File metadata and controls

262 lines (245 loc) · 56 KB

Changelog

All notable changes to Vortex are documented here. The format is based on Keep a Changelog, and the project follows the version pins recorded in VERSION (VORTEX_VERSION, TOOLCHAIN_REV, GEM5_REV).

[Unreleased]

Added

  • Branch naming types. Branches are named <type>/<name> with one of six types (feature/, fix/, perf/, refactor/, ci/, docs/), plus the maintainers' release/ and archive/. See CONTRIBUTING.md.
  • Hardware profiles. profiles/<name>.json names a machine (tinygpu, gtx1080, v100, a100, h100, rtx5080) that every flow builds through configure --profile=<name> or blackbox.sh --profile=<name>; explicit CONFIGS win over the profile. The GPU profiles are 64-bit machines with VM, atomics, TFU, shared memory and the tensor, DXA, ray-tracing and graphics units of the real part; a profile's xlen sets configure's XLEN, and a build tree of the other width rejects it. See docs/simulation.md.
  • RHEL 9 toolchain (rhel/9). EL9 hosts (RHEL, Rocky, AlmaLinux, CentOS Stream 9) get native prebuilt bundles: LLVM 20.1.8, Verilator 5.050, Yosys 0.69 and OpenSTA rebuilt against glibc 2.34 / GCC 11 libstdc++, plus the focal riscv-gnu, POCL, chipStar and Mesa bundles, which already ran there. Before this, EL9 mapped to centos/7, which has no LLVM, POCL, chipStar, Mesa, Yosys or OpenSTA bundle and whose GCC 13 riscv toolchain no longer links the kernel library. gem5 is not provided for rhel/9. See docs/install_vortex.md.
  • Per-partition fetch (VX_CFG_FETCH_WIDTH, default 1). The front end splits into FETCH_WIDTH slices, each with its own warp scheduler, fetch, decode and icache port, serving the warps with wid % FETCH_WIDTH == f; CTA dispatch, barriers and warp control stay core-wide. The core takes one of three structures from the fetch width, issue width and per-unit block counts; with one block of every unit per issue slice and FETCH_WIDTH equal to ISSUE_WIDTH, each slice is a self-contained compute slice (the NVIDIA processing-block organization). Why: sgemm at 16 warps x 16 threads, ISSUE_WIDTH 4: -31.6% cycles at FETCH_WIDTH 2.
  • Hashed cache bank select (VX_CFG_{DCACHE,L2}_BANK_HASH). The bank index is the raw bank bits XORed with a hash of the line address above them (IPOLY(5) for 16 banks, IPOLY(37) for 32, an XOR fold otherwise), so power-of-two strides spread over the banks. On by default for the L2 and for a dcache with 4 or more banks. Why: rtlsim sgemv 512x512 at 16 threads -32.8%, fp16 TCU SGEMM on 2 cores + L2 at 16 threads -13.8%, WGMMA with DXA -13.5%.
  • Dcache read merge (VX_CFG_DCACHE_READ_MERGE, on by default). Plain reads of the same word from the ports of one LSU block in the same cycle are served by one bank access, and the response is multicast to every port; each port's order into the bank is unchanged. Why: uniform loads (kernel arguments, SGEMM's shared operand) no longer serialize on one bank: rtlsim sgemm -n128 at 16 threads -6.5%, -17.2% with an 8-byte dcache word.
  • Write-allocate without fetch (VX_CFG_{DCACHE,L2,L3}_LAZY_FETCH, on where the cache is a write-back LLC). A store miss in a write-back cache installs the sector with its dirty-byte mask and a partial bit instead of fetching the line; a later load or AMO merges memory data under the unwritten bytes, and evictions write back only dirty bytes. Why: streaming writes no longer read every line first: 1-core vecadd DRAM reads -33%.
  • Command-processor DMA through the shared LLC (VX_CFG_CP_LLC_CLIENT, on by default). When one LLC serves every core, the CP's transfers enter it on their own client slot, so host transfers need only an L1 flush, not a walk of the whole LLC; transfers of at least half the LLC write around it. A launch behind DMA writes waits for a device-scope flush token sent on the slot. The runtime sees the new DMA_LLC_CLIENT CP capability. Why: rtlsim at 2 clusters + L2 + L3: dogfood -30%, multikernel -42.7%; dogfood -64% with an 8 MB L3.
  • Foldsim: threaded FPGA simulation of Vortex on the Alveo V80, built on CIRCT. Every class of identical units (sockets, issue slices, ALUs, FPUs, load-store units) is time-multiplexed through one physical copy, cycle-exact against the RTL, with no Yosys or sv2v: circt-verilog imports Vortex, Foldsim's foldsim-extract-models / foldsim-compose cut it into threaded models joined by one token fabric (Foldsim is its own project on CIRCT, installed by ci/toolchain_install.sh --foldsim; hw/syn/foldsim/), and the V80's native flow packages it with a latency-bandwidth memory endpoint and a command-queue control block (hw/rtl/afu/foldsim/). --driver=foldsim runs it on the card (TARGET=hw, VRT + QDMA) or in-process in Verilator (avedsim, the default). Vortex's RTL is unchanged: units get plain-port boundaries and instance IDs as ports from a source-to-source pass on the flow's copy (hw/syn/foldsim/lift_boundaries.py). See docs/designs/foldsim.md. Why: the simulated GPU is no longer bounded by the card's size, and the shell around it is ~8k LUTs instead of FireSim's ~93k — s2w4i2 (2 cores, NW=NT=4, IW=2) routes in 138k LUTs vs 219k and runs sgemm n=128 in 196 ms on V80: 50× SimX on the same host, 1.7× the FireSim image, cycle counts identical to Verilator. Limits: V80 only; one memory port, single-beat transactions; classes are named (FOLDSIM_CLASSES), not found; kernel register offsets 0x40–0xBF are unusable on the V80 shell (its PCIe MSI-X table answers them).
  • Hashed dcache set index (VX_CFG_DCACHE_SET_HASH, on by default). The set index is the raw set bits XORed with an XOR fold of the tag's low 32 bits, so power-of-two strides walk the sets instead of piling into a few; the tag is stored unchanged, so the same XOR restores the raw set. The L2 and L3 have no set hash: no measured case gains from one. Why: rtlsim sgemv 512x512 -20.1% at 4 threads and -23.9% at 16 (read hit rate 29% -> 85%), mxfp8 tensor -4.8%; perf_gate geomean -1.1%. Two TCU tile layouts pay +1.1% and +1.8%.
  • Logic-depth gate in CI (logic_gate). Beacon maps every DUT of the catalog through CIRCT and foldsim and asserts each RTL unit's deepest path and the design's area against golden baselines in ci/baselines/synthesis/beacon/, in minutes and without synthesis. It runs in ci.yml together with perf_gate (every pull request, every push that touches the RTL or the config); .github/workflows/logic_gate.yml is the manual entry point and runs the full-GPU builds. Why: a perf regression costs cycles, a logic regression costs Fmax; both are now named on the change that causes them, not by the nightly FPGA gate.

Changed

  • Toolchain pinned to v3.0.2 (TOOLCHAIN_REV): LLVM f44a6bb2af4c, with PoCL rebuilt on it. Wide loads/stores and 64-bit atomics stay behind +xvortexldstwide and +xvortexamod, so code built with plain +xvortex uses no new instructions.

  • Dcache read-merge pairs realign. A pair of same-word merge ports whose parts a bank served a cycle apart waits for its partner, so the pair's later uniform reads merge again; a pair that waited on each other is released. Groups of 4 ports do not realign. Why: the drift was lost on every following uniform load: vecadd on 4 LSU blocks -11.3% in rtlsim, and its SimX/RTL gap over 7 sizes falls from 3.9% (-0.9% to 7.2%) to 1.8%.

  • Small CI suites share a cell. A test category can be a directory of files, each with its own defaults, that runs as one cell per driver and XLEN: isa (tfu, zfhmin, rvc, riscv, amo), sw (opencl, hip, kernel, runtime), integration (gem5, sst, dtm, cupbop, mpi) and tensor_sp (sparse, and sparse with MX). Every case keeps its command, configs, drivers and tier; each file stays selectable by its own name (-m tfu). Why: each of these suites ran in 2-6 minutes, most of it the cell's setup; a pull request now plans 82 cells instead of 108, a push 35 instead of 49.

  • Foldsim's shell lives in the Foldsim repository. The control and memory endpoints, the DRAM bank timing model, the register map, the in-process host, the endpoint's unit tests and the boundary lifting (foldsim-lift) moved out of hw/rtl/afu/foldsim, sim/foldsim, sw/common, hw/unittest/foldsim_mem* and hw/syn/foldsim; they come with the Foldsim installation (FOLDSIM_SHELL, $(FOLDSIM_PATH)/share/foldsim/shell). Vortex keeps the target wrapper, the image flow, the runtime driver and the parity case. Why: Foldsim is a general-purpose RTL simulator; nothing in the shell is specific to Vortex.

  • RV64 portability. Device index math, DXA/OM addresses, pack-load strides, RTU scene/payload pointers and the ray log carry full width on RV64 (size_t/uintptr_t, identical RV32 code); RTU slot reads into FP registers are NaN-boxed.

  • Zero warnings restored. Every C/C++ build (simulators, runtime, kernel library, tests, OpenCL/HIP/Vulkan apps) is -Werror and Verilator warnings are fatal again, with the RTL and host code fixed to build clean.

  • DRAM model redesign. simx, rtlsim, opaesim and xrtsim model one independent Ramulator controller and device per memory bank (JEDEC HBM2/HBM3/GDDR6 organization and nanosecond timing, 32 B bursts, permuted open-page bank interleave, per-channel responses), configured from data-sheet values: VX_CFG_PLATFORM_MEMORY_{TYPE,DATA_RATE,LATENCY,QUEUE_SIZE}. The default machine keeps its idle read latency (14/26 cycles open-row/conflict, was 13/27) and one-block-per-cycle peak.

  • Cache flush architecture. The CP starts every core's flush with one broadcast CACHE_FLUSH DCR write, then reads each core's completion, so the flushes overlap; a flush read without a preceding write no longer starts one. A cache walks its banks, sends one flush token down every memory port and answers once all ports have; every independently buffered write path (each dcache lane, each OM input of the ocache) carries its own token. Read-only caches (icache, tcache, rtcache, rcache) no longer forward flushes. DBG_FLUSH_STALL adds random input backpressure to the flush path for stress tests.

  • Device-scope flush between launches. When a single LLC serves every memory client it is the point of coherence, so a launch boundary cleans only the levels above it. One typed fence operation (VX_FENCE_ACQ/REL/SYS/IO in VX_types.toml) carries the cache work from the CMD_CACHE_FLUSH header through the CACHE_FLUSH DCR write to every flush token, and a shared LLC answers a device-scope (ACQ|REL) token without a walk. Replicated LLCs and LLCs with peer clients (TEX, RTU, RASTER, OM, DXA) still walk. The runtime posts flushes lazily and flushes fully before any device-memory transfer, and device busy stays high until every core write, uncached IO stores included, is visible in memory. Why: per-launch flush cost at 4 cores + L2 drops from 2,750 to 180 cycles.

  • Targeted fences. A memory fence sends its fence operation (acquire, release or both) in a flush token that the shared LLC answers without a walk. A fence that orders only device (I/O) accesses sends an IO token, which makes each level drain to its memory ports without walking. Why: printf, which fences after each device write, runs 13.6x faster on rtlsim at 2 cores + L2.

  • LMEM DMA arbitration. DXA writes into shared memory and the TCU's WGMMA operand reads now share the local-memory DMA port round-robin. DXA had fixed priority and starved the TCU for about 510 cycles per tiled-scatter transfer. Why: rtlsim WGMMA with DXA -10.2%, sparse WGMMA with DXA -11.6%.

  • SimX timing model follows the RTL's structure. Buffer capacities and registered ready at every pipeline boundary, per-slice cache arbiter trees and network depths, registered cache core-response ports, flush and fence tokens end to end, and CTA launch onto the nearest ready core with two launch credits per core. SimX's per-core cycle counter (mcycle) now advances only while the core has work, as the RTL's does. rtlsim completes DRAM requests in per-bank arrival order, as the AXI platform does.

Fixed

  • ASIC core and top at 800 MHz. On ASAP7 the core reached 655 MHz and top 654 MHz against the 800 MHz catalog clock, held by three datapaths: the FDIV/FSQRT result stage, the FMA's accumulate and rounding stages, and the integer multiplier. Each is retimed with no change in latency, so SimX and every cycle count are unchanged. FDIV/FSQRT decides the subnormal shift and tests overflow for both rounding carries one stage early. The FMA subtracts in both orders, with the borrow as the carry-in, in parallel with the magnitude compare, and its NORM stage precomputes the subnormal shift for both candidate exponents. The multiplier registers its operands in the first of its LATENCY_IMUL stages instead of the last, where the target has no pipelined multiplier blocks (IMUL_IN_REG in VX_platform.vh); on FPGAs the DSP blocks pipeline the product themselves, and the operand register cost the U55C core 3.6 MHz. The core now reaches 1020 MHz and top 1029 MHz, with cell area +0.1%.
  • FPU clock enable on the U55C core. Each FPU core's skid register drove one clock-enable net to every unit of the core, and the FPGA core build reached 286 MHz against 300. VX_pe_serializer now computes the enable a cycle ahead and registers one copy per unit (PE_ENABLES), so each unit's enable starts at its own flop; the core reaches 296.6 MHz with no cycle change.
  • ASIC cache area. The 2-stage cache bank kept its dirty-byte mask in an asynchronously read RAM, which the ASIC flow builds from flops, and the cache was 16% over its area budget. Every bank now reads the mask one stage ahead from block RAM, and the lazy-fetch loopback reads a per-sector "every byte dirty" bit kept beside it instead of reducing a sector of the mask.
  • Exact square roots on the FLEN-64 divide/sqrt unit. VX_fdivsqrt_unit took the sign of the final square-root remainder from bit 58, but at FLEN 64 the remainder needs the full 60-bit carry-save width: an exact square left −2^58 − 2, read as positive, so the final correction was skipped. Exact squares of an unscaled radicand (sqrt(1.0), sqrt(4.0), sqrt(100), F32 or F64) then raised NX and rounded up one ULP under RUP. The unit test now covers F64 operands and exact squares, and run-fpu also runs the FLEN-64 unit. New ISA lanes (isa-32f-std, isa-64f-std, isa-64d-std) run the F and D suites on VX_fpu_std, the FPU the ASIC flow builds; the existing RTL-FPU lanes use VX_fpu_dsp, which never reaches this unit.
  • Stale softfloat archive. third_party/Makefile rebuilds softfloat when SOFTFLOAT_OPTS changes. Before this, a tree built before -DTHREAD_LOCAL=_Thread_local was added kept its non-TLS archive, and the simx runtime failed to link with TLS reference ... mismatches non-TLS definition for softfloat_exceptionFlags.
  • fcvt NaN boxing on RV64. The half-precision operand check covered the register up to XLEN instead of FLEN, so an RV64 build without the D extension read a boxed half as a NaN.
  • TCU_LD response assertion. With the LSU narrower than the warp, a TCU_LD goes out in passes and an earlier pass's response can return while a later pass's request is held; the assertion fired on that correct order. It now expects a response from the first request on.
  • ASAP7 download in CI. A transient HTTP 504 from GitHub on the Liberty files failed the whole synthesis cell. The synthesis cells now cache the checksummed downloads, keyed on the manifest, and the installer retries six times, 20 s apart.
  • TCU B-buffer descriptor race. The B buffer re-latched its descriptor on every first uop, even while a fetch was in flight, so a back-to-back WGMMA could fetch with the next instruction's row base. It now latches at fetch allocation.
  • Pipe buffer combinational loop at -O0. VX_pipe_buffer kept its input in the same vector as its stage registers, which an unoptimized Verilator build reads as a loop through any outer path (the debug CI cells).
  • Global barriers across clusters. Each cluster ran its own global-barrier unit that saw only its own cores, while vx_num_cores(), and so vortex::gbarrier, counts the whole device. On SimX every global barrier hung with more than one cluster; on the RTL, 2 clusters x 1 core timed out and 2 clusters x 2 cores released each cluster on its own arrivals, with no ordering between clusters. One device-level unit now counts every core.
  • Writes left dirty by a flush. A cache forwarded its flush token on memory port 0 only, so writes queued on another port could reach the next level after that level's walk and stay dirty there.
  • Dirty sectors dropped on a sector refill. With dirty-byte tracking and several sectors per line, installing a sector into a resident line cleared the whole line's byte mask, so a dirty sibling sector wrote back with no bytes enabled and its data was lost (mstress at 4 cores with a write-back, sectored L2).
  • Local-memory LR/SC livelock at 16 threads. One warp's per-lane LR burst used up a reservation's fixed hold budget of 7 refusals, so contended LR/SC loops on shared memory stopped making progress. The budget now scales with the core's harts.
  • VX_stream_arb trees with a partial last slice. When the request count was not a whole number of slices, the last slice's select was sized and placed as if it were full: the build failed lint, and with several outputs requests went to the wrong output.
  • -DSCOPE builds. The scope buses of fetch, issue, LSU, TCU, TEX, RASTER and OM were declared only under their DBG_SCOPE_* taps, left unbound, or did not parse, so debug-scope builds failed to elaborate.
  • mstress checked no data. Its host reference was always 0, so the test passed with corrupted loads; it now checks every loaded value exactly.
  • RTL that only lenient front ends accepted. slang, now the Yosys front end, rejects what Vivado, Verilator and CIRCT let through: wires used before their declaration (VX_socket, VX_decompressor, VX_cp_dma, VX_tcu_core), a localparam used in a port width before its declaration (VX_cp_unpack), an interface member expanded through SEXT (VX_alu_int), a negative-width cast (VX_uuid_gen, checked uninstantiated when UUID_WIDTH is 1) and $bits of an interface member as a cast width (VX_rtu_core). Each is rewritten with no logic change; Beacon reports identical register depths on core, tcu, rtu and top.
  • FPGA run instructions. The docs exported TARGET=hw, which blackbox.sh ignores, so runs fell back to xrtsim; they now pass --target=hw.
  • Block RAM for asynchronous-read RAMs is a source patch, not a Vivado netlist patch. gen_sources.sh -F runs the RAM fold (hw/scripts/ram_fold.py, pyslang): it elaborates the design only to decide which block-RAM-sized VX_dp_ram reads combinationally from registered addresses, then patches the preprocessed sources so that the RAM reads the next address. Every synthesis tool (Vivado, Quartus, Design Compiler, Yosys with its slang frontend, FireSim's image) reads those folded sources, never an elaborated netlist. ASYNC_BRAM_PATCH, VX_async_ram_patch, VX_placeholder, xilinx_async_bram_patch.tcl and its pre-opt hooks are gone. Why: the patch rewired Vivado's synthesized netlist in Tcl, ran in Vivado flows only, failed late on large builds (DRC INBB-3), and produced a netlist nothing simulated. A CIRCT-elaborated netlist in its place cost Fmax (core 295 → 286 MHz, cache 300 → 276, TCU 291.5 → 276) and did not build top.
  • CIRCT preprocesses the synthesis sources and Yosys reads them with its slang frontend; sv2v and Verilator's preprocessor are gone. gen_sources.sh -P preprocesses with circt-verilog -E (identical code to verilator -E over the whole RTL tree; only comments differ). The Yosys flow reads the preprocessed, RAM-folded sources with Yosys's built-in read_slang (Yosys 0.67 or later), the SRAM macros (BB_MODULES) black-boxed with --blackboxed-module, and strips their parameter overrides from the mapped netlist, which OpenSTA's Verilog reader rejects; the SRAM estimate reads port widths from the JSON netlist, written before the strip. CIRCT installs under $TOOLDIR/circt (toolchain_install.sh --circt; hw/syn/common.mk exports CIRCT_VERILOG, CIRCT_OPT, FIRTOOL) and elaborates the design only for Beacon and Foldsim. Verilator remains the simulator (and --xml-only scope metadata).

[3.0] — 2026-10-07

The 3.0 release introduces a fixed-function graphics stack (rasterizer, texture units, and output mergers), tensor core structured sparsity (2:4), warpgroup-level matrix multiplication (WGMMA), global-to-local data transfer acceleration (DXA), a new hardware kernel scheduler (KMU) and Command Processor (CP) architecture, a new asynchronous runtime API (vortex2.h), asynchronous barriers with arrive/wait/event semantics, compressed instruction set (RVC) support, hardware atomics, an MMU/SV32 virtual memory stack, a Mesa/lavapipe Vulkan backend (vortexpipe), HIP via chipStar, gem5 integration, a SimX v3 TLM architecture with fixed-size handshake channels, productized Synopsys and Yosys ASIC synthesis flows, and a refreshed toolchain (LLVM 20, POCL 7.0). Build and configuration infrastructure was reworked: TOML-driven HW configuration (VX_config.toml + VX_types.toml) decoupling SimX/runtime from the RTL source tree, a VX_CFG_ macro namespace that resolves toolchain preprocessor collisions, retirement of the global toolchain_env.sh to enable parallel multi-version Vortex worktrees on the same shell, consolidation of kernel//runtime/ under a shared sw/ root, a single-source VERSION file driving CI toolchain pinning, Perfetto trace export (ci/perfetto.py), and new top-level AGENTS.md + CONTRIBUTING.md for AI-agent and contributor workflows.

Added

  • FireSim FPGA-accelerated simulation (Alveo U55C). Vortex runs as a host-decoupled FireSim target — Chisel BlackBox + FASED memory timing model (hw/syn/firesim/src/main/scala/VortexTarget.scala), AFU wrapper (hw/rtl/afu/firesim/VX_firesim_wrap.sv), transport (sim/firesim/firesim_sim.cpp) and runtime HAL (sw/runtime/firesim/vortex.cpp) — selected by --driver=firesim, built from vortexgpgpu/firesim vortex_3.x consumed as $(FIRESIM_PATH) and packaged by ci/toolchain_{install,prebuilt}.sh --firesim; the image is $(FPGA_BIN_DIR)/firesim.xclbin, and XCLBIN_PATH now names the image for both the xrt and firesim drivers, replacing XRT_XCLBIN_PATH. Why: every target clock edge is scheduled by the host and target DRAM is served by a timing model, so cycle counts are reproducible run to run and the modelled memory system can be varied independently of the card — sgemm -n1024 (1.19 B instructions) runs in ~85 s with instruction counts matching rtlsim exactly, at 10.09 % LUT / 5.41 % BRAM / 0.27 % DSP and WNS +5.283 ns. Limits: U55C only — the host-memory base address, the HBM[0:7] binding and the single memory bank are fixed to that card, and on any other platform the target DRAM path fails silently. See docs/designs/firesim_integration.md.
  • AMD Alveo V80 support (aved backend). New AFU, runtime, Verilator model and synthesis flow targeting the V80 through the SLASH platform (VRT runtime, slashkit linker, IP-XACT packaging) — the board is not an XDMA shell, so XRT does not apply. TARGET=hw|sim|avedsim selects what executes the RTL; avedsim is the iteration loop and matches the xrt backend cycle-for-cycle.
  • Host-resident Command Processor ring on V80. The CP pulls commands from coherent host memory over the QDMA slave bridge, as mainstream GPU command processors do, backed by a new host-buffer allocator spanning the SLASH kernel module, libslash, vrtd and VRT.
  • TCU tfr arithmetic backend. New in-house, fully-synthesizable fused dot-product running integer and floating-point through one shared 4-cycle pipeline; gated by VX_CFG_TCU_TYPE_TFR. ** Adds FP8 (e4m3), BF8 (e5m2), and TF32 on top of the v2.x set (fp32 / fp16 / bf16 / i32 / i8 / u8 / i4 / u4). Each is gated by its own VX_CFG_TCU_{FP8,BF16,TF32}_ENABLE; format dispatch is unified across all four FEDP backends.
  • Tensor-core structured sparsity (2:4). VX_tcu_sp_mux + VX_tcu_sp_meta datapath plus host compress_2to4_matrix / prune_2to4_matrix helpers; gated by VX_CFG_TCU_SPARSE_ENABLE.
  • Warpgroup-level MMA (WGMMA). Per-warp NRA=4 / variable-NRC fragment layout, S/R source modes, smem descriptor path; gated by VX_CFG_TCU_WGMMA_ENABLE.
  • Data-transfer Acceleration (DXA). Async global→local DMA engine for tile staging (hw/rtl/dxa/ + sim/simx/dxa/).
  • Hardware Kernel Management Unit (KMU). New scheduler block (hw/rtl/VX_kmu.sv + sim/simx/kmu/) that owns CTA dispatch from the CP launch path.
  • Launch-level CTA clustering. vx_launch_info_t::cluster_dim[3] (sw/runtime/include/vortex2.h:202) guarantees every K-CTA group is co-resident on one core; KMU iterates intra-cluster offsets first (sim/simx/kmu/kmu.cpp:63) and the CTA dispatcher reserves K contiguous LMEM slots so DXA Path A multicast can target issuer + r*stride.
  • Command Processor (CP) v3. New hw/rtl/cp/ block + host-resident command ring (CMD_LAUNCH, CMD_MEM_*, CMD_DCR_*, CMD_CACHE_FLUSH, CMD_EVENT_*); integrated end-to-end across xrt, opae, simx, rtlsim behind VORTEX_USE_CP.
  • Asynchronous vortex2.h runtime API. Queues, events, modules, kernels, UVA raw-pointer kernel args, per-queue worker thread; legacy vortex.h retained as a thin wrapper.
  • C++ software CP model (sim/common/cmd_processor.cpp) shared by simx and rtlsim.
  • Graphics stack (RASTER / TEX / OM / RTU). Fixed-function 3D pipeline: hw/rtl/{raster,tex,om,rtu}/ + VX_graphics.sv + matching SimX models; --graphics regression group.
  • Public host-side graphics API. sw/runtime/include/graphics.h exposes vortex::graphics::Binning() (triangle setup + tile binning producing the on-wire rast_prim_t stream the RASTER unit reads) plus self-contained vertex_t / primitive_t input types and DCR address helpers for external Vulkan/HIP/OpenGL drivers.
  • Canonical on-wire graphics ABI in sw/kernel/include/vx_graphics.h. Templated POD vortex::graphics::fixed_t<F> (Q15.16 / Q?.24 with full arithmetic, all members public + trivially copyable) plus the on-wire structs (vec3e_t, rast_prim_t, rast_attribs_t, rast_tile_header_t, etc.) and 8888 pixel helpers.
  • Vortex SDK install layout. make install produces $VORTEX_PATH/{kernel,runtime}/{include,lib<XLEN>} plus lib/pkgconfig/vortex-{runtime,kernel}.pc (auto-generated from sw/runtime/vortex-runtime.pc.in and sw/runtime/vortex-kernel.pc.in at configure time). Default prefix is <build>/install. Why: gives downstream tools (mesa-vortex, pocl-vortex, chipStar) a single $VORTEX_PATH env var + pkg-config integration shape.
  • Vulkan support via a new Mesa Gallium driver vortexpipe selected through the lavapipe ICD; tests/vulkan/ suite (compute, draw3d, depth, textured, raytrace); Mesa shipped via the prebuilt toolchain; rv64 path enabled.
  • HIP support on rv32 + rv64 via chipStar. chipStar's hipcc now accepts --offload-pointer-width={32,64} and emits SPIR-V with the matching OpMemoryModel Physical{32,64}; a single libCHIP.so ships both widths' rtdevlib modules and selects at runtime via CL_DEVICE_ADDRESS_BITS. POCL on rv32 Vortex accepts the resulting Physical32 SPIR-V cleanly. See docs/designs/hip_on_vortex_chipstar.md.
  • OpenCL image support on PoCL-Vortex. clCreateImage, read_image{f,i,ui} / write_image{f,i,ui}, get_image_*, and samplers on the Vortex PoCL device (CL_DEVICE_IMAGE_SUPPORT). Sampling is classified per read into two tiers: a fixed-function TEX fast path (Tier A) that routes an FF-representable read_imagef (2D, power-of-two, 8-bit UNORM RGBA/BGRA, nearest/bilinear, clamp/repeat/mirror) through the existing vx_tex4 hardware sampler on a host-bound TEX stage — zero new silicon, ~46 % fewer instructions for nearest and ~4.7× for bilinear — and a permanent scalar software sampler (Tier C) for every other format/mode, chosen by a gated fallback (never a silent wrong result). The TEX-stage binds and the kernel launch are submitted as one CP command batch (vx_enqueue_commands, a single doorbell), the compute-path analog of CMD_DRAW. Image builtins are Vortex-specific scalar (the no-vector backend cannot select the generic vector image builtins). Tier equivalence (hardware vs software across both TEX stages, the software fallback, and every wrap/filter mode) is asserted by tests/opencl/image_hwsw; see also tests/opencl/image_{ff,ff_linear,ff_bgra,copy,linear,int,get}. Why: completes the OpenCL 1.2 feature set and moves the compute path onto the FF-reuse + CP-batch posture the graphics stack already holds. The image builtins + driver live in the PoCL-Vortex tree (vortex_3.x); the runtime ships in the prebuilt toolchain.
  • Fix: FF TEX clamp-to-edge for negative coordinates. hw/rtl/tex/VX_tex_sat.sv mis-saturated a negative texture coordinate to the high edge (its sign-extension bits falsely tripped the overflow path); the overflow term is now sign-gated, so negatives clamp to texel 0, matching the SimX TextureWrap model. Surfaced by OpenCL read_imagef with clamp + out-of-range coordinates (ordinary texture mapping stays in range, so the graphics TEX tests are unaffected).
  • Hardware atomics. RISC-V A-extension (LR/SC reservation table + cache-resident AMO* RMW), gated by VX_CFG_EXT_A_ENABLE. AMOs complete at the LLC while non-LLC banks invalidate the line on passthrough, so atomics are correct across the full L1/L2/L3 cache hierarchy.
  • In-house IEEE-754 FPU (VX_fpu_std), now F32 and F64. Fully RV-compliant scalar FPU built from Vortex-owned blocks, covering both single (F) and double (D) precision natively — VX_fma_unit (separate F32/F64 fused multiply-add cores), merged-format VX_fdivsqrt_unit (radix-2 non-restoring FDIV + FSQRT; one carry-save datapath sized for the widest format — 17-cycle F32-only, 32-cycle when D is enabled), merged-format VX_fcvt_unit (I2F/F2I/F2F incl. FCVT.S.D subnormal/overflow), and merged VX_fncp_unit (sign-inject/min-max/compare/class/move with F32 NaN-box checking) — selected via VX_CFG_FPU_TYPE_STD. Validated against the full rv64u[fd]-p riscv-tests ISA suite on the RTL FPU. Why: removes the FPNEW dependency entirely — FPNEW is no longer required for D support on any flow (ASIC/Yosys/Synopsys and FPGA), only optionally selectable; the native units deliver higher fmax, lower latency, and smaller area, and the in-tree source unblocks block-level tuning that vendoring made impractical.
  • RISC-V Zicond (conditional ops). CZERO.EQZ / CZERO.NEZ integrated end-to-end (decode in VX_decode.sv, ALU in VX_alu_int.sv); gated by VX_CFG_EXT_ZICOND_ENABLE. Adds an ISA-level branchless-select primitive used by LLVM 20's codegen.
  • Pack-load intrinsics (vx_packlb_f / vx_packlh_f). Single-instruction strided loads that fold 4×byte (PACKLB) or 2×halfword (PACKLH) loads into one front-end issue, expanded by VX_uop_packld into N back-to-back LSU uops with eff_rs1 = rs1 + rs2 × uop_idx. Used heavily by sw/kernel/include/vx_tensor.h for TCU tile-row packing.
  • Wallace-tree + folded-radix multipliers (VX_wallace_mul, VX_fold_mul). New hw/rtl/libs/ multiplier blocks. Why: used by VX_fma_unit (mantissa multiply) and the TFR TCU backend (per-format integer / fp multiply); shared structural multiplier lets both blocks pick the area/latency trade-off via a single point of change.
  • Kogge-Stone parallel-prefix adder (VX_ks_adder). Logarithmic-depth carry-propagate adder under hw/rtl/libs/. Why: drives the long carry chains in VX_fma_unit (exponent/mantissa alignment + final add) and the TFR TCU's FEDP final accumulator without the ripple-carry timing penalty Verilator's default + emits.
  • Stream split/join primitives (VX_stream_dispatch, VX_stream_fork, VX_stream_join). New hw/rtl/libs/ modules consumed by VX_dcr_arb, VX_dxa_dispatch, and VX_gbar_arb. Why: replaces ad-hoc 1→N and N→1 ready/valid plumbing duplicated across the DCR, DXA, and global-barrier paths with one tested, parameterizable primitive; cuts ~3 copies of the same handshake state machine.
  • Inference-based integrated clock gating (VX_clockgate). Synthesizable ICG cell at hw/rtl/libs/VX_clockgate.sv; instantiated for per-core gating in VX_socket.sv:407. Why: gives the synthesis tools a single recognizable ICG inference pattern so ASIC flows (Synopsys/Yosys) generate proper latch-based gates instead of glitching AND-based gating; per-core gating is the first power-domain leverage point.
  • Cache fill-forwarding (FILL_FORWARD). The read-prefix of a fill's MSHR pending chain completes directly from the staged fill sector instead of replaying through the bank pipeline (hw/rtl/cache/VX_cache_bank.sv, SimX mirror in sim/simx/mem/cache.cpp); the first write/AMO entry falls back to the replay path so coalesced same-line accesses keep program order. Why: standard GPU L1 practice (fill-buffer forwarding) — pending misses stop paying the replay round-trip and the input arbiter stays open to demand requests while a chain drains (sgemm −2.7%, sgemv −5.0%, sgemm-mc −2.2% cycles); also hardens the tag-store read-first bypass and MSHR chain linking against the request-after-fill races the old replay serialization masked.
  • Compressed instruction set (RVC). New VX_decompressor block in the fetch stage (hw/rtl/core/VX_decompressor.sv + sim/simx/decompressor.cpp); gated by VX_CFG_EXT_C_ENABLE. v2.x shipped the test binaries but had no decompressor.
  • Asynchronous barriers with arrive / wait / expect_tx semantics. VX_bar_unit + vortex::barrier host API; expect_tx is the hook DXA multicast uses to declare expected bytes.
  • MMU / virtual memory (SV32, rv32-only). Host-shadow page table + DeviceMemIO refactor + --vm regression group.
  • GEM5 integration. VortexGPGPU SimObject + x86/aarch64 host runtimes; ci/regression.sh --gem5 + VORTEX_GEM5_ARM=1.
  • SimX v3 TLM architecture. Transaction-level memory packets (MemReq/MemRsp with shared_ptr<mem_block_t> payloads) and reusable TLM cache / switch / coalescer modules across the L1/L2/L3 hierarchy, tcache/ocache/rcache, DXA, and CP DMA paths.
  • ASIC synthesis flows. hw/syn/{synopsys,yosys}/ productized: shared hw/syn/common.mk, bundled NanGate_15nm_OCL.db standard cells, standardized OPT_LEVEL; legacy hw/syn/modelsim flow retired.
  • Synopsys multi-PDK support. hw/syn/synopsys/Makefile now exposes three target PDKs via LIB_TGT selection: ASAP7 (7nm), SAED14 (14nm SLVT), and NanGate 15nm OCL (default). Per-PDK SRAM mappings, pin polarity, and address packing handled in hw/syn/synopsys/project.tcl (SRAM_PINS + family dispatch). Why: lets users compare PPA on a real foundry-style 7nm/14nm flow without rewriting the synthesis scripts per technology node.
  • Yosys + OpenSTA end-to-end ASIC pipeline. hw/syn/yosys/run_synth.sh runs synthesis → tech-map → area (stat -liberty) → SRAM-cost estimation (sram_cost.py) → OpenSTA timing + power (run_sta.tcl, gated by RUN_STA=1). Makefile targets: synth, techmap, timing. Why: gives the open-source flow the same area/timing/power deliverables as the Synopsys flow — no commercial-tool license needed for first-pass PPA exploration.
  • SAIF switching-activity workflow for power analysis. ci/blackbox.sh --saif [--saif_file=...] captures gate-level activity from rtlsim runs; both the Synopsys (project.tcl:489-922 — read_saif -auto_map_names + report_saif) and Xilinx (hw/syn/xilinx/dut/common.mk:31) power flows consume the resulting SAIF for vector-driven power estimation. A matching --vcd [--vcd_file=...] switch gates waveform output independently of --debug, so trace, waveform, and activity capture compose freely. Why: replaces vectorless power estimation with activity-annotated numbers tied to a real workload, dropping the order-of-magnitude error band that purely static analysis carries.
  • OpenSTA tool packaged with the toolchain. New sta() function in ci/toolchain_install.sh.in + ci/toolchain_prebuilt.sh.in; installed under $TOOLDIR/sta/ and consumed by both the Yosys flow (run_sta.tcl) and hw/syn/common.mk as $(STA). Why: makes OpenSTA a first-class peer of Verilator/sv2v/Yosys in the prebuilt toolchain so the ASIC flow's timing/power story works out-of-the-box from a fresh toolchain_install.sh --all.
  • Trap / exception foundation (preemption groundwork). Synchronous machine-mode trap path: ECALL / EBREAK / MRET with per-warp M-mode CSRs (mstatus, mtvec, mscratch, mepc, mcause, mtval). The branch unit is the trap producer (cause rides the existing branch-control interface); the scheduler snapshots mepc/mcause and redirects the warp PC to mtvec, with mret returning through mepc — mirrored one-for-one in the SimX scheduler (per-warp raise_trap / mret, replacing the old kill-all-warps trap behavior). Host-side ELF loading + HTIF tohost monitoring (sim/common/elf_loader.cpp, sim/common/host_monitor.cpp) are wired into both simulators, which is what lets the upstream riscv-tests suite run natively on Vortex. Asynchronous preemption itself (preempt-from-CP, interrupts, supervisor mode, register-file/IPDOM save-restore) builds on this and is future work. See docs/designs/trap_and_exception_foundation.md.
  • Toolchain refresh. LLVM 20, POCL 7.0, chipStar.
  • Kernel-entry calling convention (no callee-saved spills). vortex.kernel entries (__kernel macro, vx_spawn2.h) skip s0–s11/fs0–fs11 spills via an empty LLVM-20 callee-saved set (ra still saved); the KMU/__vx_cta_entry trampoline runs each once then vx_tmc zero. Why: generic-ABI per-CTA spills thrash the 16 KB L1 (sgemm2 +27% cycles).
  • Versioned toolchain pipeline for CI. VERSION is the single source of truth (VORTEX_VERSION, TOOLCHAIN_REV, GEM5_REV); CI cache keys + installer scripts both honour it; bumping a pin rolls the CI cache.
  • Perfetto trace integration. ci/perfetto.py renders RTL and SimX traces into Chrome Trace JSON (auto-detects flavour); see docs/perfetto_analysis.md.
  • AI-agent integration via AGENTS.md. Canonical entry point for AI agents and human contributors — foundation rules, documentation map, build/test/design invariants.
  • Test groups. New --vulkan, --gem5, --hip, --amo, --tensor_sp, --tensor_wg, --dtm, --mpi, --rvc, --vm, --graphics runners in ci/regression.sh; matrix expanded to rv32 + rv64.
  • Performance-regression gate (perf_gate). Catalog cases marked check: perf_gate run on rtlsim and gate against goldens in ci/baselines/perf/: retired instructions must match the baseline exactly (a mismatch means the workload changed, not performance), cycles must stay within ±2%, and a config hash invalidates a baseline whose run configuration drifted. The ratchet is two-sided — an improvement beyond 2% also fails until a human locks it in with pytest ci --update-baselines — so the goldens always state the real number. Coverage spans core, dxa, graphics, raytracing, and the tensor/tensor_sp/tensor_wg/tensor_mx families. Why: cycle regressions surface at the change that caused them instead of in a later benchmark sweep.
  • SimX↔RTL model-parity gate (model_parity). Catalog cases marked check: model_parity run the same app/args/configs on both drivers and assert (1) identical retired-instruction counts — a mismatch is functional divergence, not a timing gap — and (2) a cycle gap within the case's tolerance. SimX is the RTL's timing model; this check keeps the two in lockstep. Known modelling gaps carry an explicit known_issue: reason in the catalog rather than silently passing.
  • FPGA synthesis-regression gate (fpga_gate). ci/fpga_gate.py puts nine DUTs (cache, core, top, dxa, tcu, rtu, raster, om, tex) through Vivado synthesis + place-and-route at their target clocks and gates post-implementation Fmax and area (LUT/FF/LUTRAM/BRAM/URAM/DSP) against goldens in ci/baselines/synthesis/xilinx/ (default ±5%, per-build/per-metric overrides in ci/testcases/fpga_gate.yaml). Longest-first 2-up scheduling, per-build resume-from-checkpoint stamps, and an RTL-elaboration watch that fails a config typo in minutes instead of hours. The fpga tier is opt-in: it runs only on the self-hosted Vivado runner (.github/workflows/fpga_gate.yml) or by hand, never on hosted CI; goldens are re-recorded only by a human via --update-baseline. Why: the same golden/threshold/ratchet discipline as perf_gate, applied to what synthesis costs (timing closure, area) rather than what execution costs (cycles).
  • ASIC synthesis-regression gate (asic_gate). The open-source counterpart of the FPGA gate: ci/asic_gate.py puts the same hw/unittest DUT wrappers through sv2v → Yosys → ABC → OpenSTA on ASAP7 (RVT, TT) at their target clocks and gates post-synthesis Fmax and standard-cell area against goldens in ci/baselines/synthesis/yosys/, recording WNS/TNS, sequential and SRAM area, cell count and power alongside. The gating machinery is now shared: ci/synth_gate.py holds the catalog, config_hash, thresholds, known_issue, resumable sessions, scheduler and report, and fpga_gate.py/asic_gate.py are entry points that pin a tool adapter — fpga_gate behaviour is unchanged, config hashes included. DUTs are declared once per flow in hw/syn/{xilinx,yosys}/dut/catalog.mk, so make -C hw/syn/yosys/dut om and the gate run the same thing. The asic tier is opt-in and the gate runs from .github/workflows/asic_gate.yml — nightly, skipped when master has not moved, and fanned out to one hosted job per DUT because each takes 1-2 hours. Why: the flow needs no licence and no dedicated machine, so the discipline the fpga_gate applies on a self-hosted Vivado box can cover every contributor's changes. Two flows over the same modules also make a divergence between them a finding rather than noise. Three flow fixes fell out of building it. run_sta.tcl now reports report_worst_slack (signed) instead of deriving Fmax from report_wns, which clamps at zero and made every design that closed report exactly its target clock. configure now copies every *.mk fragment into a build tree, not just common.mk, so an included catalog.mk/build.mk resolves from build/ as well as from the source tree. And each synthesis flow's mandatory defines are now override CONFIGS +=: a CONFIGS= on a make command line silently defeats every CONFIGS += in a makefile, so the DUT dispatcher was dropping -DSYNTHESIS -DASIC -DYOSYS — the cache DUT synthesized to 1.08 M cells of flip-flop-inferred RAM with zero SRAM area. The Xilinx and Altera DUT flows carried the same trap (their gate passes CONFIGS through the environment, which appends rather than overrides, which is why it never fired there) and are hardened the same way; a command-line CONFIGS is now extra defines on top of the flow's, which is how it reads.
  • tests/opencl: full Rodinia suite + atomics benchmarks. The OpenCL test tree now carries the Rodinia benchmark suite wired into CI — backprop, bfs, b+tree, cfd, dwt2d, gaussian, heartwall, hotspot, hotspot3D, hybridsort, kmeans, lavaMD, lud, myocyte, nn (nearn), nw, pathfinder, srad, and streamcluster — plus atomics benchmarks (atomicreduce, histogram, in both tests/opencl/ and tests/hip/) that exercise the A-extension end-to-end across the L1/L2/L3 hierarchy, and the OpenCL image benchmark set (image_*; see the OpenCL image-support entry above). Why: moves OpenCL coverage from a handful of kernels to a standard, externally comparable workload suite that stresses the caches, atomics, and the image path together.
  • Hardware virtual memory (MMU v2). RTL translation hierarchy (hw/rtl/vm/): per-L1-cache socket TLB stage (non-blocking dTLB/iTLB + miss station), shared cluster L2 TLB (512e 4-way + megapage array), 2-walker PTW with walk cache; DCR-sourced satp, kill+report faults, page-granular allocation; vm CI on simx+rtlsim at XLEN 32/64. See docs/designs/virtual_memory_subsystem.md.
  • Multi-threaded SimX. Per-socket execution domains on lockstep worker threads (-DSIMX_MT=<T> via build CONFIGS), with cycles bit-identical across every thread count. New port-only communication API: SimEventLink control-plane links, KMU push dispatch matching the RTL launch bus, and framework-owned quiescence via SimPlatform::idle().
  • SimX functional emulation mode. -DSIMX_FUNCTIONAL (via build CONFIGS) selects a functional-only simulation kernel (unit latency, no backpressure, MT executor retained) behind the unchanged component API for full-speed architectural runs such as CTS conformance sweeps. Functional cycle counts are non-physical and excluded from perf_gate/model_parity.
  • CONTRIBUTING.md and this changelog at the repo root.

Changed

  • ALU, LSU and FPU scale with the issue width. VX_CFG_NUM_{ALU,LSU,FPU}_BLOCKS now default to VX_CFG_ISSUE_WIDTH (VX_config.toml); VX_CFG_NUM_SFU_BLOCKS stays at 1.
  • Shared memory scales with the lane count. VX_CFG_LMEM_LOG_SIZE is derived as VX_CFG_LMEM_NUM_BANKS x 2KB instead of a fixed 16KB, giving 8/16/32/64KB at NT=4/8/16/32 with bank depth constant.
  • DXA LMEM writes are counted and committed per banked row. The SimX drain counted one write per port request instead of one per row beat, and could leave a row half-written when the second port was full; lmem_writes now matches rtlsim exactly.
  • LMEM window decode no longer forms an end address. VX_lsu_slice.sv and VX_tcu_agu.sv test membership by comparing the address bits above the window, which stays correct when the window ends at the top of the address space.
  • TCU register-file bank-conflict-free mapping. TCU micro-op generation in TcuUopGen (and the SimX sim/simx/tcu/tcu_unit.cpp:1332 bank-conflict-free formulas) permutes A / B / C operand offsets so every uop's three RF reads land in different GPR banks; separate formula classes cover sparse, dense NT∈{4,16,64}, and dense NT∈{8,32}. Why: drops issue-stage stall cycles to zero on the TCU MMA loop — v2.x used a naive (step % sub_blocks) * block_size offset that incurred bank collisions on every other uop.
  • Profiling counters are host-driven via DCR (device-side dump removed). Kernel startup (vx_start.S) no longer dumps perf counters at exit; the host reads them on demand via vx_mpm_query → vx_dcr_read, gated by VORTEX_PROFILING. Why: drops perf-dump code from every kernel binary.
  • Source-tree consolidation. kernel/ + runtime/ → sw/{kernel,runtime,common}; new sw/common/ holds code shared by device and host (rvfloats, softfloat_ext, mem_alloc, plus the h/w-internal gfx_render.{h,cpp} host hardware model used only by simx). Why: removes include-path duplication and mirrors the sim/{simx,common,...} layout. Note: ABI types and downstream-visible config (tensor_cfg.h, the graphics on-wire types) live in sw/kernel/include/ so they ship through the install tree; sw/common/ is vortex-internal and never installed.
  • Downstream tools consume vortex via $VORTEX_PATH + pkg-config. mesa-vortex, pocl-vortex and chipStar no longer reach into the vortex source tree ($VORTEX_HOME) or build tree ($VORTEX_BUILD_DIR) for headers or libraries. They link against the install tree produced by make install through vortex-runtime.pc / vortex-kernel.pc. Mesa's vortex-runtime option is now vortex-path; pocl's -DVORTEX_PREFIX= / -DVORTEX_BUILD_DIR= are replaced by pkg_check_modules(VORTEX REQUIRED vortex-runtime) + -DVORTEX_PATH_{32,64} for per-XLEN device-side bitcode builds.
  • gfxutil.{h,cpp} removed. Binning() moved into graphics.h + graphics.cpp (now part of libvortex.so); the toVX{Format,Compare,StencilOp,BlendFunc} helpers (CGLTrace-specific test-input translators) inlined into tests/regression/gfx_draw3d/main.cpp, the only consumer; ResolveFilePath (test-asset filesystem resolver) inlined per-test, matching the resolve_path pattern raycast already used. Why: gfxutil.h was leaking cocogfx (CGLTrace, ePixelFormat) into what should have been vortex's public surface; eliminating it lets graphics.h be self-contained as the install tree requires.
  • riscv-tests .bin blobs removed from the source tree. Pre-built tests/riscv/isa/*.bin (c56562fe) and tests/riscv/benchmarks_{32,64}/*.bin (cd1656cf) collapsed into a single on-demand build under tests/riscv/common.mk that clones upstream riscv-tests at a pinned commit and builds per-XLEN behind a stamp file. Why: drops binary blobs from version control and pins behaviour to a single upstream commit instead of stale checked-in artifacts.
  • Configuration moved to TOML. VX_config.toml + VX_types.toml replace hw/rtl/VX_config.vh; ci/gen_config.py emits per-target headers (build/hw/VX_config.vh, build/sw/VX_config.h) and -D overrides from one source, with expr: / [[enum]] / [[builtin]] / [[param]] semantics. Why: gives the config typed scalars / cross-key expressions / typed enums the flat \defineblock could not express, and decouples SimX/runtime from the RTL source tree (no more-I$(ROOT_DIR)/hw`).
  • Configuration namespace. All HW config macros now carry the VX_CFG_ prefix; HW/SW layering split — VX_config.h is HW/sim-private. Why: resolves preprocessor collisions with LLVM/Clang and Verilator/SV \define`s, and stops HW config from leaking into kernel-side toolchain invocations.
  • No more global toolchain_env.sh. Each build/ carries its own resolved tool paths. Why: enables parallel multi-version Vortex worktrees on the same shell (the old source ci/toolchain_env.sh hijacked $PATH).
  • Build system. Tool-path env vars unified on the _PATH suffix; shared hw/syn/common.mk; standardized OPT_LEVEL across synthesis backends; LLVM default target fixed; dead hw/config call dropped. Why: normalizes the build/synthesis surface so cross-backend changes touch one place.
  • Verilator pinned to 5.028 (was tracking the latest 5.046 release in the prebuilt). Why: 5.046 removed the --xml-only flag that sim/opaesim/Makefile needs for --scope, tightened DEFOVERRIDE into a hard error breaking DEBUG=3 + -DGPR_RESET debug builds, and rejected cvfpu's C_PC / C_EXP_* macros under DPI_DISABLE + FPU_FPNEW (--config2). 5.028 keeps all three working (commit f00bb142).
  • SimObject channels — explicit fixed-size handshaking. Unbounded std::queue + blocking push/pop replaced by fixed-capacity channels + non-blocking try_send / try_pop (RTL ready/valid analog); [[nodiscard]] forces producers to handle backpressure at the call site. Why: makes SimX model true RTL backpressure (1:1 with ready/valid) so buffering bugs surface in C++ instead of only at RTL bring-up.
  • Scoreboard issue arbiter — GTO (Greedy-Then-Oldest). VX_scoreboard now drives a dedicated VX_gto_arbiter with a suppress mask for warps whose target functional unit is full (they keep aging but are skipped for selection until the FU drains). v2.x used VX_stream_arb (round-robin). Why: GTO matches mainstream GPU warp-issue policy — finish the currently-running warp before switching — yielding better ILP/cache locality than naive RR.
  • Scoreboard — XREGS dependency tracking + per-FU lock for multi-uop macros. Scoreboard gains a second plane (inuse_xregs) tracking FPU special registers (fflags, frm); every instruction declares rd_xregs / wr_xregs masks in decode (VX_decode.sv:377-380). New fu_lock / fu_unlock instruction flags let a uop sequencer hold a functional unit across a multi-uop macro — set by VX_tcu_uops.sv:422 for WGMMA (fu_lock=first_uop, fu_unlock=last_uop) — and the scoreboard refuses to issue any other warp's uop to the locked FU until it retires. Why: eliminates v2.x's coarse FPU-boundary stall for fflags/frm WAW/RAW hazards, and keeps multi-uop macros atomic on one FU instance — without fu_lock, interleaving warps would corrupt shared FU state (WGMMA's per-block A registers + accumulator).
  • Warp scheduler — per-warp ibuffer-capacity gate. VX_scheduler tracks per-warp ibuf_full and computes schedule_warps = ready_warps & ~ibuf_full, with an all_ibuf_full ? ready_warps : preferred_warps fallback to keep pipelines absorbing transient stalls. v2.x scheduled solely on active_warps & ~stalled_warps. Why: prevents the scheduler from issuing a warp whose decoded uops will only block on a full ibuffer downstream — wasting fetch/decode bandwidth and pushing back-pressure into the front end.
  • __syncthreads() (BAR opcode) now drains LSU before suspending warps so SMEM writes commit before any post-barrier reads. Gated on lsu_sched_drained in VX_wctl_unit.sv and lsu_drained() in sim/simx/sfu_unit.cpp.
  • BUG FIX: SimX cache-flush parity with RTL VX_dcr_flush — ProcessorImpl::flush_caches() (sim/simx/processor.cpp) now fans out to icache + dcache + {tcache, rcache, ocache} L1 surfaces in parallel (was dcache-only), matching the RTL shared-req/AND-of-done topology in VX_core.sv + VX_graphics.sv.
  • Sectored L2/L3 + word-size dcache banking. L2/L3 lines doubled to 2*MEM_BLOCK with a MEM_BLOCK sector (VX_CFG_{L2,L3}_SECTOR_SIZE) — one tag spans the line while fills/evictions transact at the bus granule, halving LLC tags. Dcache banks now derive from a reduced coalescer WORD_SIZE (NUM_BANKS = NUM_REQS = footprint/word), scaling with thread count. Why: cuts LLC tag area and lets dcache memory-level parallelism track NT without shrinking the line.

Fixed

  • SimX arbiter input grouping. TxArbiter/TxRxArbiter grouped inputs by log2ceil(inputs / outputs) where VX_stream_arb uses ceiling division, so a request count that is not a multiple of the output count left the trailing inputs unserved (3 cores over 2 shared icaches hangs at boot). Covered by the cache: demo-shared-icache-odd catalog case.