Skip to main content
Roviral

AMD Zen 6 and Zen 6c: Faster Branch Recovery, Wider Vector Loads and Different Core Designs

Zen 6 improves front-end and execution throughput, while Zen 6c adds larger out-of-order structures and cache capacity for latency-heavy workloads.

AMD Zen 6 and Zen 6c: Faster Branch Recovery, Wider Vector Loads and Different Core Designs

AMD’s Zen 6 family changes more than core density. The measured results point to two designs with distinct priorities: Zen 6 favors higher clock speeds, while Zen 6c has larger out-of-order structures and a much larger shared L3 cache to keep more work moving when memory is slow. Both build on Zen 5’s front end and execution engine, with changes to branch recovery, instruction decoding and vector throughput.

That division shows up in the performance data. The 12-core Zen 6 EPYC 9686F leads in estimated single-threaded SPEC CPU 2026 results at its tested clock, while the 32-core Zen 6c EPYC 9996 delivers similar single-thread performance to the previous-generation EPYC 9575F despite running about 900 MHz slower. At matched clock speed, Zen 6c’s larger structures help explain why it can pull ahead per clock in some workloads.

Branch prediction and instruction delivery

Zen 5 already had the most accurate branch-direction predictor measured in the tests, and Zen 6 appears to retain that accuracy while reducing the cost of a wrong prediction. When the predictor’s working set exceeds its ability to make useful predictions, the measured penalty plateaus at roughly 3 to 3.5 ns per branch on Zen 6, compared with roughly 3.5 to 4 ns on Zen 5. That difference suggests lower misprediction recovery latency.

Zen 6 also handles two branches per cycle while the instruction footprint remains within the L1 instruction cache. Once it exceeds that cache, throughput drops to one branch per cycle across the rest of the branch target buffer tests, except for the 64-byte test, which reaches four cycles per branch for the L2 BTB. The comparison suggests AMD put more emphasis on BTB speed than on increasing its capacity.

The instruction front end keeps Zen 5’s two-decode-cluster design, but changes how a thread can use it. Zen 5 effectively limited a single thread to one decode cluster; Zen 6 lets that thread draw on both. Beyond the L1 instruction cache, measured instruction-side behavior looks much like Zen 5’s. The main change is therefore concentrated where a small instruction footprint can benefit from the added decode capacity.

Execution throughput shifts by workload

Zen 6 brings back Zen 4’s ability to pair NOPs, allowing the core to retire up to 16 per cycle. It also gets more out of the same six integer ALUs: the measured throughput for simple 64-bit additions rises to 5.96 per cycle, from 5.25 on Zen 5.

That gain comes alongside a reduction in integer multiply hardware. Zen 6 has two integer multiply units rather than Zen 5’s three, reducing PDEP and PEXT throughput from three instructions per cycle to two. AMD’s explanation is that the third unit on Zen 5 did not earn its area cost. This is a targeted trade: more measured throughput for simple integer operations, with less capacity for multiply and bit-manipulation instructions.

The floating-point units are unchanged. Zen 6 can still execute two 512-bit FADD, FMUL or FMA operations per cycle. The larger vector change is VNNI: the number of units doubles from two to four, and measured 512-bit VNNI throughput rises from 1.99 to 3.88 instructions per cycle. Zen 6c matches that result. VNNI is used in work such as the inner loop of quantized inference and video filters.

Load throughput also improves for narrower vector code. Zen 5 could perform four vector loads per cycle in the tested configuration, but no more than two could be vector loads, whether they were 256 or 512 bits wide. Zen 6 raises 256-bit load throughput to four per cycle on both core designs, while keeping 512-bit loads at two. Both widths can now reach 128 bytes per cycle, a useful change for software that still targets AVX1 or AVX2.

Zen 6c’s larger out-of-order engine

The architectural split between the two core types starts after micro-op dispatch and appears to end after the load queue. Several out-of-order structures are larger on Zen 6c: its reorder buffer has 640 entries versus 576 on Zen 6; its integer register file has 352 versus 288; its vector scheduler has 180 versus 138; and its load queue has 330 versus 280.

Those capacities let Zen 6c keep more operations in flight and potentially cover more memory latency. The measured differences suggest Zen 6 is shaped for higher frequency, while Zen 6c uses extra capacity to sustain work when data takes longer to arrive. That interpretation also fits their different cache layouts: the Zen 6 CCD has 12 cores and 48 MB of L3, while the Zen 6c CCD has 32 cores and 128 MB. Both provide 4 MB of L3 per core.

L3 latency rises across the family. The reported figures are about 47 cycles on Zen 5, 55 cycles on Zen 6 and 66 cycles on Zen 6c. Larger caches and more mesh stops are possible contributors. In time units, Zen 6’s higher clock keeps the measured latency close to the Zen 5-based EPYC 9355P: 10.7 ns versus 10.3 ns. Zen 6c measures 16.4 ns, reflecting its lower clock and larger CCX.

Zen 6 also fixes an uneven part of Zen 5’s L2 read behavior. Zen 5 delivered about 42 bytes per cycle across most of the L2’s capacity; Zen 6 reliably reaches 64 bytes per cycle. Bandwidth per cycle elsewhere in the cache hierarchy is largely unchanged.

Load forwarding and SPEC CPU 2026 results

Store-to-load forwarding appears unchanged from Zen 5, and the two Zen 6 designs behave alike in the measured tests. A 32-bit load from the same address as a 64-bit store completes with effectively zero latency, allowing two dependent store-load pairs per cycle. Loads fully contained within a store complete in seven cycles regardless of alignment; partial overlaps take 14 cycles.

In estimated single-threaded SPEC CPU 2026 results, the EPYC 9686F ranks near the top. It roughly matches the Ryzen 9 9950X3D2 in integer rate and exceeds it in floating-point rate. At a matched 4.1 GHz, the 9686F leads by about 4% in integer and 11% in floating point, despite the X3D processor’s larger L3 cache.

The EPYC 9996 also posts strong results. It roughly matches the previous-generation EPYC 9575F in single-thread performance while running about 900 MHz slower and carrying four times as many cores. It edges out NVIDIA’s Vera in integer performance and leads it by about 20% in floating point.

The 9686F’s higher clock helps it lead the 9996 in most subtests, finishing about 18% ahead in both suites. Its scores are 6.20 for integer and 10.6 for floating point, against 5.25 and 8.99 for the 9996. Among the larger leads are 714.cpython, 766.femflow and 772.marian. Yet the 9996 beats the 9686F in 721.gcc and 765.roms, where the higher clock does not translate into an advantage.

Pipeline-slot breakdowns help explain that variation. In core-bound integer tests such as 750.sealcrypto, 710.omnetpp, 735.gem5 and 753.ns3, the chips have nearly identical shares of retiring slots. Differences grow in memory-heavy work: the 9686F spends 50.0% of slots stalled on backend memory in 729.abc, versus 37.9% for the 9996; in 723.llvm, the figures are 34.1% and 19.0%. The larger L3 on Zen 6c may serve more requests before they reach main memory.

Floating-point results show a similar workload split. The chips have comparable retiring shares in 731.astcenc, 772.marian and 767.nest, while both spend more than half their slots stalled on front-end bandwidth in 709.cactus. In memory-heavy tests, backend memory stalls are higher on the 9686F: 55.3% versus 42.5% in 765.roms, 67.6% versus 60.9% in 749.fotonik3d, and 33.8% versus 17.8% in 782.lbm. The 9686F trails in 765.roms, roughly ties in 749.fotonik3d and leads by about 11% in 782.lbm, despite clocking up to roughly 29% higher.

https://media.discordapp.net/attachments/809099718189121536/1569240935466803300/image.png?ex=6af2bd02&is=6af16b82&hm=1233642c0815dc5a6265c7be59547965aa82df42f26fcb8e10f63055f641f2d8&=&format=webp&quality=lossless&width=2616&height=1359

Clock matching reveals the core trade-off

At 4.1 GHz, the 9686F scores 4.92 in integer and 8.64 in floating point, putting Zen 6c about 6.7% ahead per clock in integer and 4% in floating point. Core-bound integer profiles remain close at the matched clock: retiring slots account for 67.3% on the 9686F and 67.6% on the 9996 in 750.sealcrypto.

The memory and front-end profiles still separate them. At matched clocks, backend memory stalls remain higher on Zen 6 in 765.roms, 782.lbm and 749.fotonik3d. The 9996’s 128 MB L3, compared with 48 MB on the 9686F, is a plausible reason it avoids more trips to main memory. In code-heavy tests, front-end latency stalls also take a larger share on the 9686F: 35.2% versus 16.6% in 727.cppcheck, and 25.8% versus 10.0% in 721.gcc. With the front ends shared and clocks matched, the cache and memory hierarchy likely account for much of that gap.

Zen 6’s front-end and execution changes improve throughput in several specific cases, while Zen 6c’s extra in-flight capacity and L3 cache favor workloads that can make use of them. The results point to a family where core choice depends increasingly on the balance between clock speed, working-set size and memory latency.

https://media.discordapp.net/attachments/1329409886676848660/1569271555379175535/image.png?ex=6af2d986&is=6af18806&hm=cdc4d18e51b664a0098b0958ffe6992b13c9f835fa23072ae98cc20e3f1f9375&=&format=webp&quality=lossless&width=2997&height=870
Source: George Cozma · chipsandcheese.com

Filed alongside