In this guide: 18 sections
- Single or dual rank: the short answer
- Reading the label: 1Rx8, 2Rx8, 2Rx4 and 2S2Rx4
- What rank changes on a laptop or desktop
- The mixing rules ranks impose
- What to check on a listing page
- Reading rank off a module you already own
- A rank is a chip select, and everything else follows
- Capacity is die density, device width and rank count in one equation
- What a second rank actually buys
- Single, dual and quad rank, and why quad rank disappeared
- Why more ranks per channel lowers the speed
- 3DS: more dies behind one chip select
- 3DS RDIMM or LRDIMM: two answers to one problem
- Where the ranks sit on DDR5
- Which machines take which stacking
- What ranks cost in power and in boot time
- The older generations use the same grammar
- What to confirm beyond the listing
A rank is one full-width set of memory chips that the processor reads and writes
together, so 1Rx8 on a stick means one rank of x8 chips and 2Rx8 means two.
On a laptop or desktop, rank is a tie-breaker: buy the size and speed you need,
in two sticks rather than four, and take the rank that comes with that size.
Tests put dual rank up to 7% ahead in applications on DDR4 and anywhere from
almost nothing to 11% ahead in games, and on DDR5 Igor’s Lab found the two
comparable, with single rank clocking higher. Rank changes what you do in two
cases: four sticks in a desktop,
where the rated speed usually falls, often further with dual rank, and adding to a stick
you own, where you match the label if you can.
3DS means each chip is several dies stacked in one package and wired together
by through-silicon vias, and 2S2Rx4 is a 3DS module with two ranks of two-die
stacks. You meet it on server memory, where the controller’s rank budget decides
what fits, which is why four different 64GB DDR4 server modules exist, run at
different speeds and do not all fit the same machine, although their listing
titles read the same.
Single or dual rank: the short answer
On a laptop or desktop rank is a tie-breaker, and on a server it is a constraint.
| Your situation | What to buy | Why |
|---|---|---|
| Two sticks for a desktop or laptop | The size and speed you need. If two otherwise equal DDR4 sticks differ, 2Rx8 |
The size mostly sets the rank, and the tests put the gain at a few percent, rarely more |
| One large stick or two smaller, same total | Two smaller, one per channel | A second channel doubles the width of the bus; a second rank does not widen it at all |
| Four sticks in a desktop | Two larger sticks, if they reach your total | On most platforms four sticks are rated well below two, and on many four dual-rank sticks lowest of all |
| Adding to a stick you own | The same size and rank where you can get it, or a new pair | A mix usually runs, and sticks sharing a channel lose Intel’s top-speed promise |
| A server, one module per channel | Dual rank, 2Rx4 |
Almost nothing derates, and the second rank lets the controller refresh one rank while it reads the other |
| A server, two modules per channel | Whatever the board’s population table rates fastest | Rank count picks the speed bin |
| A server at its top capacity | The construction the processor lists, 3DS or load-reduced | Support for the two is listed separately, and neither implies the other |
| Adding to a server | The same type, capacity and rank count as what is there, or a full replacement | Channels with mismatched ranks interleave less, and nothing warns you |
| You want Chipkill (SDDC) | x4 devices: 1Rx4, 2Rx4 or a 3DS x4 part |
SDDC requires x4-based DIMMs, whatever the rank count |
| An EPYC 9004 server at two DIMMs per channel | All 3DS or no 3DS | AMD does not allow 3DS and non-3DS modules to be mixed in that population |
The rule underneath is that a channel supports a limited number of ranks, not a limited number of modules. Intel’s Core Ultra 200S allows two ranks per channel with one DIMM and four with two; Intel’s S2600WT server board allows eight. What that budget does to a whole server’s ceiling is in why your server won’t take its maximum RAM.
Reading the label: 1Rx8, 2Rx8, 2Rx4 and 2S2Rx4
The notation is nRxW: rank count, the letter R, then the width of one DRAM
device. It is printed on the module label, it appears in every serious
compatibility list, and it is absent from most listing titles.
| Label | Ranks | Device width | Devices on the module | Where you see it |
|---|---|---|---|---|
1Rx8 |
1 | x8 | 8, or 9 with ECC | Desktop, laptop, ECC UDIMM, small RDIMMs |
2Rx8 |
2 | x8 | 16, or 18 with ECC | Desktop, laptop, entry server |
1Rx16 |
1 | x16 | 4 | The smallest desktop and laptop sticks |
1Rx4 |
1 | x4 | 18 | Server only |
2Rx4 |
2 | x4 | 36 | The commonest server RDIMM shape |
4Rx4 |
4 | x4 | 72, or 36 dual-die | Quad-rank RDIMM and LRDIMM |
2S2Rx4 |
4 logical, 2 package | x4 | 36 stacked | 3DS |
Kingston’s 8GB DDR5 laptop stick KVR56S46BS6-8 (February 27, 2023) is a 1Rx16
part, four chips, and x16 chips carry half the banks of x8
ones. Some
makers state rank in the part number: Kingston ValueRAM puts an S, D or Q before the width, so
KVR32S22S8/16 is 1Rx8.
Two spellings catch people out. An x16 device cannot build an ECC module, because
72 does not divide by 16, and Micron’s DDR4 RDIMM specification allows x4 and x8
only - so 1Rx16 next to “ECC REG” in a listing title is a typing error, not a
rare part. And a stray D, as in 4DRx4, is the dual-die spelling some LRDIMM
vendors use for a quad-rank x4 module; hundreds of titles in this site’s
listings write it that way.
The stacked form, which you meet on server memory, counts twice over. The number
before the S is package ranks: how many chip selects the module consumes.
The number before the R is logical ranks inside each package rank: how many
dies are stacked behind each of those chip selects. So 2S2Rx4 is two package
ranks with two dies each, four logical ranks in total, and AMD’s capacity ladder
for EPYC 9004, where 2S2Rx4 is 128GB, 2S4Rx4
256GB and 2S8Rx4 512GB, only works if you multiply the two numbers together.
A package rank costs a chip select; a logical rank does not.
Ask for the label, not the heatspreader
The organization string is the one fact about a module that cannot be derived from anything else visible, so ask the seller for a photograph of the label. On a laptop stick, a plain desktop stick or a server part it is a paper sticker on the PCB, carrying the part number, the organization string, the JEDEC module designation and often the raw card revision. A desktop kit under a heatspreader is harder: Igor’s Lab (January 6, 2021) says not every maker publishes rank, a stick’s appearance will not reliably tell you, and before buying your options are the maker’s site, its support or an owner’s reading.
The designation, such as PC4-3200AA-UB2-11 on a desktop stick,
PC5-5600B-SB0-1010-XT on a laptop stick or PC4-2666V-RB2-11 on a server
module, carries the generation in PC4, the data rate in the digits, a latency
grade in the letters joined to them, and then, after the second hyphen, the
module type: U unbuffered, S SODIMM, R registered, L load-reduced, E
unbuffered ECC, the letter that decides whether the module will POST in your
machine. RB2 is raw card B, revision 2. A photograph of a heatspreader with a
vendor logo on it has shown you nothing.
What rank changes on a laptop or desktop
You rarely get to choose, because the size mostly sets the rank. Kingston’s
datasheets show the pattern: its DDR5-6000 CL30 kits are 1Rx8 at 16GB a stick and
2Rx8 at 32GB (KF560C30BBEK2-32 and -64, February 15, 2024), and its DDR5-5600
laptop sticks split the same way (KF556S40IB-16 and -32, May 23, 2024). DDR4 is
looser. A 16GB DDR4-3200 laptop stick comes both ways: Kingston’s KVR32S22S8/16
is 1Rx8 (July 21, 2020) and KVR32S22D8/16 is 2Rx8 (May 10, 2019), and Igor’s
Lab (January 6, 2021) reports Crucial moving 16GB Ballistix sticks from two ranks to
one once denser chips got cheaper. The listings agree:
| Listings stating one rank / two ranks | DDR4 desktop | DDR4 laptop | DDR5 desktop | DDR5 laptop |
|---|---|---|---|---|
| 8GB sticks | 931 / 169 | 2,029 / 283 | 63 / 1 | 164 / 2 |
| 16GB sticks | 184 / 988 | 362 / 1,728 | 188 / 4 | 316 / 43 |
| 32GB sticks | 1 / 306 | 0 / 578 | 4 / 171 | 8 / 254 |
Those are this site’s tables for eBay US on November 2, 2026, and about one listing in sixteen states a rank. A 16GB stick is usually two ranks on DDR4 and one on DDR5; 8GB is usually one and 32GB two.
The tests disagree on the size of the gain:
| Test | Machine | What dual rank changed |
|---|---|---|
| Tom’s Hardware, February 20, 2021 | Laptop: Ryzen 7 4800H, RTX 2060, DDR4-3200 | 2 x 16GB against 2 x 8GB: 3.5% overall, under 1% in games |
| Tom’s Hardware, March 15, 2021 | Desktop: Ryzen 9 5900X, DDR4 | Up to 7% in applications, “almost zero” in games |
| Igor’s Lab, January 6, 2021 | Desktop: Ryzen 9 5950X, RTX 3090, DDR4-3800 at fixed timings | Cyberpunk 2077 at 1080p: about 11% on average and almost 16% in the 1% lows, less at 1440p |
| Igor’s Lab, December 16, 2021 | Desktop: Core i9-12900K, DDR4-4000 and DDR5-5600 | “Measurable”, about 3 fps at most in two games, and DDR4 dual rank trailed on average fps. Given dual rank’s lower clocks, the author expects the net best of each to be “pretty identical” |
| Igor’s Lab, May 7, 2025 | Desktop: Ryzen 7 9800X3D, DDR5 | Single rank “can be clocked higher” and is “comparable” |
The gain is largest when the processor is the limit, as with a very fast graphics card at 1080p. Part of it is capacity, because Tom’s Hardware’s dual-rank sets also held twice the memory, and DDR5 has less to gain. The tests above cover desktops and one DDR4 laptop with a dedicated graphics card.
On an AMD or Intel desktop board
At two sticks, rank barely touches what the processor maker promises. AMD’s page for the Ryzen 7 9800X3D, read November 2, 2026, prints 5600 for either rank at two sticks and 3600 for either at four. Intel’s 13th Gen is the exception at two sticks, with dual rank a step lower. Four dual-rank sticks are rated below four single-rank ones on Intel with DDR5 and on Ryzen 5000, though not on AM5. Two sticks against four has every figure. So:
- Pick the kit for your platform first, then read its rank if the price is level.
- On DDR5, for 64GB or more, two
2Rx8sticks beat four1Rx8ones. Igor’s Lab’s rule on Ryzen 9000 X3D is that two large modules are better than four small ones, and dual rank does not rule out a fast kit: Kingston’sKF560C30BBEK2-64is2Rx8at DDR5-6000 CL30. - Above DDR5-6000, single rank has the margin. MSI’s manual for the MAG B650 Tomahawk WiFi lists overclocks to 7600+ with two single-rank sticks and 6400+ with two dual-rank ones, and the kit guide says how to read that.
On a laptop
Fill both channels first. In Tom’s Hardware’s laptop test, 2 x 8GB, two ranks in all, beat one dual-rank 16GB stick by 10.9% overall and 7.7% in games, and what one stick costs on integrated graphics is larger. After that the slots and the maker’s maximum decide what you buy, and the rank comes along. Tom’s Hardware’s advice was to prefer dual rank and to read the spec sheet, because some 16GB DDR4 sticks are single rank. Can you upgrade the RAM in your laptop comes first.
The mixing rules ranks impose
On a laptop or desktop a mix of ranks usually runs, and the catch, where sticks share a channel, is speed. Intel’s datasheets separate two cases.
- One stick per channel. Dual-channel mode goes by capacity. Intel’s 12th Gen
datasheet (Document 655258, Revision 011, May 2025) uses it “with the total
amount of memory in each channel being the same” and sets no rank condition, so
a 16GB
1Rx8beside a 16GB2Rx8qualifies on that text. Unequal sizes split into two zones. - Two sticks in a channel, as with four in a desktop. Intel’s top speed holds “when same DIMM part number populated Within channel”, and “Frequency is not guaranteed when mix DIMM’s populated”. Its 13th and 14th Gen datasheet repeats that (Document 743844, Revision 015, May 2025).
That is Intel’s published guidance on a mix, so match the rank where you can. If you cannot, expect it to run, and test it while you can still return it. The mixing table and adding to what you have go further.
The rules on a server
Servers are stricter, and a bargain can turn into a machine that will not boot. Four families of rule, from the most absolute down.
Rules that are physical. Registered and unbuffered modules do not mix, nor ECC and non-ECC on most platforms that want ECC. Those live in RDIMM, UDIMM and LRDIMM.
Rules that vendors state as absolutes and do not agree on. AMD’s EPYC 9004 guide says “Do not mix x4 and x8 DIMMs within a memory channel.” Supermicro’s X11 guide, describing Intel platforms, says “x4 and x8 DIMMs can be mixed in the same channel.” Both are correct about their own platforms. Read the document for the board in front of you, not the one you remember.
Rules about order. Where mixing rank counts is allowed at all, the near-universal instruction, in Dell’s and HPE’s guidelines alike, is to populate the slot furthest from the processor first and to put the module with the most ranks in it, because the channel is tuned around the far module’s terminators. Reverse it and the machine may POST, run, and then fail memory tests under load.
Rules about symmetry. These are the ones people break by accident, because nothing refuses to boot. AMD’s EPYC 9004 guide states that channel interleaving “requires all channels to use the same DIMM type, total memory capacity, and ranks”. A server with one dual-rank channel among single-rank ones of the same capacity interleaves across fewer channels rather than complaining. You lose bandwidth silently. That is why adding a single module to a balanced server is usually the worst upgrade available.
Stacking has its own symmetry rule, absolute on the platform that states it: 3DS and non-3DS modules cannot be mixed in a two-DIMM-per-channel EPYC 9004 system.
What to check on a listing page
- Start from the right table. Desktop RAM prices, Laptop RAM prices and Server RAM prices rank every generation for that kind of computer. DDR4 server memory and DDR4 registered ECC narrow a server’s to DDR4.
- Choose by size and speed, then read the rank. Most titles leave it out. If it matters to you, ask for a photograph of the label.
- Prefer two sticks to four, and check what four cost before buying a kit you plan to double later.
- Adding to a stick you own? Compare labels. Same size and rank where you can get them, or replace the pair.
- Check the machine before the module. RAM by processor gives a processor’s memory type, speed, channels and ceiling, and the laptop or desktop maker’s document settles the rest; for a server, server models gives the fit. RAM by part number gathers what the listings give for each part number.
- Compare price per gigabyte across the whole generation. All RAM prices ranks everything the site has seen and Trends shows how prices have moved.
- On a server, count ranks against the channel, not modules against slots. Work out the machine’s rank budget and subtract what is already in it before looking at capacities. With one module per channel, prefer more ranks; with two, rank count picks the speed bin, so read the board’s population table first.
- At the top capacities, buy the construction the processor lists. Divide the platform’s headline capacity by its slot count to see which module size the ceiling was written against; if that module is stacked, a non-stacked one of the same capacity will not get you there. 64GB DDR4 is where this bites first.
Reading rank off a module you already own
Read the sticker if you can see it: 1Rx8 or 2Rx8 is printed beside the size.
If the machine is closed or the stick wears a heatspreader, ask the machine.
On Windows, one line of PowerShell prints what the firmware reports:
Get-CimInstance Win32_PhysicalMemory | Select-Object DeviceLocator, PartNumber, Attributes, ConfiguredClockSpeed
Attributes is the rank. Microsoft’s class reference, read November 2, 2026, says
it “Represents the RANK” on Windows 10 and later, and the SMBIOS specification (DSP0134 version
3.9.0, July 7, 2025) makes 0 mean unknown, so 1 is single rank, 2 is dual and 0
means the firmware left it blank. Task Manager does not show it. CPU-Z, AIDA64 and
HWiNFO read the stick’s own SPD chip, which Igor’s Lab calls the only really
reliable way. Reading what is installed on
Windows
decodes the other fields.
What the Linux tools print
On Linux, the command that always works is dmidecode:
sudo dmidecode -t 17 |
grep -E '^[[:space:]]+(Locator|Size|Type|Speed|Configured (Memory|Clock) Speed|Data Width|Total Width|Part Number|Rank):'
The fit guide prints a full block. Three things in that output are traps.
Rank:is the package rank count, taken from the SPD’s package-rank byte. A 3DS module normally reports 2 there, not the eight logical ranks on its own label: it answers the chip-select question, not the capacity question.- There is no device width field.
Data Width: 64 bitsandTotal Width: 72 bitstell you the module has ECC, and nothing distinguishes x4 from x8. Whether a machine can do single device data correction is on the label, not in dmidecode. Configured Memory SpeedbelowSpeedis the derating table, live.Speedis the module’s bin; the configured figure is what the controller settled on after counting the ranks it found. 2666 and 2400 on the same pair of lines means the population dropped the machine a bin.
decode-dimms, after sudo modprobe ee1004, reads the SPD itself, so it has the
die count, the signal loading and the device width. The catch is access: DDR4 SPD
EEPROMs hang off an I2C bus that a server’s baseboard management controller usually
owns, and DDR5 puts an SPD hub on the module with different tooling. Read the label
when neither tool works, which on a module you have not bought yet is always.
A rank is a chip select, and everything else follows
A module’s data bus is 64 bits wide, 72 with ECC on DDR4 and earlier, 80 on a DDR5 registered module. A rank is however many DRAM devices it takes to cover that width at once. Divide:
non-ECC, x8 devices 64 ÷ 8 = 8 devices per rank
ECC DDR4, x8 devices 72 ÷ 8 = 9 devices per rank
ECC DDR4, x4 devices 72 ÷ 4 = 18 devices per rank
ECC DDR5 RDIMM, x4 80 ÷ 4 = 20 devices per rank (10 per sub-channel)
ECC DDR5 RDIMM, x8 80 ÷ 8 = 10 devices per rank (5 per sub-channel)
Every device in a rank receives the same address and command and contributes
its own slice of the word: on a desktop DDR4 1Rx8 stick a read is eight x8 devices
each handing over eight bits at once. What separates one rank from the next is a
single wire. The chip select, CS_n, is asserted for exactly one rank at a time,
and a device that does not see its chip select asserted ignores the command on the
bus entirely. Extra ranks widen nothing, because one of them already covers the bus. Only one rank per
channel drives the data bus at any instant, so a second rank is capacity and
overlap and never more bits per transfer.
The chip select is not the only signal replicated per rank. On DDR4 the per-rank
signals are CS_n, CKE and ODT, while the address and command buses
and the data bus are shared. So power management is per rank, and
termination is per rank: the controller switches on-die termination on the
ranks it is not talking to, with resistor values the board vendor characterized
for a specific number of ranks at a specific speed. That is one of the ways rank
count and speed grade become the same subject. DDR5 has no CKE pin at all;
power-state entry moved onto the command/address bus.
Capacity is die density, device width and rank count in one equation
JEDEC’s DDR4 SPD annex does not contain a module capacity field. There is no byte anywhere in the 384-byte block that says “32GB”. The capacity is computed from four separate fields:
module capacity (bytes) = die density (bits) ÷ 8
× primary bus width ÷ device width
× logical ranks per DIMM
Worked on a 16GB 2Rx8 DDR4 stick built on 8Gb dies:
8 Gb ÷ 8 = 1 GB per die
64 bits ÷ 8 bits = 8 data devices per rank
1 GB × 8 = 8 GB per rank
8 GB × 2 ranks = 16 GB
ECC devices are outside that sum: they store a checksum and add nothing to the capacity in the listing title, as ECC vs non-ECC explains.
Intel’s Core Ultra 200S datasheet lists every DDR5 UDIMM construction its memory controller supports, and the whole table falls out of the same formula with three die densities:
| Die | Device organization | Devices | Ranks | Module |
|---|---|---|---|---|
| 16 Gb | 2048M x8 | 8 | 1 | 16 GB |
| 16 Gb | 1024M x16 | 4 | 1 | 8 GB |
| 16 Gb | 2048M x8 | 16 | 2 | 32 GB |
| 24 Gb | 3072M x8 | 8 | 1 | 24 GB |
| 24 Gb | 1536M x16 | 4 | 1 | 12 GB |
| 24 Gb | 3072M x8 | 16 | 2 | 48 GB |
| 32 Gb | 4096M x8 | 8 | 1 | 32 GB |
| 32 Gb | 2048M x16 | 4 | 1 | 16 GB |
| 32 Gb | 4096M x8 | 16 | 2 | 64 GB |
Look at 32 GB. It appears twice, as 2Rx8 on 16 Gb dies and as 1Rx8 on 32 Gb
dies, and so does 16 GB, once 1Rx8 and once 1Rx16. On this processor with
four DIMMs installed the single-rank part is rated 4800 MT/s and the dual-rank
part 4400, and die density is not in the listing title.
The 24 Gb rows are why DDR5 has capacities that are not powers of two: 12, 24,
48 and 96 GB are all 24 Gb dies, and a 48 GB module is 2Rx8 or 1Rx4
depending on who built it; AMD’s EPYC 9004 organization list has both. A
capacity does not imply a rank count.
What a second rank actually buys
The performance argument for two ranks is entirely about what a controller can
overlap. JESD79-4 gives each DDR4 device 16 internal banks arranged in four bank
groups at x4 and x8, and eight banks in two groups at x16. JESD79-5 raised that
to 32 banks in eight bank groups at x4 and x8. Because every device in a rank
receives the same command, the rank’s bank count is the device’s bank count: a
2Rx8 DDR4 stick has 16 banks per rank and 32 across the stick, not 16 for every
chip.
A second rank therefore doubles the number of rows that can sit open at once,
and it doubles two per-rank activation budgets, the tRRD spacing between row
activations and the tFAW window. Neither limit knows the other rank exists,
so a controller can start a row on one rank while the other is inside its window.
A rank switch is cheaper than a bank-group repeat
Micron’s 16Gb/32Gb 3DS DDR4 datasheet tabulates read-to-read spacing three ways.
Its ranks are the logical ranks inside a stack, but the ordering is what matters.
At DDR4-2666 the same rank and bank group costs 7 clocks (tCCD_L, SLR), a
different rank 5 (tCCD, DLR), and the same rank with a different bank group 4
(tCCD_S). A second rank gives the controller a third way to hide the array’s
recovery time, ranked between the two it already had.
Between two separate package ranks there is an extra cost JEDEC does not specify: the bus turnaround while one rank’s drivers release the bus. It belongs to the board and is set during memory training, so the published rank-switch penalty is a floor, and the real one on your machine is that floor plus a board-specific gap. That is why careful benchmarks of single against dual rank report a range rather than a figure.
Refresh is per rank, and that is where the second rank earns most
JESD79-4 sets the average refresh interval tREFI at 7.8 microseconds at or
below 85 °C, halving above it, and each refresh occupies the rank for tRFC, which
is 350 ns on 8Gb DDR4 dies and 550 ns on 16Gb ones. 550 ÷ 7800 is 0.0705, so a
channel built from 16Gb DDR4 dies spends about seven percent of its time refusing
to answer even when otherwise idle, and that figure doubles above 85 °C.
On a single-rank channel, a refresh stalls the channel. On a two-rank channel the controller can refresh one rank while serving reads from the other. This is the least discussed and most reliable benefit of a second rank, because unlike bank-level parallelism it does not depend on the access pattern: refresh happens whether the workload is sequential or random. Refresh timings in general are covered in CAS latency explained.
DDR5 attacked this directly. JESD79-5 adds same-bank refresh, which refreshes one bank across all bank groups instead of the whole rank, so the rest of the rank stays addressable, and refresh management, by which the device demands extra refreshes when a row is being hammered. Both make a rank less of a monolith, and both reduce the value of having a second one.
Why the gain depends on the workload, and shrank on DDR5
Two ranks help when the controller has enough outstanding requests to find something useful to do with the second one: most on many independent streams, least on a single chain of pointer chases. Three changes have been eroding the benefit since DDR3:
- DDR4 gave every rank four bank groups where DDR3 had none, so a controller already had a cheap way to avoid the same-bank-group penalty inside one rank.
- DDR5 doubled that to eight bank groups and 32 banks.
- DDR5 split the module into two independent 32-bit sub-channels, each with its own command bus, which is a second form of parallelism whether or not a second rank is present.
A rule of thumb learned on DDR3, where dual rank was a dependable win, overstates the case on DDR5, where the answer is usually decided by the derating table.
Dual rank is not dual channel
The two phrases sound alike and describe opposite things: two channels are two 64-bit buses, 128 bits per transfer, and two ranks are one 64-bit bus with two sets of devices. Doubling channels is worth close to double the peak bandwidth. Doubling ranks is worth a schedule improvement whose size depends on what you are running. Tom’s Hardware’s laptop test put two ranks on both sides, and the two sticks won by 10.9%. So if a board has four slots and two channels, two modules populating both channels beat one module of twice the capacity every time, regardless of rank count. Rank count is the tie-breaker between options that already fill the channels.
Two ranks on one module, or two modules of one rank?
Same total rank count, and the benchmarks barely separate them: Igor’s Lab found two dual-rank and four single-rank DDR4 sticks “almost perfectly equal” at fixed timings, and Tom’s Hardware found the difference negligible. It is still not a wash. On an unbuffered channel one dual-rank module loads the command bus less than two single-rank modules; on a registered channel it is one register’s load against two. The single module also leaves a slot free, so it wins in almost every case. The exception is a board whose population table rates two single-rank modules higher: take the table’s word for it.
Single, dual and quad rank, and why quad rank disappeared
The rank counts are not a ladder from worse to better. Each exists for a different reason.
Single rank is the cheapest way to build a capacity once the die density can reach it, because it needs half the devices of a dual-rank part, and it loads the data bus least, which is why single-rank modules hold the top row of almost every population table at two DIMMs per channel. It gives up the overlap: one set of banks, one activation budget, and a stall on the channel every time that rank refreshes.
Dual rank is where 32GB sticks sit and where 16GB DDR4 sticks mostly sit, and on servers it is the commonest construction by a wide margin: the capacity sweet spot, mild or no derating at one module per channel, and the deepest used market.
Quad rank is a historical artifact. Before 16 Gb dies, the only way to build a large registered module was four ranks, which spends an entire desktop channel’s chip-select budget by itself. That is the origin of most confusing rules in older motherboard manuals: the slot that will not take the module, the ceiling that halves when you fill the second slot, the speed that drops two bins.
Eight ranks never happened as eight chip selects. It happened as eight logical ranks behind two, a 4-high 3DS module, which is why quad-rank modules disappeared rather than being extended. Single rank and quad rank are opposite answers to the same question - how to stay inside the channel’s electrical budget - separated by twenty years of die density, and on a server dual rank is where almost everybody should be standing.
Why more ranks per channel lowers the speed
A memory channel is a transmission line with stubs hanging off it, and every device on it is a capacitive load. Two buses are loaded in two different ways.
The command and address bus is loaded per device. Every DRAM on the channel must see the same address and command, so on an unbuffered module the address bus fans out to every device of every rank. The data bus is loaded per rank. A data line reaches exactly one device per rank, because each device owns its own four or eight lanes.
Count it, leaving aside a server module’s register. Two 2Rx4 DDR4 RDIMMs are 72
devices’ worth of address-bus load and four loads on each data line; two unbuffered
2Rx8 desktop sticks are 32 and four. The desktop channel has less than half the
command-bus loading and exactly the same data-bus loading.
A registered module’s clock driver re-drives address and command, so the controller sees one command-bus load per module, but a registered module does nothing at all about data-bus loading, which is why rank count still sets its speed grade. A load-reduced module adds data buffers, nine on a DDR4 LRDIMM and ten on a DDR5 one, so the data lines see one load per module too. A 3DS package removes load a third way, inside the package, covered in the 3DS section. Which machines take which module type is in RDIMM, UDIMM and LRDIMM.
The chip-select budget
One chip select, one package rank, so the ceiling on ranks per channel is a pin
count rather than a preference. Intel’s Core Ultra 200S datasheet states it in
the signal list: DDR0_CS[3:0] is “Chip Select: (1 per rank) … There is one
Chip Select for each SDRAM rank”, four of them per sub-channel. The support
matrix states the budget outright: a maximum ranks-per-channel of 2 with one
DIMM per channel and 4 with two.
DDR4 counted the same way. A DDR4 registered DIMM has CS0_n and CS1_n plus
two dual-function pins, CS2_n/C0 and CS3_n/C1, whose other function is a chip
ID for a stacked part, so a quad-rank module and a 3DS module compete for the
same four pins.
Four is the desktop number. Server controllers get more. Intel’s S2600WT board rules allow “a maximum of 8 ranks … on any one channel, counting all ranks in each DIMM on the channel”, and eight is what lets a Dell PowerEdge R620 take “up to two quad-rank RDIMMs … per channel” at all, at the speeds in the next table.
The derating tables, and what they derate
Every platform publishes a table of speed against population, and every one of them is indexed by rank count somewhere. Two platforms, twelve years apart:
| Platform | Population | Rated speed |
|---|---|---|
| Intel Core Ultra 200S | 4 DIMMs, single-rank | 4800 MT/s |
| Intel Core Ultra 200S | 4 DIMMs, dual-rank | 4400 MT/s |
| Dell PowerEdge R620 | quad-rank RDIMM, 1 DPC | 1333 MT/s |
| Dell PowerEdge R620 | quad-rank RDIMM, 2 DPC | 1066 MT/s |
| Dell PowerEdge R620 | 3 DIMMs per channel, single or dual rank only | 1333 MT/s maximum |
The first pair is the cleanest statement of the effect in any consumer datasheet: same slot count, same generation, and 400 MT/s of difference decided by nothing but whether the modules are one rank or two.
What the table derates is signal integrity on the data bus, and the penalty is a cliff rather than a slope: each rank’s DQ pins are a stub on the data line, and the training either meets the speed bin it wanted or drops to the next bin down, whole.
The derating is a property of the channel, not of the module. In a four-stick
set, a 1Rx8 stick rated 4800 among its own kind loses that rating next to a
dual-rank neighbor, because what changed is the number of stubs on the shared line.
And a listing that quotes a speed grade is quoting the module’s bin, not the speed
you will get: the population table says what the channel will be clocked at, and
that is usually lower. RAM speed: MHz against MT/s covers
the gap.
3DS: more dies behind one chip select
Once the chip-select budget is spent, the only way left to add capacity is to put more dies behind the chip selects you already have. Micron’s 3DS DDR4 datasheet describes the arrangement: “The 3DS device provides a stack of DRAM die with one die configured as the master and the remaining die in the stack configured as slave device(s). Each die functions as a different logical rank.” The master die carries the only external interface; the others are reached through through-silicon vias. Then comes the sentence that matters most:
“In contrast to conventionally stacked DDR4 (TwinDie), 3DS stacks only have one CS_n pin regardless of the number of die; die (logical rank) selection is accomplished by the state of the Chip ID (Cx) pin(s), which behave as rank address(es).”
A 2-high stack uses CS_n plus one chip ID; a 4-high stack adds a second; three
chip-ID bits reach eight dies. The chip IDs are extra address bits, not extra
chip selects, so the controller’s budget never notices them. On a registered
module the register drives the chip-ID inputs, so the stack height a module can
present depends on the register’s mapping, not on the connector’s pin count.
The second benefit is electrical: in Micron’s words, “the electrical signal loading of the external interface is that of a single DDR4 SDRAM”. Eight dies, one load, which is why high-capacity DDR4 and DDR5 server memory converged on stacking.
Three costs come with it.
- Heat. Eight dies share one path to the heatspreader, and refresh doubles above 85 °C, so a hot stack refreshes twice as often, which makes it hotter. That is a large part of why stacked modules carry conservative speed bins.
- Yield. A bonding failure scraps every die in the stack. That cost is in the price, and it is why a 3DS module has never been the cheapest route to a capacity a monolithic part can also reach.
- Timing. Every array timing in a 3DS datasheet exists twice, for the same
logical rank (
SLR) and for a different one (DLR), as in the rank-switch timings.
DDP is the other kind of stacking, and it is not 3DS
A dual-die package, which Micron calls TwinDie and the trade calls DDP, also puts two dies in one package. The difference is exactly the one Micron’s TwinDie sentence draws: a DDP package “uses CS1_n, CKE1, and ODT1 to control the second die”. The second die has its own chip select, its own clock enable and its own termination pin. It spends a chip select and it presents two loads. So a 64GB DDP module is a four-rank module in every sense the memory controller cares about, while a 64GB 3DS 2-high module holds the same bits with the same die count and occupies two chip selects.
The same 64GB, four different ways
Here is the 64GB DDR4 registered module, built four ways, with a 128GB stack for scale. All are real constructions that shipped, all on 36 x4 packages, because eighteen packages cover the width and the module carries two sets of them.
| Construction | Dies | Chip selects | Ranks the system sees | Real part |
|---|---|---|---|---|
Monolithic 2Rx4, 16Gb dies |
36 | 2 | 2 | M393A8G40AB2-CWE, DDR4-3200 |
DDP 4Rx4, 8Gb dies |
72 | 4 | 4 | - |
DDP 4Rx4 LRDIMM, 8Gb dies, plus 9 data buffers |
72 | 4 | 4 | M386A8K40BM2 |
3DS 2-high 2S2Rx4, 8Gb dies |
72 | 2 | 4 | M393A8K40B21, DDR4-2400 |
| 128GB: 3DS 4-high, 8Gb dies | 144 | 2 | 8 | MTA144ASQ16G72PSZ |
Four modules, one capacity, one generation, one form factor, one notch position. They differ in die density, die count, chip-select consumption, electrical loading, speed grade, price and which machines will take them, and the listing title for all four is the same four words. Two 64GB Samsung x4 registered modules: one is two ranks and graded DDR4-3200, the other is four logical ranks and graded DDR4-2400, because the stacked part was designed when 8 Gb was the largest die in volume and the monolithic part waited for 16 Gb. On a board that derates by rank at two modules per channel they do not perform alike, and in a machine already carrying dual-rank modules they may not both fit.
Part numbers often give the construction away. In a
Samsung DDR4 number, the last digit of the four characters after the A (8K40)
is the device width: 0 x4, 3 x8, 4 x16. The die-revision letter follows, then
the package code: B for a monolithic flip-chip part, M for DDP and a digit for
a TSV stack, 2 for 2-high. Micron’s number straight after MTA counts dies, not
packages: MTA36ASF8G72PZ is 36, MTA72ASS8G72PSZ is 72 and MTA144ASQ16G72PSZ
is 144, with the SS and SQ family letters and the PSZ suffix marking the
stack. Crucial’s registered parts put a D or S before the width digit, so a
…RFD4… part is dual-rank x4. Others, including SK hynix and system-vendor
relabels, do not decode reliably. Buying used RAM on
eBay walks through a full Micron number.
The notation nobody agrees on
Multiply the two numbers in the stacked form and you get what population tables
care about: 2S2Rx4 is four logical ranks on two chip selects, 2S4Rx4 eight,
2S8Rx4 sixteen. Past that, the labeling is a mess in vendors’ own documents,
and it is the most common source of a mis-ordered module.
- The same 2-high 64GB construction is a raw card to Supermicro, which lists
“3DS RDIMM Raw Cards: A/B (4Rx4)”, and a “(4Rx4) 3DS RDIMM” in Lenovo’s
option list, while listings of Samsung’s
M393A8K40B21sell it as “2S2Rx4”. One module, two spellings, and only one of them says it is stacked. - AMD’s EPYC 9004 Series Memory Population Recommendations (publication 58269)
tabulates
2S8Rx4as “16 ranks” and then2S4Ras “4 ranks”, not eight.
When they conflict: count logical ranks for capacity limits and speed bins,
count package ranks for chip selects and electrical load, and take the module’s
own label over any secondary source. A bare 8Rx4 printed on a stacked part is
already the logical count.
A raw card is a JEDEC-registered PCB design, identified by a letter and a
revision, as in RB2. Server vendors qualify raw cards rather than part numbers,
because two vendors’ modules on the same raw card are electrically the same
object, so when a support list names a raw card, match the raw card printed on
the module label.
What the SPD records, and how it tells 3DS from dual-die
Every module carries a small EEPROM holding its Serial Presence Detect data. For DDR4 the layout is JEDEC Standard 21-C, Annex L; for DDR5 it moved into its own document, JESD400-5. On DDR4, byte 4 holds the die density, byte 6 the package type, byte 12 the package ranks and the device width, and byte 13 the bus width.
The signal loading field in byte 6 is where 3DS and DDP part company in the data. A dual-die package declares a die count of two and a multi load stack, because its second die has its own chip select and its own loading. A 4-high 3DS package declares a die count of four and a single load stack, because the master hides the other three. Read the fields of a 128GB 3DS part built from 8 Gb dies:
byte 4 die density 8 Gb
byte 6 package type non-monolithic, 4 dies, single load stack
byte 12 package ranks 2
byte 12 device width x4
byte 13 primary bus width 64 bits
logical ranks = package ranks × die count = 2 × 4 = 8
capacity = 8 Gb ÷ 8 × 64 ÷ 4 × 8 = 1 GB × 16 × 8 = 128 GB
The capacity formula multiplies by logical ranks. Byte 12 reports package
ranks. Multiply by byte 12 alone on a stacked module and you get 32GB for a
128GB part, a quarter of the real answer. That is the error behind every listing
that describes a 128GB 3DS module as 2Rx4, and it is why the die count in
byte 6 is not optional reading. An asymmetrical module, flagged by byte 12’s
rank-mix bit, has ranks of different capacities: legal, rare, and not two of anything.
3DS RDIMM or LRDIMM: two answers to one problem
Both exist because a channel runs out of electrical budget before it runs out of address space. A load-reduced module buffers the data lines on the module; the ranks behind the buffers are ordinary ranks, so a four-rank part still spends four chip selects. A 3DS registered module buffers nothing on the data lines. It hides half, three-quarters or seven-eighths of its dies behind a master, depending on the stack height, and addresses them with chip IDs, saving chip selects at the same time.
| 64GB LRDIMM (DDP 4Rx4) | 64GB 3DS RDIMM (2S2Rx4) | |
|---|---|---|
| Buffers on the command bus | register | register |
| Buffers on the data bus | nine data buffers | none |
| Load per data line | one per module | one per package rank, so two |
| Chip selects consumed | four | two |
| Logical ranks for capacity | four | four |
| Added latency | register plus data buffer | register only |
| Platform support | needs explicit LRDIMM support | needs explicit 3DS support |
Neither is a superset of the other: there are machines that take 64GB LRDIMMs and refuse 64GB 3DS RDIMMs, and machines the other way around.
DDR5 settled the contest. AMD’s EPYC 9004 platform supports no LRDIMM at all, because 3DS registered modules cover the capacities load reduction used to be needed for, at lower latency and with fewer parts to fail. On used DDR4, load-reduced modules and registered modules are two separate markets, and the machine decides which you are in, as RDIMM, UDIMM and LRDIMM explains.
Where the ranks sit on DDR5
A DDR5 module is not one 64-bit channel. It is two independent 32-bit
sub-channels, 40 bits each once registered ECC is added, each with its own
command and address bus and its own chip selects. Intel’s desktop controller
exposes four of them, DDR0 through DDR3, each with CS[3:0] and CA[12:0]
of its own. JEDEC’s word is sub-channel; pseudo-channels are an HBM arrangement.
A DDR5 x4 registered module’s rank is twenty packages, so a two-rank x4 module
carries forty, and a 128GB 2S2Rx4 3DS part carries the same forty, because
stacking changes the die count inside each package, not the number of packages.
For server DDR5, AMD’s EPYC 9004 guide is the clearest published list of what exists:
| Type | Organizations | Capacities |
|---|---|---|
| RDIMM | 1Rx8, 1Rx4, 2Rx8, 2Rx4 |
16, 24, 32, 40, 48, 64, 80, 96 GB |
| 3DS RDIMM | 2S2Rx4 |
128, 192 GB |
| 3DS RDIMM | 2S4Rx4 |
256, 384 GB |
| 3DS RDIMM | 2S8R |
512 GB, marked “pending ecosystem enablement” |
The boundary falls at 96GB: below it, ordinary registered modules; above it, nothing but 3DS. EPYC 9004 supports no LRDIMM and no UDIMM at all, so on that platform high capacity goes through stacked registered modules or it does not happen. The same document’s population rules are in the server rules.
The one place ranks become a speed feature is the server-only multiplexed-rank module, which reads two ranks at once and multiplexes them onto the bus. The catalog is at DDR5 memory.
Which machines take which stacking
Stacking support is a property of the memory controller inside the processor, not of the board: a board that takes a 256GB stacked module with one processor installed will refuse the same module with an older one in the same socket.
You can work out which module a platform’s headline capacity was written against with nothing but division. The headline is the slot count multiplied by the largest module the processor qualifies, so the headline divided by the slots is the module. The headline figures and slot counts are the vendors’:
Xeon E5-2600 v4 1.54 TB ÷ 12 slots = 128 GB per module
Xeon Scalable 1st gen 768 GB ÷ 12 slots = 64 GB per module
Xeon Scalable, M SKUs 1.5 TB ÷ 12 slots = 128 GB per module
EPYC 7001 2 TB ÷ 16 slots = 128 GB per module
EPYC 7002 and 7003 4 TB ÷ 16 slots = 256 GB per module
EPYC 9004 6 TB ÷ 24 slots = 256 GB per module
(all per socket)
The first-generation Xeon Scalable row is the interesting one. Its standard processors were sold against a 64GB module, so the 128GB stacked parts the boards physically accept sit outside the ceiling the processor was specified to, and reaching 1.5TB meant buying an M-suffix part, such as the Gold 6140M or Platinum 8180M, at a premium for a larger number in a firmware table.
The EPYC rows show the other pattern: each generation’s ceiling moved by doubling the stacked module rather than by adding slots, so used 256GB stacked DDR4 modules are useful on one generation of AMD hardware and dead weight on the one before.
Three vendor statements about specific machines show what to check before spending:
- A Supermicro X11DPi-N takes a 256GB 3DS module only with second-generation Xeon Scalable installed; with first-generation processors the same board caps at 128GB stacked, so the 4TB the board is advertised with is unreachable with the wrong processor in the socket.
- A Supermicro X10SRL-F reaches 128GB load-reduced only with a 3DS part; a non-stacked 128GB LRDIMM does not exist for it.
- A Lenovo ThinkSystem SR630 is documented at 3TB, which is 24 slots at 128GB, written specifically against 128GB 3DS registered modules, while its load-reduced ceiling is 64GB per module, the opposite of the usual pattern, in which load-reduced parts reach higher than registered ones.
The rule that survives all three: check the processor, then the board, then the module, in that order. The compatibility pages say in words where a machine’s ceiling depends on stacking or rank, and RAM by processor starts from the processor.
Rank sparing and the other features that need ranks
Memory sparing sets a rank aside as a replacement, at a quarter of a quad-rank
channel or half of a dual-rank one, and a channel holding a single 1Rx8 module
cannot turn it on at all. Intel’s adaptive double device data correction needs x4
modules and two ranks per channel. Mirroring, sparing and
lockstep
has the arithmetic and the vendors’ wording. Single device data correction depends
on width, not rank: Lenovo’s ThinkSystem documentation states “Single Device Data
Correction (SDDC, also known as Chipkill, requires x4-based DIMMs)”. That is the
strongest argument for x4 server memory, and it has nothing to do with rank
count; how it corrects a dead device is in ECC vs non-ECC.
What ranks cost in power and in boot time
Standby current is per rank. Every datasheet specifies a device’s idle current, for its refresh machinery, its delay-locked loop and its termination, per device. A channel with four ranks of eighteen x4 devices has seventy-two devices drawing it where a channel with one rank has eighteen, which is a large part of why a fully populated server idles higher than one with the same capacity in fewer, denser modules.
Training is per rank. Before a channel can run at speed, the firmware finds, for every rank, the timing at which each data lane’s signal is centered, which is why a large server takes minutes to reach its firmware screen. A desktop shows it on a new kit’s first start: ASRock’s launch-era AM5 table, reported by Guru3D (September 9, 2022), gave 100 seconds for two single-rank sticks, 200 for two dual-rank or four single-rank, and about 7 minutes for four dual-rank. A machine that suddenly takes much longer to POST after a memory change has not developed a fault. It has been given more ranks to train, or a population whose training results the firmware has not cached.
The older generations use the same grammar
DDR3 server memory is where rank count was most visibly a constraint: the largest
modules were 4Rx4, spending four chip selects each. DDR3 load-reduced modules
answered with a memory buffer that performed rank multiplication, presenting a
module’s physical ranks to the host as fewer logical ranks: the same trick as a 3DS
chip ID, done on the circuit board a generation earlier.
DDR3 registered and load-reduced modules are usually the cheapest ECC memory per
gigabyte on this site, and the rank rules decide whether a given pile of them will
fill a given machine. See DDR3 memory, with
desktop, laptop,
registered and load-reduced
split out. DDR2 and DDR use the same nRxW
grammar with smaller numbers and no stacking.
What to confirm beyond the listing
- Rank itself, most of the time. About one laptop or desktop listing in sixteen states it, and a 16GB DDR4 stick can be either.
- Die density. A 32GB DDR5 stick is
2Rx8on 16 Gb dies or1Rx8on 32 Gb dies, and Intel’s own table rates those two differently in the same machine. - Whether a module is stacked. A 64GB DDR4 registered module is monolithic, dual-die or 2-high stacked depending on when it was built, and the dual-die one spends twice the chip selects.
- The speed you will get. The label is the module’s bin; the population table is the channel’s rate.
- Whether a server accepts stacking. That is a processor property, so two machines with one model number can have different memory ceilings.
This site records rank wherever the title states it; the organization string rarely reaches a title, and one question to the seller answers it.
On a laptop or desktop, the sticker is a tie-breaker and a way to match what you own. On a server it is more: two 64GB modules, four constructions, one listing title, and every machine that takes only some of them says so in advance, in a table indexed by the numbers on that sticker.