In this guide: 21 sections
- Eleven ceilings, and only six of them move
- Missing memory? The size of the gap names the cause
- What to do with this on a listing page
- The per-socket maximum is a property of the chip, and sometimes of the price list
- Channels, sub-channels, and what a vendor means by “channel”
- Slots: the ones on the board, the ones on a card, and the ones the empty socket owns
- The chassis can rule a module type out entirely
- The firmware table is not the silicon, and a QVL maximum is usually a firmware maximum
- The rank budget, not the slot count
- Module type is a whole-machine decision, and DDR5 took one option away
- What the second module per channel costs
- Population rules, interleaving, and the configuration that costs two thirds of the bandwidth
- Capacity on the wrong socket is not the same capacity
- Mirroring, sparing and lockstep spend capacity on reliability
- What a refusal looks like, and how to read one
- Installed is not usable, and the gap is not a rounding error
- Old ceilings: the address width, 32-bit systems and Windows editions
- Working the real ceiling out of three documents and the running machine
- Four machines, worked
- The cheapest route to a capacity is usually more modules, not bigger ones
- How this site records each maximum
A server’s advertised maximum RAM is the best processor, the largest qualified module and every slot filled, multiplied together, and a second-hand machine is almost never all three at once. Eleven separate limits apply at the same time, and the smallest of them is the capacity you actually get. On a used server the binding one is usually the processor or the module type rather than the slot count; the commonest reason a machine shows half the memory its seller described is an empty second processor socket, whose slots work only with a second processor fitted; and a server that reports exactly half of what you fitted is almost always mirrored in firmware rather than broken.
HPE prints the formula in its own QuickSpecs boilerplate: “The maximum memory capacity is a function of the number of DIMM slots on the platform, the largest DIMM capacity qualified on the platform, and the number and model of installed processors qualified on the platform.” Every term in that sentence is a variable, and the marketing page quotes the best value of each. Buy against the headline alone and good memory can seat and then post short of it, or not at all; buy against the eleven limits and it runs at the capacity you planned.
The summary tables and the buying checklist come first, then the detail behind each. The examples follow one illustrative machine so that the numbers can be checked against each other: a two-socket Xeon Gold 6130 server with 24 DIMM slots and twelve 32 GB dual-rank registered modules fitted.
Eleven ceilings, and only six of them move
Each of these has stopped somebody’s memory upgrade, and the one that binds is rarely the one in the marketing copy.
| Ceiling | Enforced by | Can you buy around it |
|---|---|---|
| Addressable physical memory | The processor’s physical address width | Not on 64-bit hardware, and it never binds there |
| Per-socket maximum | The memory controller, sometimes a fuse and a price list | Yes - fit a different processor |
| Sockets populated | The chassis, and whether the second processor was ordered | Yes - fit the second processor |
| Channels per socket | The processor | No |
| Slots per channel | The board’s routing | No |
| Largest die the firmware knows | The memory reference code in the system firmware | Sometimes, with a firmware update |
| Ranks per channel | Chip-select pins on the memory controller | Partly - stacked modules dodge the count |
| Module type | Board, processor and firmware together, machine-wide | Yes, but only by rebuilding the whole machine on one type |
| Qualified configuration | The vendor’s test matrix | Little worth risking |
| RAS mode | A firmware setting you chose | Yes - turn it off, and accept what it was for |
| Operating system or license | The kernel, or the edition you paid for | Yes - a different edition |
These are not alternatives. They all apply at once, and the usable capacity is the minimum of all eleven rather than the one the vendor chose to print. The six that move are each a purchase or a setting rather than a fact about the machine: a processor, a second processor, stacked modules, a module type, a firmware setting you can change for nothing, and an operating system edition.
Missing memory? The size of the gap names the cause
When a server reports less than you fitted, the size of the shortfall usually identifies the ceiling before you open a manual.
| What the machine reports | Most likely cause | Where to look |
|---|---|---|
| Exactly half of what you installed | Full memory mirroring, set in firmware | First confirm lscpu reports both sockets; then the memory RAS or operating mode menu in BIOS setup (mirroring and sparing) |
| A quarter or a half missing, with sparing enabled | Rank sparing holds ranks in reserve | The same firmware menu |
| Short by exactly one module | A module the firmware failed to train and mapped out | dmidecode -t 17 lists it and /proc/meminfo does not count it (refusals) |
| Half the slots inactive | The second processor is missing, so its slots have no controller | lscpu reports one socket (slots) |
| Stops at 128 GB under Windows | The Windows 11 Home edition limit | The Windows edition (old ceilings) |
| 3.2 to 3.5 GB out of 8 GB | A 32-bit operating system | The operating system’s architecture |
| A round figure far below what is fitted, on Linux | A leftover mem= kernel parameter |
cat /proc/cmdline |
| One or two percent short | Firmware-reserved regions and the I/O hole below 4 GB, which is normal | The e820 map in dmesg (installed is not usable) |
| Full capacity, about a third of the bandwidth | An unbalanced population, such as twelve modules on an eight-channel socket | The vendor’s population table (interleaving) |
| Full capacity, below the modules’ rated speed | Two modules per channel, or one slower module setting the pace | Configured Memory Speed per module in dmidecode -t 17 (the second module) |
Most of those are configuration or a missing part, not faulty memory. A gap of exactly one module can be a bad module, so fit and count everything on arrival, inside the returns window.
What to do with this on a listing page
- Count the processors before you count the slots. A two-socket board with
one chip fitted has half its slots inactive.
lscpureporting one socket, ordmidecode -t 17showing twelve empty locators in a row, is the whole answer. On an older platform the second processor is often cheaper than the modules it unlocks. - Find the per-socket ceiling on the processor, not on the chassis. The processor index lists it for every processor, each with a page of its own, such as the Gold 6130’s. Above a terabyte per socket on Intel Xeon Scalable, look for the M or L suffix in the listing title and assume its absence means absence (the per-socket maximum).
- Decide the module type once, for the whole machine. RDIMM and LRDIMM cannot be mixed, 3DS and non-3DS cannot be mixed at two modules per channel, and DDR5 servers take no load-reduced memory at all. Start from registered ECC unless a vendor table says otherwise; load-reduced is a decision about the machine, not the module.
- Work the rank budget, not the slot count. Two quad-rank modules fill an eight-rank channel; two dual-rank modules use half of it. The largest module on any vendor’s list is nearly always a stacked part with rules of its own (the rank budget).
- Prefer a population the interleave can use. One module per channel, or two per channel on every channel, and nothing in between. Twelve modules on an eight-channel socket costs two thirds of the bandwidth while looking like an upgrade.
- Buy the mainstream capacity of the generation. Compare 16GB, 32GB and 64GB on price per gigabyte and expect the smallest to win, then confirm the module count fits the slots, ranks and interleave rules (more modules, not bigger ones).
- Read the listing for the organization string, not the capacity. A 64 GB
module can be
2Rx4monolithic,4Rx4load-reduced or a 2-high stack, and those three are not interchangeable. If the listing does not show it, ask for a photograph of the label. - Check the machine’s own report before and after:
dmidecode -t 16and-t 17, and/proc/meminfofor what the kernel kept (the running-machine check). - Match the memory to the machine rather than to the number in the title. The compatibility pages state each machine’s vendor maximum with the conditions attached, and server memory by generation narrows the catalog to the modules those machines take.
- Treat a bid as an offer and a Buy It Now price as a price. An unfinished
auction is not a number you can pay today, so this site’s rankings
compare Buy It Now prices by default;
?bids=showadds bid-only listings, marked as bids, and?auctions=nodrops every auction.
The per-socket maximum is a property of the chip, and sometimes of the price list
The memory controller is on the processor die, so the capacity ceiling moves when the processor moves, in the same chassis, with the same slots and the same documentation. A Dell PowerEdge R730 reaches 3,072 GB with E5-2600 v4 processors and 1,536 GB with v3, and nothing differs except what is under the heatsinks. Supermicro’s X11DPL-i prints both tiers in one table: up to 2 TB of 3DS RDIMM or LRDIMM at DDR4-2933 with 82xx and 62xx processors, and up to 1 TB at DDR4-2666 with 81xx, 61xx, 51xx, 41xx and 31xx. A Skylake-SP board and a Cascade Lake board are the same board.
Intel went further on Xeon Scalable and sold the ceiling as a product. HPE’s DL580 Gen10 documentation notes that “Intel memory processors (with suffix M or suffix L) are needed for supporting more than 1 TB memory per socket” on second-generation parts, with L parts reaching 4.5 TB. Two chips with the same core count, clock and thermal envelope differ in one fused capability and a great deal of money, and on the used market the suffix is frequently absent from the listing title.
The example machine shows the size of the effect. The Gold 6130 is a standard first-generation Scalable part, rated by Intel at 768 GB per socket:
board arithmetic 24 slots × 128 GB LRDIMM = 3,072 GB
processor ceiling 2 sockets × 768 GB per socket = 1,536 GB
usable ceiling = min(3,072, 1,536) = 1,536 GB
The modules would allow three terabytes and the processors allow half of that. Fit a pair of M-suffix second-generation parts and the same board, the same slots and the same modules reach 3,072 GB, because the term that was binding moved. The 768 GB per socket is Intel’s figure for the SKU, and 128 GB is the largest DDR4 load-reduced module in general circulation.
The same effect runs both ways across a product’s life. A PowerEdge R660 reaches 8 TB on a fourth-generation Xeon Scalable and stops at 4 TB on a fifth, because the octal-rank 256 GB module Dell lists against the 4800 MT/s parts has no row against the 5600 MT/s ones. The R660xs does the opposite: 1,024 GB on fourth-generation parts and 1,536 GB on fifth, because the 96 GB module Dell lists at 5600 MT/s does not exist at 4800. The ceiling moved because the parts list moved, and Dell states neither condition next to the headline figure.
AMD’s ceilings behave the same way and are stated more cleanly. AMD publishes 4 TB per socket for EPYC 7002 and 7003, and describes a two-socket EPYC 7001 server reaching 4 TB in total, 2 TB per socket: Naples is half of Rome on the same SP3 socket and boards. On SP5, the EPYC 9004 socket, AMD publishes 6 TB per socket as “256GB DIMMs * 2 DPC * 12 channels” and also publishes 9 TB with 384 GB modules that are not yet something you can put in a cart. This site records the purchasable figure, the ceiling a buyer can reach today.
One figure in the processor column needs a second look: Dell’s R660 guide shows a memory capacity against every processor SKU, and the Xeon Max parts - the 9480, 9470, 9460 and 9462 - read 64 GB where every other SKU reads 4 TB. That 64 GB is the on-package high-bandwidth memory, not a DIMM ceiling.
Channels, sub-channels, and what a vendor means by “channel”
A channel is one independent path from the memory controller to a set of modules. The count per socket is fixed by the processor: two on a desktop part, four on the older single-socket server lines, six on first- and second-generation Xeon Scalable, eight on EPYC 7001 through 7003 and on fourth-generation Xeon Scalable, twelve on EPYC 9004 and 9005. That count sets the bandwidth and, with the slots per channel, the slot count. The bandwidth arithmetic checks a channel count against a figure the vendor publishes separately:
per channel MT/s × 8 bytes per transfer
per socket per channel × channels
DDR4-3200, 8 channels 3200 × 8 = 25,600 MB/s × 8 = 204.8 GB/s
DDR4-2667, 4 channels 2667 × 8 = 21,336 MB/s × 4 = 85.3 GB/s
DDR5-4800, 12 channels 4800 × 8 = 38,400 MB/s × 12 = 460.8 GB/s
The middle row is the interesting one. AMD footnotes four EPYC 7002 parts - the 7282, 7272, 7252 and 7232P - as “performance optimized for 4 channels with DDR4-2667 DIMMS” and gives them 85.3 GB/s rather than 204.8 GB/s. That figure decodes exactly as four channels of DDR4-2667, so filling all sixteen slots per socket on one of them does not buy the bandwidth the family headline promises.
DDR5 complicates the vocabulary rather than the arithmetic. JEDEC’s DDR5 standard, JESD79-5, splits a module into two independent 32-bit sub-channels, but Intel and AMD still count one channel per DIMM slot group: eight on a fourth-generation Xeon Scalable, twelve on SP5. A sub-channel is a different way of counting the same interface, not extra capacity, and a document saying “sixteen channels” about an eight-DIMM-per-socket machine is counting sub-channels. DDR5’s on-die ECC is not subtracted from the advertised density either, and it is not system ECC, which is the distinction ECC vs non-ECC exists to make.
Slots: the ones on the board, the ones on a card, and the ones the empty socket owns
The capacity identity is four terms:
maximum capacity = sockets × channels per socket × slots per channel × module capacity
Every headline figure is that product evaluated at its best value in every term. Evaluate it at the values of your machine instead. On the example machine:
2 sockets × 6 channels × 2 slots per channel = 24 slots
24 × 32 GB, if it were fully populated = 768 GB
12 × 32 GB, as actually fitted = 384 GB at one module per channel
Three of those four terms are where the surprises live.
Slots that belong to a processor that is not there. Intel states the general rule for its own boards: “The memory slots associated with a given processor are unavailable if the corresponding processor socket is not populated.” That is wiring rather than policy, because those slots have no controller at the other end. HPE’s DL160 Gen9 QuickSpecs states that “if only one processor is installed in a two processor system, only half of the DIMM slots are available”, which takes that machine’s stated 1,024 GB down to 512 GB with one chip fitted. An ML350p Gen8 has 24 slots and twelve of them are inactive in a single-processor build. On the second-hand market this is the commonest reason a machine arrives with half the memory the seller described, and it is also the cheapest of the eleven ceilings to lift: a low-bin second processor for a decade-old platform costs less than four modules, as the cheapest-route section works out.
Slots that arrive on a card you have to order separately. The entry model of the 48-slot DL580 Gen10 ships two of its four processors, and HPE’s note reads “24 DIMM slots available with Entry Model; 2 more processor slots and 24 more DIMMs available via optional HPE DL5x0 Gen10 CPU Version 2 Mezzanine Board Kit (P07991-B21)”. Half the advertised slots are a part number. The DL580 G5 did the same a generation earlier: its own memory configuration table reads “Maximum (Without Memory Expansion Boards Option) 128 GB” against a headline of 256 GB.
Slots per channel, which is a board decision rather than a processor one. Two is the common number on current servers and three was common on DDR3-era platforms. AMD publishes the SP3 rule as “a maximum of sixteen DIMMs per socket”, and then notes that SP3 boards ship with 8, 12 or 16 slots. The socket permits sixteen. The board in front of you has whatever it has, and a Supermicro X11DPL-i with eight slots reaches its 2 TB ceiling only because 256 GB modules exist, where a sixteen-slot board of the same generation gets there with 128 GB parts at a fraction of the price per gigabyte. For a used buyer that matters more than any other term, because the slot count decides how small the modules are allowed to be, and small modules are where the used market is cheap.
The chassis can rule a module type out entirely
Two ceilings are enforced by sheet metal and airflow rather than by silicon, and neither appears in the memory section of any datasheet.
A PowerEdge R720xd with 3.5-inch drives does not support load-reduced memory at all, for thermal reasons; the same machine with 2.5-inch drives does. The drive cage changes the air path across the DIMM slots, and a load-reduced module with a buffer on every data line dissipates more than a registered one. That single line in a Dell manual is the difference between a 384 GB machine and a 768 GB one.
The DL380 Gen11 does it with slots rather than module types. HPE’s footnote reads “32 DIMMs only with 8SFF or 16SFF, 16 DIMMs maximum with 24SFF”, so ordering the dense drive cage halves the slot count and therefore the ceiling, from 8 TB to 4 TB, before you have chosen a module at all, and a used machine rarely lets you choose the drive cage.
The firmware table is not the silicon, and a QVL maximum is usually a firmware maximum
The memory reference code has to know the die. At every power-on the firmware reads each module’s serial presence detect (SPD), looks up a timing and voltage recipe for that DRAM density and organization, and trains the channel. JEDEC standardizes what is in the SPD, but nothing obliges a firmware to have a recipe for every die that will ever exist. If the reference code has no entry for the die on the module, the machine posts at the wrong capacity, posts at a fraction of the speed, or does not post.
The clearest published case is at the small end. Intel documents DRAM technologies of 1 Gb, 2 Gb and 4 Gb for LGA1155, and nothing else, so a 16 GB DDR3 unbuffered module, built on 8 Gb dies, is outside Intel’s specification even though it seats and plenty of them work on later Ivy Bridge boards. DDR4 16 Gb dies needed firmware updates on boards that had shipped assuming 8 Gb. The 24 Gb DDR5 dies behind the 48 GB and 96 GB modules need a thirteenth- or fourteenth-generation Core processor on LGA1700, where a twelfth-generation part caps at 32 GB modules and 128 GB in total, on the same socket and frequently on the same board.
So a qualified vendor list is a snapshot of the reference code, not a statement about the memory controller. It is revised upward whenever a bigger part is validated, which is why an old PDF understates a machine. It is also why a firmware update sometimes raises a ceiling and sometimes does not: if the constraint was a missing die entry, an update can fix it; if it was routing or rank loading, no firmware will.
The validated-configuration limit is a document, not a mechanism. A PowerEdge T640 has 24 slots and takes a 64 GB registered module, which multiplies out to 1,536 GB, and Dell states 768 GB: the larger configuration simply was not qualified. This is the one to argue with least, because the failure mode of memory the firmware team never trained against is silent corruption rather than a refusal to boot. Vendors also contradict themselves: Dell’s R660 technical guide lists 256 GB modules in its supported memory matrix and stops at 128 GB in its supported DIMMs table, an 8 TB machine or a 4 TB one depending on which table you open.
The SPD itself, and the XMP and EXPO profiles stored in it, are covered in RAM speed, MHz and MT/s. Two of its consequences matter here. A module whose SPD cannot be read is not slow, it is absent: the firmware cannot size it and maps the slot out, so a machine that counts eleven modules out of twelve usually has a seating or presence-detect problem rather than a DRAM problem, and moving the module to another slot separates the two in one reboot. And the rank field reports package ranks, so a 3DS module reports 2 where its own label says 4Rx4 or 8Rx4.
What the firmware thinks, read off the running machine
The firmware’s own opinion is readable with dmidecode -t 16 (the output is in
the running-machine check,
and the wider set of commands is in
how to check what RAM fits).
Number Of Devices is the honest slot count, because it comes from the board’s
own device table rather than a marketing document, and it includes the slots
that belong to an empty socket. Maximum Capacity is the firmware’s opinion and
nothing more. On the example machine it reads 3 TB, which is 24 slots multiplied
by the largest module the firmware has an entry for, and the processors fitted
cap the machine at half of that. Treat it as the board term of the identity,
never as the answer.
The field also has a reporting artifact. SMBIOS stores Maximum Capacity as a 32-bit value in kilobytes, which tops out at 2 TiB; beyond that the field carries the sentinel value 0x80000000 and the true figure sits in a 64-bit Extended Maximum Capacity field, added in SMBIOS 2.7. A machine reporting exactly 2 TB there may be reporting a sentinel rather than a capacity, and a tool that does not read the extended field will print 2 TB for an 8 TB server.
The rank budget, not the slot count
A memory channel does not have a module limit. It has a rank limit, because each rank needs its own chip-select line and the controller has a fixed number of them. Intel’s population rules for its own server boards state it as a hard number: “A maximum of 8 logical ranks can be used on any one channel, as well as a maximum of 10 physical ranks loaded on a channel.” Eight is reached long before the slots run out:
server DDR4 channel, two slots - 8 selectable ranks in total
2 × 64GB 4Rx4 LRDIMM 4 + 4 = 8 ranks budget full, 128GB
2 × 64GB 2Rx4 RDIMM 2 + 2 = 4 ranks budget half, 128GB
2 × 32GB 2Rx4 RDIMM 2 + 2 = 4 ranks budget half, 64GB
2 × 256GB 3DS LRDIMM 2 + 2 = 4 ranks budget half, 512GB
(eight ranks each, four dies deep behind
each of two chip selects)
The first two rows hold identical capacity and load the channel completely differently. The fourth holds four times as much on the same budget, because a 3DS stack hangs several dies behind one chip select; ranks and 3DS modules explains how, and how to read ranks off a label. The consequence here: the largest module on any vendor’s list is nearly always a stacked part, and stacked parts carry population rules of their own.
| Largest module of its class | Construction | What it commits you to |
|---|---|---|
| 64GB DDR4 RDIMM | 2Rx4, monolithic 16Gb |
Fewest restrictions of anything here |
| 64GB DDR4 LRDIMM | 4Rx4, non-3DS |
Whole machine must be LRDIMM |
| 128GB DDR4 LRDIMM | 4Rx4 non-3DS, or 2-high 3DS |
LRDIMM, and the two builds are not interchangeable |
| 256GB DDR4 LRDIMM | 8Rx4, 4-high 3DS |
LRDIMM and 3DS throughout |
| 96GB DDR5 RDIMM | 2Rx4 on 24Gb dies |
A processor generation whose tables list 24Gb dies |
| 256GB DDR5 RDIMM | 8Rx4, 4-high 3DS |
3DS throughout; DDR5 server tables list no LRDIMM at all |
| 512GB DDR5 RDIMM | 2S8Rx4, 8-high 3DS |
Listed by AMD for EPYC 9004 as pending ecosystem enablement |
On DDR3-era platforms Intel’s second number, the physical rank limit, is the one that stops you. A PowerEdge R620 takes “up to two quad-rank RDIMMs per channel” and Dell’s manual prints the price: those modules run 1333 MT/s at one per channel and 1066 at two, and the third slot of a three-slot channel is closed to them entirely: only single- and dual-rank parts can fill it, and fitting one there caps the whole system at 1333.
Module type is a whole-machine decision, and DDR5 took one option away
Four module types matter for capacity. What separates them mechanically is the subject of RDIMM, UDIMM and LRDIMM; here is what each does to the ceiling.
Unbuffered modules cap lowest and cap hardest, because the address and command lines of every module hang directly off the controller. A PowerEdge R610 supports “up to 192 GB of RDIMM memory (twelve 16 GB RDIMMs)” and, in the same document, “up to 24 GB of UDIMM memory (twelve 2 GB UDIMMs)”: eight to one, in one machine. An ML350p Gen8 takes 768 GB load-reduced across 24 slots, 384 GB registered across 24, and 128 GB unbuffered across 16.
Registered modules buffer address and command only, which is what makes eight or sixteen slots per socket possible at all, and it is what nearly all second-hand server memory is: registered ECC DDR4 and registered ECC DDR3 are the bulk of the market.
Load-reduced modules buffer the data lines too, which lets a quad-rank module present a single load. An HPE ProLiant DL380 Gen9 takes 768 GB of registered memory and 3,072 GB of load-reduced out of the same 24 slots. A PowerEdge R440 states “up to 512 GB RDIMM and 1 TB LRDIMM” out of sixteen slots. A Supermicro X10DRi-T states 512 GB with registered memory and 2,048 GB with 128 GB 3DS load-reduced parts out of the same sixteen. Same board, same channels, same firmware: the ratio is the module type, and the two types cannot be mixed.
3DS parts stack dies behind one chip select, which is how DDR5 servers reach their top capacities without load-reduced modules at all. AMD’s EPYC 9004 guide lists no LRDIMM and no UDIMM on SP5, only RDIMM and 3DS RDIMM, and the DDR5 server tables from the other vendors read the same way.
The prohibitions extend to stacking. Supermicro’s X11 rules forbid non-3DS and 3DS LRDIMMs together “in the same channel, across different channels, and across different sockets”, and AMD’s EPYC 9004 guide says “Do not mix 3DS and non-3DS memory modules in a 2DPC system.” The decision is taken on the day you buy the first module. MRDIMM, a fifth type, is a speed feature rather than a capacity one, and MRDIMMs are starting to appear in this site’s DDR5 listings.
What the second module per channel costs
Filling slot two doubles the ranks on the channel and the controller answers by slowing down, by an amount that depends on the generation and on the processor’s market segment. Cisco publishes the clearest table for current Intel parts:
| CPU tier | 4th Gen 1DPC | 4th Gen 2DPC | 5th Gen 1DPC | 5th Gen 2DPC |
|---|---|---|---|---|
| Platinum 8 | 4800 | 4400 | 5600 | 4400 |
| Gold 6 | 4800 | 4400 | 5200 | 4400 |
| Gold 5 | 4400 | 4400 | 4800 | 4400 |
| Silver 4 | 4000 | 4000 | 4400 | 4400 |
| Bronze 3 | 4000 | 4000 | 4400 | 4400 |
Supermicro’s X13 guide gives the same 4800/4400 and 5600/4400 ceilings, and HPE states its ML350 Gen11 maximum as “32 x 256 GB RDIMM @ 4400MT/s at 2 DPC” with both processor generations. At two modules per channel no current Xeon exceeds 4400 MT/s, and Silver and Bronze parts lose nothing to the second module (4000 on 4th Gen, 4400 on 5th), so DDR5-5600 modules in a fully populated machine run about a fifth below their grade:
(5600 - 4400) ÷ 5600 = 0.214 = 21.4 percent off the data rate
Bandwidth scales directly with the data rate, so on an eight-channel socket:
8 channels × 5600 MT/s × 8 B = 358.4 GB/s 1DPC, half the slots empty
8 channels × 4400 MT/s × 8 B = 281.6 GB/s 2DPC, every slot full
Doubling the capacity costs 21 percent of the bandwidth, which is a trade most people would take and almost nobody is told they are making.
DDR4 is messier, and the vendors disagree. HPE’s DL580 Gen10 table derates registered memory from 2933 at 1DPC to 2666 at 2DPC while leaving load-reduced memory at 2933, because the buffering buys back what the extra ranks cost; Supermicro’s X11 guide, covering the same processors, lists 2933 at both for every module type. Assume the pessimistic figure when shopping. AMD’s DDR4 platforms derate consistently:
| Processor | 1DPC | 2DPC | Stated by |
|---|---|---|---|
| EPYC 7001 (Naples) | 2666 | 2133 | AMD |
| EPYC 7002 (Rome) | 2933 | 2666 | HPE, DL385 Gen10 |
| EPYC 7003 (Milan) | 3200 | 2933 | HPE, DL385 Gen10 Plus v2 |
The Naples row is the one to notice: filling every slot on a first-generation EPYC machine costs a fifth of the memory clock, though that 2DPC figure comes from a secondary source, as AMD has retired its Naples-era population guideline from amd.com. On SP5, AMD’s population guide tabulates the first DIMM per channel only, so it gives no data rate for a fully populated twenty-four-DIMM socket. Read the configured speed off a running machine rather than trusting any table. The board matters too: an HPE ProLiant DL385 Gen10 with EPYC 7002 processors tops out at DDR4-2933 in HPE’s tables, and the DL385 Gen10 Plus takes the same processors at 3200.
Population rules, interleaving, and the configuration that costs two thirds of the bandwidth
This is the failure that shows up as no smaller number anywhere. The capacity is right, the modules are right, the machine boots, and it runs at a third of the speed it should.
Lenovo measured STREAM Triad across every population of a two-socket EPYC 7002/7003 machine, all at the same clock, as a fraction of the fully populated figure:
| DIMMs per socket | Pattern | Interleave sets | Bandwidth |
|---|---|---|---|
| 1 | one channel | 1 | 14% |
| 2 | one channel pair | 1 | 28% |
| 4 | two channel pairs | 1 | 54% |
| 6 | six channels (7003 only) | 1 | 71% |
| 8 | all eight channels, 1DPC | 1 | 100% |
| 12 | six channels at 2DPC (7003 only) | 1 | 71% |
| 12 | four channels at 2DPC, four at 1DPC | 2 | 35% |
| 16 | all eight channels, 2DPC | 1 | 100% |
Read the two twelve-module rows together. Going from eight modules to twelve can cost two thirds of the machine’s memory bandwidth, because twelve cannot form one interleave set: the controller builds two four-channel sets instead of one eight-channel one. That is the configuration you land on by adding four modules to a machine that already worked.
Only 1, 2, 4, 6, 8, 12 and 16 modules per socket are sensible on that platform, and only 8 and 16 reach full bandwidth with identical modules. Genoa widened the rule rather than dropping it: EPYC 9004 forms interleave sets of 2, 4, 6, 8, 10 or 12 channels, and to form one “all channels are required to have the same DIMM type, the same total memory capacity and ranks.”
Mixing two capacities is cheaper than it looks, provided the balance holds. Lenovo measured about 3 percent bandwidth loss for a near-balanced configuration: two capacities, every channel carrying the same total capacity, and an even total rank count, such as eight 64 GB plus eight 32 GB modules per socket for 768 GB. Balance is per channel, not per socket: the same two module sizes arranged so that four channels carry 96 GB and four carry 64 GB (twelve modules) is the 35 percent row.
Reading a vendor population table
A row is a set of slots, not the first n slots: on Supermicro’s six-slot X11UP board, four modules go in A1, B1, D1 and E1, skipping C1, so that each of the two memory controllers gets two channels rather than one getting three. A row marked not recommended will boot with poor bandwidth; that is where odd module counts live. Slot color encodes order rather than capability: white or blue is first, and it is the slot farther from the processor. And the footnotes carry the rules the grid cannot express: which processor generations a row applies to, which module types it excludes, whether a capacity is one-per-channel only.
Where rank counts can be mixed at all, the heavier module goes in that first slot. Beyond that the rules are per-vendor and contradict each other - AMD’s EPYC 9004 guide forbids x4 and x8 modules in one channel, Supermicro’s X11 guide allows it. Cisco’s M7 matrix allows its 48 GB modules only at one per channel, and its footnote reads “When mixing two different DIMM densities, all 8 channels per CPU must be populated.” So read your own platform’s rules; the general mixing rules are in ranks and 3DS modules.
Capacity on the wrong socket is not the same capacity
On a machine with more than one processor, memory is attached per socket. Cores
on socket 0 reach socket 0’s memory directly and socket 1’s across the
interconnect, at higher latency and lower bandwidth. numactl -H reports each
node’s size and a distance matrix from the firmware’s ACPI tables; on the
example machine local memory reads 10 and remote 21, so remote memory costs
roughly twice what local memory costs.
The capacity consequence is a rule about module counts. Buy in multiples of the channel count times the socket count, because anything else leaves one node smaller than the other, and a process that outgrows its local memory starts allocating remotely without telling anyone. A two-socket machine with all its memory on one socket is the extreme case: half the cores reach every byte over the interconnect, and the machine performs worse than the same memory in a single-socket box.
Mirroring, sparing and lockstep spend capacity on reliability
Three firmware settings can take memory away after the machine has counted it. All three live in the BIOS menu normally called memory RAS or memory operating mode, where the default on nearly every machine is independent mode, which costs nothing.
Mirroring halves it. In full memory mirroring every write goes to two channels and the reported capacity is half the installed capacity: a 768 GB machine reports 384 GB. What that buys is that an uncorrectable error on one channel is served from the other rather than halting the machine.
Address range mirroring changes the trade from all to some. The firmware
mirrors only a requested range, and Linux’s kernelcore=mirror boot parameter
places kernel allocations inside it, so a few gigabytes of mirror protect the
part whose corruption takes the machine down.
Sparing reserves ranks, and the cost depends on the modules. Rank sparing holds one or two ranks per channel in reserve; when a rank accumulates correctable errors past a threshold, its contents are copied into the spare and it is retired. The reserved rank is not addressable, so the arithmetic is:
usable = installed × (R - S) ÷ R
R = ranks per channel
S = spare ranks per channel
It reproduces Supermicro’s own published figures exactly:
64 GB, R = 4, S = 1 64 × 3 ÷ 4 = 48 GB matches
64 GB, R = 4, S = 2 64 × 2 ÷ 4 = 32 GB matches
16 GB, R = 2, S = 1 16 × 1 ÷ 2 = 8 GB matches
The cost of sparing is a quarter on a quad-rank channel and a half on a dual-rank one, which is the opposite of the intuition that more ranks means more overhead. A single-rank module cannot support sparing at all, because retiring its only rank retires the module. Intel’s own board rules put rank sparing behind “at least 2 SR or DR DIMM installed, or at least one QR DIMM installed, on each populated channel”.
Lockstep costs bandwidth, not capacity, and this is the one people get backwards. Two channels run as one wider interface, so nothing is reserved, but achievable bandwidth falls roughly in half. Intel replaced lockstep on Xeon Scalable with ADDDC, adaptive double device data correction, which Lenovo documents as working “with x4-based memory DIMMs” and requiring “two DIMM ranks per channel”, plus a Gold or Platinum processor. A channel holding one single-rank x8 module can enable none of these modes, which matters before buying the cheapest modules for a machine whose whole point is staying up.
The RAS mode is not in SMBIOS. It is in the firmware setup screen, and on a machine bought second-hand it is whatever the previous owner left it at. A server that reports exactly half the memory you installed is almost always mirrored rather than broken, and that is a five-minute fix rather than a return.
What a refusal looks like, and how to read one
Memory training happens before there is any display output, so a machine that will not accept a module says so in one of three ways.
It does not POST at all. The firmware failed to train a channel and stopped, which on a server surfaces as a fault light beside a DIMM slot, a POST code, or a beep pattern on older hardware. Moving the module to a slot on a different controller separates a bad module from a bad slot in one reboot.
It POSTs with the module mapped out. Everything works and the capacity is short by exactly one module’s worth. SMBIOS still describes the module, because the firmware built those structures from the presence detect, while the kernel does not count it:
$ sudo dmidecode -t 17 | grep -c "Size: 32 GB"
12
$ grep MemTotal /proc/meminfo
MemTotal: 362251776 kB
Twelve modules of 32 GB described and eleven modules’ worth counted. A gap of exactly one module is a mapped-out module, not a memory hole, and the firmware normally logged why.
It POSTs at a lower speed than the modules are graded for. Besides the
two-per-channel derate, one module with a lower top grade drags the whole
channel, or machine, down to it; Configured Memory Speed per module in
dmidecode -t 17 shows which.
The reason lives in the logs, and on a server they are out-of-band rather than in the operating system:
$ sudo ipmitool sel list | grep -i memory
Correctable error thresholds also retire memory at runtime, which is why a machine can lose a rank’s worth of capacity months after it was last touched. On a used machine, an event log that has already been cleared is itself information about the seller. Fit everything on arrival, inside the returns window, and read the count before you read anything else. A module that maps out on the bench in week one is a return; the same module discovered in month four is a loss. The same window argument runs through buying used RAM on eBay.
Installed is not usable, and the gap is not a rounding error
Even with every ceiling satisfied, the operating system reports less than the modules hold. The low four gigabytes of physical address space are shared with memory-mapped I/O - PCIe configuration space, device apertures, the local APIC, firmware reserved regions - and the firmware remaps the displaced DRAM above the four gigabyte line, which is what the BIOS setting called memory remap or memory hole remapping does. What it cannot reclaim, plus the ACPI tables and any crash-kernel reservation, is the residue. On the example machine’s twelve 32 GB modules, 384 GiB:
384 GiB × 1,048,576 KiB = 402,653,184 KiB installed
395,806,208 KiB reported by the kernel
difference = 6,846,976 KiB = 6.53 GiB = 1.70 percent
Its size is a property of your firmware and your kernel command line, not a
constant, so the 1.7 percent above is an illustration and your own machine’s
dmesg e820 map is the authority. Reported memory is always less than installed
memory, never more, and a gap of one or two percent on a large server is normal.
It stops being normal when the gap is a round number, which is what
the table at the top
decodes.
Old ceilings: the address width, 32-bit systems and Windows editions
The processor’s address width never binds on 64-bit hardware. lscpu
reports it as Address sizes, and the example machine’s Gold 6130 reads 46 bits
physical. Forty-six bits is 64 tebibytes, which is more than forty times the
largest DRAM configuration the example machine can reach, and newer parts
widened it to 52 bits. The memory controller has lived on the processor since AMD’s K8 in
2003 and Intel’s Nehalem in 2008, so the old advice that “the chipset caps the
memory” is wrong on hardware from 2009 onward.
A 32-bit operating system cannot use memory above 4 GiB, and usually cannot use all of the first 4 GiB either, because the space below the line is shared with memory-mapped I/O: a 32-bit install on a machine with 8 GB fitted typically reports somewhere between 3.2 and 3.5 GB. 32-bit Windows client editions cap at 4 GB regardless of Physical Address Extension, a license decision rather than an architectural one.
Windows editions still cap memory. Microsoft publishes per-edition physical memory limits, and the ones that bite a home lab are the client editions: Windows 11 Home stops at 128 GB and Windows 11 Pro at 2 TB. A second-hand two-socket server with 192 GB fitted, running the edition that came with the desktop it replaced, will report 128 GB and no error.
On Linux, look for a leftover. The kernel’s own limits are 64 TiB with
four-level paging and 4 PiB with five, but a mem= parameter left on the kernel
command line from some past debugging session truncates physical memory
silently and survives reboots:
$ cat /proc/cmdline
BOOT_IMAGE=/vmlinuz-6.8.0 root=UUID=... ro quiet mem=64G
That trailing mem=64G is the whole cause, on a machine with 384 GB fitted, and
nothing else on the system will mention it. On older firmware, also check that
the memory remap or above 4G decoding option exists and is enabled;
without it the DRAM displaced by the I/O hole is simply lost.
Working the real ceiling out of three documents and the running machine
Every ceiling above is one term. Here is the order to evaluate them in, chosen so that the cheapest document to read eliminates the most wrong answers.
Document one: the processor’s own specification. Intel’s ARK entry or the family datasheet, AMD’s product page or datasheet. It answers the per-socket maximum, the channel count, the maximum data rate, and the DRAM die technologies the controller supports. Multiply the per-socket figure by the sockets actually fitted, not by the sockets present.
Document two: the system or board document. QuickSpecs for HPE, the technical guide for Dell, the motherboard manual for Supermicro, the product guide for Lenovo. It answers the slot count, the per-module-type ceilings and the chassis conditions, and the conditions are in the footnotes: how many processors the slot count assumes, which drive cage, whether the largest module is registered or load-reduced. This site’s compatibility pages record the vendor’s own maximum together with its conditions, per vendor for Dell, HPE, Lenovo and Supermicro.
One check belongs here. If a machine’s headline capacity is more than slots multiplied by the largest DRAM module in its own supported list, the difference is persistent memory, not DRAM. Against the PowerEdge R650 Dell’s comparison table prints “Up to 16 Intel Persistent Memory 200 series (BPS) slots, 12 TB max”, while the adjacent R660 column’s 8 TB is DRAM only. Those modules are generation-locked (the 100 series pairs with second-generation Xeon Scalable, the 200 series with third), each one takes a DRAM slot, the population rules require DRAM alongside them in a fixed ratio, and Intel discontinued the line, so supply is second-hand, and a module a previous owner locked with a passphrase arrives unusable until unlocked or securely erased.
Document three: the memory population rules. A separate document on every platform worth the name, and the one nobody opens. It answers the rank budget, the mixing rules, whether 3DS parts are supported, the speed by population, and which capacities are one-module-per-channel only.
Then the machine itself, which settles what the documents cannot:
$ sudo dmidecode -t 16 | grep -E "Number Of Devices|Maximum Capacity"
Maximum Capacity: 3 TB
Number Of Devices: 24
$ sudo dmidecode -t 17 | grep -E "Locator:|Size:|Rank:|Configured Memory Speed:" |
grep -v "No Module Installed" | head -8
Locator: DIMM_A1
Size: 32 GB
Rank: 2
Configured Memory Speed: 2666 MT/s
Locator: DIMM_B1
Size: 32 GB
Rank: 2
Configured Memory Speed: 2666 MT/s
$ lscpu | grep -E "Socket|NUMA node\(s\)"
Socket(s): 2
NUMA node(s): 2
Number Of Devices is the true slot count including the empty socket’s share.
Rank is the package rank, which is what the chip-select budget cares about.
Configured Memory Speed against the module’s own Speed field is the
downshift, measured rather than predicted. And NUMA node(s) matching
Socket(s) confirms that both processors are present and that the slots wired
to the second one are live.
The answer is the smallest figure those four sources give, and on a second-hand machine it is usually the processor or the module type, not the slot count.
Four machines, worked
HPE ProLiant DL380 Gen11. Headline 8 TB, from 32 × 256 GB DDR5 RDIMMs, octal-rank 3DS parts you will not find loose. The 24SFF chassis halves that to 4 TB but keeps one module per channel across its sixteen slots, which is full 1DPC speed; the 8SFF machine reaches 8 TB at 4400 MT/s in HPE’s own speed table. The dense chassis costs capacity; the dense population costs clock.
HPE ProLiant DL580 Gen10, four sockets, 48 slots. Three maxima out of one chassis: 1.5 TB as 24 × 64 GB RDIMM at 2933 (1DPC), 3 TB as 48 × 64 GB RDIMM at 2666 (2DPC), and 6 TB as 48 × 128 GB LRDIMM at 2933 (2DPC). Load-reduced memory doubles the capacity and keeps the clock, which is the case where paying the LRDIMM premium is unambiguously right. Above a terabyte per socket you also need M- or L-suffix processors, and the mezzanine kit before 48 slots exist at all.
A second-hand two-socket EPYC 7002 box, 32 slots, 4 TB on the spec sheet. That 4 TB is not AMD’s number:
board figure 32 slots × 128 GB LRDIMM = 4,096 GB
AMD's figure 2 sockets × 4 TB = 8,192 GB with 256 GB modules
The board’s stated maximum is half the socket’s. Now three routes to roughly a terabyte. Sixteen 64 GB modules, eight per socket at one per channel, run at 2933 and 100 percent of peak bandwidth. Thirty-two 32 GB modules reach the same terabyte at 2666, also 100 percent, with every slot spent. Twenty-four 32 GB modules, the configuration you land on by adding sticks to an eight-module machine, is 768 GB at 35 percent, because twelve modules across eight channels cannot form a single interleave set and Rome has no six-channel mode to fall back on. The cheapest-looking purchase is the one that halves the machine.
The example machine, taken as far as it goes. Two Gold 6130 processors, 24 slots, twelve 32 GB dual-rank registered modules fitted, 384 GB reported.
where it is now 12 × 32 GB = 384 GB, 1DPC, full interleave
fill the empty slots 24 × 32 GB = 768 GB, 2DPC, full interleave
same slots, 64 GB 24 × 64 GB = 1,536 GB, at the processor ceiling exactly
same slots, 128 GB 24 × 128 GB = 3,072 GB, refused: 2 × 768 GB = 1,536 GB
The boundary is the processor rather than anything you can see in the chassis. 24 × 64 GB lands exactly on the 1,536 GB ceiling, so the largest useful module for this machine is 64 GB even though the slots would take something bigger, and 128 GB modules buy capacity the processors will refuse.
The cheapest route to a capacity is usually more modules, not bigger ones
On the second-hand market the price per gigabyte rises with module capacity, and steeply at the top of each generation. The reason is supply: the largest module of a generation was expensive when new, was bought in small numbers, is usually a stacked part, and is retired later than the mainstream capacities that filled a decade of two-socket servers and arrive on the used market by the pallet.
You can check the direction on this site. Open DDR4 16GB, DDR4 32GB and DDR4 64GB, sort each by price per gigabyte, and compare the cheapest row of each. The order is normally smallest first, and the gap between the mainstream capacity and the top capacity is usually a multiple rather than a margin. On DDR3, between 8GB, 16GB and 32GB, it is starker still. Prices and inventory move every week, so run the comparison rather than trust a quoted figure. A machine’s own page runs it for you: the Cheapest way to fill it card on, say, the PowerEdge R730’s page prices each module size across that machine’s slots, cheapest per gigabyte first, at the latest prices captured.
So the arithmetic for a target capacity runs the other way from the way people usually do it. Take a sixteen-slot two-socket DDR4 server, four channels per socket at two slots each, and a target of 512 GB:
route A 16 × 32 GB 2DPC, 4 ranks per channel, derated clock, zero slots left
route B 8 × 64 GB 1DPC, 2 ranks per channel, full clock, eight slots free
route C 4 × 128 GB two channels of four populated per socket
Route C is wrong for a reason that has nothing to do with money: two modules per socket populate only two of its four channels, so by the channel arithmetic each socket runs on about half its bandwidth. Between A and B, the cost difference is the per-gigabyte gap between 32 GB and 64 GB modules on the day, and the performance difference is one speed bin against eight free slots. Route A is normally cheaper and route B is normally faster and upgradable, and neither is the obvious answer.
The “more modules is cheaper” rule has two limits. The first is the rank budget: sixteen dual-rank modules on an eight-channel socket is four ranks per channel, comfortably inside an eight-rank budget, while sixteen quad-rank modules is eight, the budget exactly, and on many boards also a speed bin lower and a module type commitment for the whole machine.
The second is the empty socket, and it is the biggest single lever on a used machine. Half the slots on a two-socket board are wired to the second processor, so a single-processor machine cannot use route A at all. On a platform old enough to be worth buying second-hand, the second processor is frequently cheaper than the four modules it unlocks the slots for, and it doubles the channel count and the bandwidth at the same time. Price the processor before you price the bigger modules, and use the processor index to confirm the pair you are matching is a pair.
Compare whole generations as well as capacities, because a DDR3 server that is cheap to fill can be a better machine than a DDR4 server that is not: the DDR3 and DDR4 pages sort the same way, and the all-generations price table puts them side by side.
How this site records each maximum
The vendor’s maximum is the largest configuration somebody validated, not the largest that works. Which die densities a firmware revision knows is not published, so nobody can say in advance whether an update will lift a ceiling. AMD’s SP5 documentation gives no 2DPC data rate. And per-SKU ceilings are often absent from the machine’s own documents: Lenovo’s SR650 V2 specification says only that “the operating speed and total memory capacity depend on the processor model and UEFI settings”, so its 8 TB is recorded as the top-of-range stated maximum, not a promise for every processor. Each maximum this site records comes from a vendor document, and where two vendor statements differ, both are recorded.
The capacity on the marketing page assumes the best configuration of each part. The capacity you can reach is the smallest of eleven numbers, and every one of them is something you can look up before the modules arrive rather than discover after.