Unmarked dark grey cabinet with a smooth blank door in an empty corridor

1,638 GB/s Published, 667 GB/s Measured: What a 40.7 Percent Ceiling Says About the Tier You Can Use

What was published and what was measured

AMD opened the EPYC 9006 platform on November 10, 2026 with sixteen memory channels per socket, and the number attached to that platform is 1,638 GB/s. That figure is not a chip specification. It is the arithmetic of sixteen channels running at 12,800 MT/s, and it only holds with MRDIMMs. With ordinary registered DIMMs at 8,000 MT/s the same platform is 1,024 GB/s. Both numbers are AMD’s own, from the EPYC 9686F datasheet.

Three independent test sets appeared the same day, and none of them reached the published figure. Level1Techs measured 667 GB/s on the ramp to all sixteen channels, which is 40.7 percent of the datasheet number, and the team called a good 1,200 GB/s realistic for a dual system. ServeTheHome worked on a single populated socket in a Dell PowerEdge R9815 because the dual 256-core machine it had been promised in October did not arrive until launch morning, and it said it wished it had used faster and more memory, because RAM is expensive right now.

The 40.7 percent is the part worth reading, and it is not a Venice number. I ran the same style of copy pass on my own two-channel board and landed at 38.3 percent of that board’s theoretical channel. A 14,904 dollar processor and a 135 dollar memory kit agree on the same fraction of their own published ceiling. That agreement is what a datasheet bandwidth figure means in practice.

The datasheet number decomposes into two separate things

Channel width and channel count are independent, and the headline figure is the product of both. Per channel, a DDR5 channel is 64 bits wide, so it carries 8 bytes per transfer. The arithmetic is the same for every platform in the table below.

Platform Memory type MT/s GB/s per channel Channels Published total
EPYC 9006 (AMD datasheet) MRDIMM 12,800 102.4 16 1,638 GB/s
EPYC 9006 (AMD datasheet) RDIMM 8,000 64.0 16 1,024 GB/s
My board (Ryzen 9 5900X) UDIMM, 2 populated 2,667 21.3 2 42.7 GB/s
Strix Halo class board LPDDR5X, 128-bit 8,000 128.0 (single 128-bit package) 1 package 128 GB/s

My board’s published-equivalent ceiling is 42.7 GB/s. The Venice figure is 38.4 times that. The 38.4 splits cleanly: 4.8 times per channel, and eight times more channels. Nothing in the 38.4 comes from the silicon being faster per bit. It comes from having eight times more wires and running them 4.8 times faster.

The last row is the one that matters for anyone buying hardware in 2026. A soldered 128-bit LPDDR5X package is one package, not sixteen channels, and it delivers 128 GB/s. That is three times my board’s ceiling with a fraction of the parts, because package width does the work that channel count does on a server board.

What my board actually measured

The probe ran on the serving box, not on the machine I sent it from. That box is a Ryzen 9 5900X with 64 GB of DDR4-2667 in two channels, 64 MB of L3 confirmed over SSH, and the copy pass was executed there with Python 3.13. Seven passes per size, median reported. The 16 MB working set never reaches DRAM, so its row is a rate achieved inside cache and cannot be expressed as a share of the memory channel.

Working set Median copy time Data moved Memory traffic Share of the 42.7 GB/s channel
16 MB 793.1 µs 21.15 GB/s 42.31 GB/s rate inside cache, not DRAM traffic
32 MB 1,738.5 µs 19.30 GB/s 38.60 GB/s 45.2% as data moved
64 MB 3,925.6 µs 17.10 GB/s 34.19 GB/s 40.0% as data moved
128 MB 7,962.1 µs 16.86 GB/s 33.71 GB/s 39.5% as data moved
256 MB 16,422.8 µs 16.35 GB/s 32.69 GB/s 38.3% as data moved

Counted as memory traffic rather than as data moved, the two largest rows read 78.9 percent (128 MB) and 76.6 percent (256 MB) of the channel, because a copy touches every byte twice. Those are two different statements about the same run and they should not be presented as one number.

The latency side is separate. A pointer chase over a random permutation on a 128 MB working set measured 123.6 ns per hop. The same buffer with no dependent load costs 44.2 ns per element, which is the interpreter walking memory. The memory-attributable part is 79.4 ns per hop, derived by subtraction, not measured directly. On a 16 MB working set inside the 64 MB of L3 the chase measured 87.5 ns per hop against a 43.9 ns no-load baseline, so the cache-attributable part is 43.6 ns. The DRAM tier costs 1.82 times the cache tier per dependent load on this board, counted on the memory-attributable parts (79.4 ns against 43.6 ns), not on the raw chase figures. That boundary is the same cliff I measured on this hardware in the measured cache cliff, and the copy rows above are consistent with it: the rate falls as the working set crosses out of cache and then flattens.

Three measurement paths land on the same fraction

The copy pass, a STREAM-style ramp, and a decode loop are three different methods. They agree on the percentage far more closely than they should.

Path What was measured Against what Fraction
Level1Techs ramp, 16 channels 667 GB/s 1,638 GB/s datasheet 40.7%
My copy pass, DRAM sizes 16.35 GB/s data moved 42.7 GB/s theoretical channel 38.3%
Decode loop, arithmetic 252 GB/s effective read rate 667 GB/s measured ramp 37.8%

The third row is arithmetic, not a measurement. It comes from Level1Techs’ measured 36 tokens per second on Gemma 3 12B. A 12B model at 4-bit is roughly 7 GB of weights, and decode reads those weights once per token, so 36 tokens per second implies about 252 GB/s of sustained read. That is 37.8 percent of the bandwidth that the same team measured on the same machine with a different method.

I am not claiming three methods prove a law. A STREAM ramp and a memmove pass measure different things, and the agreement is suggestive rather than proof. What it does show is that a published channel figure is a ceiling nobody reaches, and the reachable fraction is roughly the same on a server platform and on a desktop board. The number to plan against is the measured fraction, not the datasheet.

Per-core bandwidth is the figure that survives the division

Dividing a platform total by core count is the step launch coverage skips. I did the same division for per-core bandwidth on a separate chip, and it is where the Venice headline collapses.

System Bandwidth Cores GB/s per core
EPYC 9996, datasheet figure 1,638 GB/s 256 6.40
EPYC 9996, measured ramp 667 GB/s 256 2.61
My board, theoretical 42.7 GB/s 8 5.33
My board, measured DRAM copy 16.35 GB/s 8 2.04

Read as datasheet against datasheet, the gap is 38.4. Read as measured against measured, it is 1.28. A 256-core server platform delivers 28 percent more bandwidth per core than an eight-core desktop board that costs a few hundred dollars in silicon. The 38.4 was never a per-core claim. It was a core count.

That is why the ClickHouse result matters more than the SPEC estimate. Tom’s Hardware found the 256-core EPYC 9996 slower than the 192-core EPYC 9965 in a ClickHouse test, and the author suggested cache coherency at higher core counts as the likely cause, offered as plausible rather than measured. The same testing put the 9996 30 to 40 percent ahead in Blender. Blender threads do not share much data. A database thread that updates a shared structure pays a coordination cost that grows with core count, and a directory-based coherence protocol adds a lookup on every miss. Eight chiplets of 32 cores communicate across package boundaries, which costs more time and more power than communication inside one die.

A suite-level score hides that. SPEC reports a geometric mean across many sub-tests, so one strong result offsets a weak one. The per-workload result is the one that decides whether 256 cores help you.

Threads made the decode slower

Level1Techs ran CPU inference on Gemma 3 12B and got 36 tokens per second on 96 threads of one socket, and 16 tokens per second on all 192 threads across two sockets. Prompt processing peaked around 600 tokens per second. Adding threads cut generation by more than half.

That is the same shape as the per-core table. Decode is a read loop. It cannot exceed the bandwidth available to the loop, and crossing the socket boundary costs about 50 ns per access against roughly 200 ns inside one socket, per the same team’s pointer chase. Two sockets do not double the bandwidth a single token stream can use; they add a hop.

The NUMA setting changes the result before any tuning does. NPS1 measured 9.2 percent behind NPS2 in an inference test and still about five percent behind after the kernel warmed up. On SQLite, NPS1 cost 17 percent. Those numbers are larger than anything a software tuning round recovers.

What this means for a local build

The practical reading is that channel count is not something a local build can buy. A consumer board exposes two channels. A workstation board exposes four. The sixteen-channel figure is a platform property, and it is only real when all sixteen slots are filled with the right module type. ServeTheHome could not fill its slots. A smaller operator’s own EPYC box has two modules in six slots, which is the ordinary state of most machines people actually own.

Where the money goes is worth looking at directly, because the price ratio does not track the bandwidth ratio. The G.SKILL Trident Z5 Neo 64 GB kit (2×32 GB, DDR5-6000 CL30, UDIMM) reads $1,225.23 on its live listing as of November 21, 2026. It is two channels, so its theoretical platform is 96 GB/s, which works out to about $12.76 per GB/s.

The G.SKILL RipjawsV 64 GB kit (2×32 GB, DDR4-2666, UDIMM) is the same capacity on the same kind of two-channel board, at $134.99. Its theoretical platform is 42.7 GB/s, or about $3.16 per GB/s. The price ratio between these two kits is 9.1. The bandwidth ratio is 2.25. The factor of 4.04 between the two per-GB/s figures is not bandwidth. It is the tier the market is pricing right now, and I wrote about what that pricing does to a local build in what a 3x DRAM price means for local LLM builds.

The third option is the one that actually changes the bandwidth. A MINISFORUM MS-S1 Max with a Ryzen AI Max+ 395 and 64 GB of LPDDR5 is $2,599.00 on its live listing today. Its memory is a soldered 128-bit package at 8,000 MT/s, which is 128 GB/s, and that is three times the theoretical platform of my two-channel board. The price includes the processor, storage and networking, so the per-GB/s comparison against a memory-only kit is not a fair one. The honest statement is simpler: a soldered wide package delivers more usable bandwidth than a two-channel kit does, and no amount of DIMM shopping on a consumer board gets you there.

For sizing a local build, the number to use is the measured fraction of the channel, not the published channel. On my board that is 38.3 percent as data moved. Applying the same fraction to a fully populated sixteen-channel Venice platform gives roughly 627 GB/s, which is close to the 667 GB/s Level1Techs actually measured. That is the only way the two numbers connect, and it is why the datasheet figure should not go into a capacity plan.

What to check before buying

Three things are measurable before a purchase, and all three change results more than any post-purchase tuning:

  • Slot population. The datasheet bandwidth assumes every channel is filled with the specified module type. RDIMM and MRDIMM are different numbers on the same platform, 1,024 against 1,638.
  • NUMA mode. Test NPS2 before rollout. The measured difference between NPS1 and NPS2 was 9.2 percent on inference and 17 percent on SQLite.
  • Power at the wall. The 600 W figure is a cooling target, not a measured draw. Tom’s Hardware reported no measured power for its test systems, and ServeTheHome declined to compare power across vendors because AMD’s readout counts the CPU without memory while Nvidia’s counts both.

For language model work specifically, the server CPU stays a niche. A 256-core platform hits the same generation wall as an eight-core one, because the wall is bandwidth per core and the per-core figures above are within a factor of 1.3. The cores are useful for the parts of a workload that share little data. For the part that reads weights once per token, the tier is the constraint, and the tier is priced separately from the silicon. The hardware tiers for running models locally are laid out in the pillar article rather than restated here.

Comments

No comments yet. Why don’t you start the discussion?

Leave a Reply

Your email address will not be published. Required fields are marked *