I bought a pair of used SODIMMs (Small Outline DIMM memory modules, the compact RAM form factor used in laptops) for a ThinkPad T480 last week. The seller was a recycler, the price was right, and the modules are the kind of RAM (Random Access Memory, the working memory a CPU reads and writes while the system is running) that is hard to find new at this capacity. I had no way to know whether they were actually working when they came out of the previous laptop. So before installing them, I ran MemTest86+ (a stand-alone memory-testing program that boots from USB and exhaustively exercises every address in RAM) on each stick individually.
The question I had going in was the same question that comes up on every forum thread about RAM testing: how many passes is enough? I went looking for the answer and got the usual range of opinions. Three passes for a quick check. Eight passes for a thorough check. Overnight, no specific count. One pass and trust the result.
The honest answer is that the question is the wrong shape, and the test plan I ended up using is more useful than any single pass count.
What a pass actually tests
MemTest86+ runs a fixed battery of test patterns over the full address range of the stick. The patterns are designed to catch specific classes of fault, and the test is more thorough than any single number suggests:
- Stuck-at faults. A bit permanently reads as 0 or 1 regardless of what was written. This is the grossest failure and shows up on the very first pattern of the first pass.
- Transition faults. A bit fails to flip when written with the opposite value. The cell holds one state but not the other, which is rare on consumer hardware and common on heavily-used server memory.
- Coupling faults. Two adjacent bits interfere with each other. Writing to one cell changes the value in a neighboring cell. The patterns that detect coupling faults are designed to flip one bit while leaving the neighbor at a specific state, then verify the neighbor did not move.
- Address-decoding faults. The stick writes to one address and reads from a different one. This shows up as a pattern that should be deterministic returning different results on different runs.
- Refresh faults. The cell loses its charge between writes and reads. MemTest86+ exercises this by holding specific patterns for extended periods between read cycles.
- Data-retention faults. The cell holds its value for a while and then loses it under specific temperature conditions. This is the class of fault that the warmed-up multi-pass test is designed to catch.
A single pass is one complete walk through every pattern, in sequence, over the whole address range. A complete pass on a 32 GB stick at default speed takes roughly two to three hours on the laptop I tested on. The progress indicator at the bottom of the screen shows the percent complete and the current pattern.
If a single pass completes with zero errors, you have established that the stick is functional under all the patterns MemTest86+ knows about, at the temperatures and timings (the memory controller’s clock and latency settings that determine how fast the RAM runs) it was running at during the test. You have not established that the stick is good for all time, at all temperatures, under all workloads. You have established that the stick is good for the conditions you just tested.
If a single pass surfaces even one error, the stick is bad. Do not argue with one error. Even one error means a bit flipped during the test, which means the bit is unstable, which means the stick is not safe to use as-is. The forum answer “one pass and trust the result” is correct in this direction: any error is disqualifying.
The number-of-passes question only matters when the count is zero.
Why three passes became the informal standard
The informal “three passes” rule comes from the observation that some faults are pattern-of-pattern. A bit that passes the first six patterns might fail on the seventh because the seventh pattern happens to put the cell into a state that exposes a marginal timing issue. Running multiple passes with the same patterns does not change this. Running multiple passes with the address range walked in different orders does change it, and MemTest86+ does walk the address range in different orders between passes.
For a 32 GB stick, three full passes takes six to nine hours. Most forum posts settle on three as the lower bound for “reasonably sure,” with the understanding that “reasonably sure” is not the same as “certain.” For sticks you have reason to suspect are weak (used SODIMMs from a recycler, sticks pulled from a machine that crashed, sticks that have been sitting on a shelf for a year), three passes is the floor.
The number does not have a theoretical basis. It is a folk heuristic (a rule of thumb that emerged from community practice rather than from a published calculation). It works because the failure modes it catches (intermittent timing faults that need multiple passes to expose) cluster in the first few passes, and the failure modes it does not catch (thermal faults that only show up after the stick warms up) need a different test setup, not a higher pass count.
The test plan that actually catches most faults
For used SODIMMs that I am planning to run in a production machine, I use a three-stage test. The stages take roughly twelve hours total, which is one overnight run. Each stage is doing something different, and skipping one of them loses a class of fault coverage:
- A baseline pass on a cool stick. Pull the stick from wherever it has been sitting, plug it into the test rig, and run one pass immediately. The goal is to catch gross failures (sticks that are clearly dead) without waiting for thermal effects to develop.
- Three passes under load. Run three full passes back-to-back. The stick will warm up over these passes. The goal is to catch timing faults that only show up at higher temperatures. MemTest86+ does not directly report the stick temperature, but it reports the test duration, and you can feel the stick through the case of the laptop if you want a rough number.
- One pass with the memory timings loosened. MemTest86+ has a configuration option to slow down the memory clock or relax the timings. Run one pass at the looser setting. The goal is to distinguish between “the stick is bad” and “the stick is marginal at the timings the test rig is using.” If the loosened-timing pass is clean and the original-timing pass surfaced errors, the stick may be usable in a less aggressive memory configuration. If both passes surfaced errors, the stick is bad.
If all three stages are clean, I trust the stick enough to install it in a production machine. If any stage surfaces an error, I retire the stick.
What the number of passes does not catch
There are two classes of fault that pass count does not help with, and both are worth knowing about before you spend the night testing.
The first class is voltage-related faults. A stick that passes MemTest86+ in a desktop with a clean power supply can still fail in a laptop with a marginal battery or a weak charging circuit. The test rig and the production machine need similar power delivery to give meaningful results. For a SODIMM going into a T480, the test rig should be a T480 or similar, not a desktop with a different power profile.
The second class is intermittent faults that happen only under specific workloads. A stick that passes MemTest86+ may still produce bit flips under heavy use, because the access patterns MemTest86+ uses do not cover every pattern a real workload will produce. Real-world failures are rare on sticks that have passed MemTest86+, but they are not zero. For a production machine that holds data the user cannot afford to lose, ECC RAM is the answer, not higher pass counts.
The number I use and why
For used SODIMMs going into a personal machine, I run the three-stage test above and stop. Twelve hours is a long time to wait, but it is a one-time cost per stick, and the alternative is debugging mysterious crashes later. For sticks that are new (factory-sealed, from a vendor I trust), I run a single pass as a smoke test (a quick sanity check that the hardware responds at all) and stop. New sticks fail much less often than used ones, and the failure modes are usually gross.
For sticks I am selling or giving away, I run the full three-stage test and document the result. The recipient has no way to know what the stick has been through, and a documented clean test is worth the twelve hours.
The exact number of passes is less important than the conditions. Three passes on a warm stick with loosened timings catches more faults than eight passes on a cold stick at default timings. The forum focus on pass count is a proxy for the more important question of how thoroughly the stick has been exercised.
Trade-offs
Twelve hours of test time is a real cost. If the user is in a hurry, the temptation is to run a single pass and trust the result. For a personal laptop where the consequences of a bad stick are a system crash and a reboot, a single pass is defensible. For a server holding data the user cannot afford to lose, the cost-benefit math is different, and a longer test (or ECC RAM, or both) is the right answer.
The loosened-timing pass is not free. It is one more pass on top of the three full passes, and it requires the user to know how to change the MemTest86+ configuration. The benefit is that it distinguishes between “the stick is bad” and “the test rig is too aggressive.” For most users, that distinction is not interesting, and they should just trust the three full passes and skip the fourth.
Documenting the test result is the part most users skip, and it is the part that matters the most. A clean test means nothing if the user cannot prove the test was run, on what date, on which stick, with what configuration. A note in a spreadsheet with the stick’s serial number, the test date, and the result is enough. The note lets the user find a bad stick that slipped through testing, and it lets the user stop testing a stick that has already been documented as clean.