Server Memory Explained: RDIMM, LRDIMM and Rank

Before module type, before capacity, before anything: what your platform accepts is set by the memory controller, which means it is not a preference available to you at purchase time.

Generation is absolute. DDR3, DDR4 and DDR5 are keyed differently and physically will not seat in the wrong slot, which is the one mistake the hardware prevents for you.

Module type is not prevented. An RDIMM will slide into a board expecting UDIMM and the machine simply will not post. Registered, load reduced and unbuffered are three different things and a board supports specific ones.

Rank support is the third, and it is where most surprises come from. Boards limit how many ranks they can drive per channel, so a module that is correct in every other respect can still be refused once the channel is fully populated.

Speed is the most forgiving. Memory runs at the lowest common speed across the installed modules and what the controller supports, so a faster module is not an error, it is money you did not need to spend.

Send the server or board model with your enquiry and these get confirmed before anything is quoted.

These describe how a module presents itself to the memory controller, and they are the three types that appear in servers.

A registered module, RDIMM, puts a register between the controller and the memory chips to buffer the address and command lines. That reduces the electrical load on the controller and is what allows a server to run many modules per channel. It is the standard server module.

A load reduced module, LRDIMM, goes further and buffers the data lines as well through a memory buffer. Because the controller sees the buffer rather than the individual chips, LRDIMM allows higher total capacity per channel than RDIMM can reach. The cost is a small latency penalty and a higher price per module.

ECC UDIMM is unbuffered memory with error correction. It sits between server and desktop memory and suits certain workstation boards specifically.

The terms get used loosely, so be precise. Error correction and buffering are related but they are not the same thing, and a module can have one without the other.

The label on a server module carries a code such as 2Rx4 or 2Rx8, and it decides more about whether a module is useful than the capacity does.

The first part is rank. A rank is a set of memory chips the controller addresses as one block. 1R is single rank, 2R dual rank, 4R quad rank. Boards support a limited number of ranks per channel, so ranks are a budget you spend as you fill slots. This is why a board that takes a given total capacity may still refuse a particular arrangement of modules that adds up to it.

The second part is organisation, the width of each memory chip in bits. x4 means four bit wide chips, x8 means eight bit wide. Because a rank has to be a fixed total width, x4 modules use more chips than x8 modules of the same capacity. That has real consequences: x4 organisation supports stronger error correction on many platforms, while x8 is more common on lower capacity modules.

When you are quoting or buying, carry both. 32GB alone does not identify a module.

You can mix more than people assume and less than a spreadsheet suggests, and the rules are worth knowing because they decide what a mixed lot can actually be used for.

Within one machine, module types do not mix. RDIMM and LRDIMM cannot be installed together, and error correcting and non correcting modules cannot be either.

Speeds do mix, downward. Every module runs at the lowest speed present and supported, so mixing a faster module with a slower one wastes the faster module rather than breaking anything.

Capacities and ranks mix only within the rules the board sets, and those rules are specific about population order. Most server boards require slots filled in a defined sequence, and getting the sequence wrong can leave a channel unbalanced or disable memory entirely.

Manufacturers mix freely in most server platforms, where equivalent modules from different vendors are genuinely interchangeable. If you need one brand across an order for support reasons, that is a firm constraint rather than a preference, and it needs stating up front.

This is the part no generic memory article covers, and it is the whole job when memory arrives by the pallet.

A bulk memory lot is not one product. It is a pile of modules that has to be sorted into identical types before any of it can be used or sold, because memory is deployed in matched sets rather than as individual sticks. Twelve hundred assorted modules with no breakdown is a sorting job. Twelve hundred modules split into eight part numbers with a count against each is inventory.

Sort by exact part number, not by capacity. Two 32GB DDR4 modules with different rank organisation, different speeds or different module types are different products with different buyers, and averaging them into one line hides that.

The practical output is a list where each row is one part number, its capacity, speed, module type, rank organisation and a count. That list is quotable. A capacity total is not.

And sort before you decide the lot is low value. Mixed pallets frequently contain a few part numbers carrying most of the worth.

Almost everything needed to identify a server module is printed on it, and learning to read one label saves hours across a pallet.

The capacity is usually first and largest. Next comes the generation and speed, often given as a data rate such as PC4 followed by a number, or as the DDR generation with a megahertz figure. Then the rank and organisation code, 1Rx8, 2Rx4 and so on. Registered modules are often marked R and load reduced modules L, though this varies by manufacturer.

The manufacturer part number is the field worth capturing above all others, because it resolves every one of the above in a single string, including details the printed summary omits.

If a label is missing or unreadable, the module can usually still be identified by the chip count and layout, but that is slow work. It is quicker to photograph one label per stack while you are sorting.

When you send a memory list, one row per part number with a count against it is all that is needed.