DFT · Chapter 7 · Test Compression
Compression vs Coverage vs X-Handling
Compression is a three-way trade-off between the compression ratio, coverage, and unknown handling. On the coverage side, a higher ratio means fewer input variables, so fewer care bits can be satisfied per pattern and dense hard faults need more patterns or get dropped. Well-designed compression loses very little coverage, but aggressive ratios lose measurably. On the unknown side, values from uninitialized logic, non-scan flops, memories, or analog blocks flow into the XOR compactor and corrupt the compacted response, masking real detections. The usual fix is masking off the unknown-carrying chains, but that also masks any real fault effects on those chains, so masking is itself a coverage trade. The better lever is reducing unknowns at their source by tying, initializing, or scanning them, with masking kept as a fallback.
Advanced14 min readDFTCompression RatioX-MaskingX-SourcesCoverage Trade-off
Chapter 7 · Section 7.4 · Test Compression
Project thread — the mini-SoC's non-scan memory is a major X-source at the compactor; this lesson sets up 7.5 (debugging the resulting compression loss) and Chapter 8 (MBIST).
1. Why Should I Learn This?
Compression is a balance, not a free win — and X-handling is where it's usually lost.
- Ratio ↑ → test time ↓ (1.4), but coverage-risk ↑ (care-bit density) and X-sensitivity ↑.
- X (unknown) at the XOR compactor corrupts the compacted output → masks detections.
- X-masking blocks X-carrying chains — but also masks real fault effects there (a coverage trade).
- Best lever: reduce X-sources at the source (tie/init/scan); masking is a fallback.
2. Real Silicon Story — the masking that ate the coverage
A team hit compressed coverage well below the uncompressed baseline and assumed the ratio was too high. They lowered the ratio — coverage barely moved. The real culprit was elsewhere.
A non-scan memory in the design was an X-source: its outputs were unknown during scan test, and those X's flowed into the XOR compactor, corrupting the compacted response. To cope, the flow had masked a large number of chains every cycle the memory's X's were present — and that masking was the problem: it blocked the X's, yes, but it also masked every real fault effect on those chains during those cycles, throwing away coverage across a wide region.
The fix wasn't the ratio — it was the X-source. They initialized/bypassed the memory during scan (and planned MBIST, Chapter 8) so far fewer chains needed masking; the masking shrank, and coverage recovered to baseline. Lesson: when compressed coverage falls short, suspect X-masking driven by X-sources, not just the ratio — and fix X at the source, because masking spends coverage to buy X-tolerance.
3. Factory Perspective — the trade-off through each lens
- What the test engineer sees: the compressed-vs-uncompressed coverage gap, the mask density (how many chains masked, how often), and the ratio — the three dials to balance (1.4).
- What the yield engineer sees: that excess masking creates coverage holes → escape risk (DPPM, 1.5), and that X-sources (memories, analog) are recurring culprits.
- What the RTL/DV engineer sees: that their X-sources (uninitialized/non-scan/multi-cycle) drive masking — and that fixing X at the source (init/tie/scan) is their highest-leverage lever (6.3/6.4).
- What management cares about: that pushing the ratio for test-cost (1.4) has a coverage/X cost — and that X-source reduction (design work) often beats both a lower ratio and heavier masking.
4. Concept — the three-way balance
The three quantities in tension:
- Compression ratio ↑ → test time / data volume ↓ (1.4/7.1) — the benefit.
- Coverage — ideally held, but at risk from care-bit density and X-masking.
- X-sensitivity — how much unknown values corrupt the compactor.
Coverage risk from the ratio (care-bit density, 7.2/7.3):
- Higher ratio → fewer input variables → fewer care bits satisfiable per pattern → dense (hard) faults need more patterns or drop.
- Well-designed ratio → negligible loss; aggressive ratio → measurable loss (split patterns / undetected).
X-handling risk (the compactor, 7.2):
- X-sources: uninitialized logic, non-scan flops, memories, analog, uncontrolled multi-cycle paths.
- An X on any chain entering the XOR compactor makes the compacted bit X → masks real fault detections merged there → coverage loss / false results.
X-masking — the fix that is itself a trade:
- Mask registers gate off X-carrying chains at the compactor before the XOR → the X can't corrupt the output.
- But masking a chain also masks any real fault effect on it that cycle → X-masking spends coverage to buy X-tolerance.
- So more X → more masking → more coverage lost.
The best lever — reduce X-sources at the source:
- Fix X where it's born: tie/initialize uninitialized logic, scan non-scan flops, bypass/initialize memories during scan (and MBIST them, Chapter 8), control multi-cycle paths (4.4).
- Less X → less masking → coverage held. Masking is a fallback for the residual X.
- Complement with X-bounding (identify/limit X-sources) and X-tolerant compactor designs.
The balance:
- Ratio up → test time down, but coverage-risk up and X-sensitivity up. Choose a ratio, deploy robust X-handling, and above all reduce X-sources — and always baseline against uncompressed coverage.
5. Mental Model — a group photo ruined by one blurry face
The XOR compactor is like taking one group photo that sums up many people's expressions into a single verdict ('everyone smiling?').
- If one person's face is a blur (an X), the whole photo is unusable — you can't tell if anyone else was frowning (a real fault effect). One X ruins the merged verdict.
- X-masking is cropping the blurry person out before judging the photo — now the blur doesn't ruin it. But you've also cropped out whatever that person's real expression was — if they were frowning (a fault effect on that chain), you'll never see it. Cropping spends information.
- The ratio is how many people you cram into one photo: more people per photo (higher ratio) = fewer photos (less test time), but one blur ruins more, and specific poses are harder to arrange (care-bit density).
- The best fix isn't cropping more — it's telling the blurry person to hold still (fix the X-source: init/scan/MBIST). Then almost no cropping is needed and the photos are clean.
One blur ruins the group photo; cropping it loses real information; the real fix is to stop the blur at the source.
6. Working Example — masking cost vs X-source reduction
Quantify the trade-off and the better lever:
# Compressed coverage vs the trade-offs - REPRESENTATIVE, SIMPLIFIED, tool-neutral:
Uncompressed baseline coverage = 99.4% (the TRUE achievable, 6.5)
Compressed, ratio 30x, HEAVY masking = 96.1% <- 3.3% LOST -- mostly to X-MASKING (a non-scan memory X-source)
-> masking blocked the memory's X, but ALSO masked real fault effects on ~many chains x many cycles
Compressed, ratio 30x, X-SOURCE FIXED (init/bypass memory + MBIST plan, Ch8) = 99.3% <- recovered! little masking
Compressed, ratio 60x (aggressive), X fixed = 99.0% <- small care-bit-density loss (dense faults split/drop, 7.2)
# LESSON: the big loss was MASKING driven by an X-SOURCE, not the ratio. Fix X at the SOURCE -> coverage returns.# The three-way balance - REPRESENTATIVE:
ratio UP -> test time DOWN (1.4) BUT coverage-risk UP (care-bit density) + X-sensitivity UP
X-masking -> blocks X BUT masks real fault effects on masked chains (coverage trade)
reduce X-src -> BEST: less masking needed -> coverage held at high ratio (tie/init/scan/MBIST, 6.3/6.4/Ch8)
# Choose: a ratio the care-bit density supports + robust X-handling + AGGRESSIVE X-source reduction.7. Industry Flow — balancing ratio, coverage, and X
The trade-off is set by choosing a ratio, handling X (source-first), and baselining coverage:
8. Debugging Session — compressed coverage below baseline
Compressed coverage is well below the uncompressed baseline and the team lowers the ratio with little effect; the real cause is heavy X-masking driven by an X-source (a non-scan memory) -- masking blocks the X but also masks real fault effects on those chains -- so the fix is to reduce the X-source at its source (initialize/bypass/scan/MBIST), which shrinks masking and recovers coverage, better than lowering the ratio
COMPRESSED-COVERAGE LOSS IS OFTEN X-MASKING FROM AN X-SOURCE — FIX X AT THE SOURCECompressed coverage is well below the uncompressed baseline (e.g. 96% vs 99.4%). The team lowers the compression ratio to recover it — but coverage barely improves.
The loss is coming from heavy X-masking driven by an X-source, not from the ratio — so lowering the ratio doesn't help, because masking (not care-bit density) is what's dropping the coverage. The two ways compression loses coverage are care-bit density (ratio-driven — dense faults split/drop, 7.2) and X-masking (X-source-driven — masked chains lose their fault effects). Lowering the ratio only addresses the first. Here the dominant cause is the second: an X-source (a non-scan memory, say) emits unknown values during scan that flow into the XOR compactor, and because an X on any chain corrupts the compacted bit, the flow masks the X-carrying chains every cycle the X is present. That masking does block the X — but it also masks every real fault effect on those chains during those cycles, so a wide swath of coverage is thrown away wherever the memory's X reaches the compactor. Since the ratio isn't the driver, reducing it leaves the masking (and its coverage loss) largely intact — the memory still emits X, the flow still masks those chains, and the coverage stays low. The tell is in the masking report: a large number of chains masked, concentrated around the X-source.
Reduce the X-source at its source so far fewer chains need masking — coverage recovers, and you keep a high ratio; masking is only for the residual X. Fix the X where it's born (6.3/6.4): initialize or bypass the memory during scan (put it in a known state, or gate its outputs to a defined value in test), scan any non-scan flops feeding the compactor, tie/initialize uninitialized logic, and control uncontrolled multi-cycle paths (4.4) — and plan MBIST to test the memory itself (Chapter 8). With the X-source contained, the flow masks far fewer chains, so the real fault effects on those chains are no longer thrown away, and compressed coverage returns to the uncompressed baseline — at the original high ratio. Use X-masking only for the residual, unavoidable X, and consider X-tolerant compactor designs. Always baseline against uncompressed to confirm recovery. The principle to lock in: compression trades ratio against coverage and X-sensitivity — a higher ratio saves test time but risks care-bit-density coverage loss, and unknown values from X-sources corrupt the XOR compactor and force X-masking, which blocks the X but also masks real fault effects on those chains — so the best lever for compressed-coverage loss is to reduce X-sources at their source (initialize, tie, scan, MBIST) rather than to lower the ratio or mask more heavily, because masking spends coverage to buy X-tolerance while source reduction keeps both. (Care-bit density is 7.2; X-source debugging methodology is 6.3; the full compression-loss debug is 7.5; memories drive MBIST in Chapter 8.)
9. Common Mistakes
- Blaming the ratio for an X-masking loss. Lowering the ratio won't fix masking driven by an X-source — fix the source.
- Treating X-masking as free. It masks real fault effects on masked chains — a coverage trade.
- Masking more instead of reducing X-sources. Source reduction keeps both coverage and ratio; masking spends coverage.
- Ignoring memories/analog as X-sources. They're major X-sources — init/bypass in scan, MBIST them (Ch8).
- Not baselining against uncompressed. The uncompressed coverage is the true target — compare to it.
10. Industry Best Practices
- Reduce X-sources first (tie/init/scan/MBIST) — the highest-leverage X lever (6.3/6.4/Ch8).
- Use X-masking for the residual X only — minimize masked chains (it costs coverage).
- Set the ratio to care-bit density (7.2); baseline compressed vs uncompressed coverage.
- Consider X-tolerant compactor designs where X is unavoidable.
- Diagnose a compressed loss by cause — care-bit density (ratio) vs masking (X-source) (7.5).
11. Senior Engineer Thinking
- Beginner: "Compressed coverage is low — lower the compression ratio."
- Senior: "Is the loss care-bit density (ratio) or X-masking (an X-source)? The masking report will say. Usually it's a memory/non-scan X-source flooding the compactor, so we mask chains — which also drops real fault effects. I fix X at the source (init/bypass/scan/MBIST), so less masking is needed and coverage returns at the same ratio. Masking spends coverage; source reduction keeps it."
The senior diagnoses the cause (ratio vs masking) and reduces X-sources rather than masking more or lowering the ratio.
12. Silicon Impact
This lesson turns compression from a magic ratio into an engineered balance, and the X-handling dimension is where most real compressed-coverage loss occurs — so getting it right is what makes compression's test-cost win (1.4) safe for DPPM (1.5). The three quantities are genuinely coupled: raising the ratio cuts test time but raises care-bit-density coverage risk and X-sensitivity, so you can't treat the ratio as free. The subtle, high-stakes part is X-masking: because the XOR compactor turns any X on any chain into a corrupt compacted bit, flows mask X-carrying chains — and that masking also discards the real fault effects on those chains, so X-masking literally spends coverage to buy X-tolerance. That's why the best lever is X-source reduction: fixing the unknown at its source (initialize/tie/scan uninitialized and non-scan logic, bypass/initialize memories in scan and MBIST them in Chapter 8, control multi-cycle paths, 4.4) means far fewer chains need masking, so coverage is held at a high ratio — a strictly better outcome than heavier masking (loses coverage) or a lower ratio (loses test-time savings and often doesn't even address masking). The single most common misdiagnosis — the story's — is lowering the ratio to fix an X-masking loss, which barely helps because the driver was the X-source, not the ratio; the masking report distinguishes them. For the RTL/DV engineer, this is a direct mandate: your X-sources determine compressed coverage, so eliminating them at the source (a design/testability act) is the highest-leverage way to make compression cheap and high-coverage — and it's exactly the diagnosis the project's mini-SoC memory will force in 7.5, and the reason memories get their own test (MBIST, Chapter 8).
13. Engineering Checklist
- Balanced ratio vs coverage vs X — chose a ratio the care-bit density supports (7.2).
- Reduced X-sources at the source first (tie/init/scan/MBIST — 6.3/6.4/Ch8).
- Used X-masking only for residual X; minimized masked chains (coverage trade).
- Baselined compressed coverage against uncompressed (6.5); diagnosed any gap by cause.
- Considered X-tolerant compactor designs where X is unavoidable.
14. Try Yourself
- Trace an X from a non-scan memory into the XOR compactor and show it corrupts the compacted bit.
- Apply X-masking to that chain — show the X is blocked but a real fault effect there is also masked.
- Compute a coverage loss from heavy masking, then show fixing the X-source recovers it at the same ratio.
- Contrast a care-bit-density loss (fixed by ratio) with an X-masking loss (fixed by X-source) — different causes.
- Rank the levers for compressed-coverage loss: reduce X-source > lower ratio ≈ mask more — and justify.
The trade-off is tool-neutral. Real masking/coverage come from the compression tool. No paid tool required to reason about the balance.
15. Interview Perspective
- Weak: "Higher compression can lose coverage, so you handle X."
- Good: "Higher ratio risks care-bit-density loss, and X corrupts the compactor so you mask it."
- Senior: "Compression balances three things: ratio (test-time savings, 1.4), coverage (care-bit density — higher ratio → dense faults split/drop, 7.2), and X-sensitivity (the compactor). The big risk is X: an unknown on any chain corrupts the XOR compactor, masking detections, so we X-mask the X-carrying chains — but masking also masks real fault effects on them, so it spends coverage. The best lever is reducing X-sources at the source — initialize/bypass memories (and MBIST them, Ch8), scan non-scan flops, tie uninitialized logic — so fewer chains need masking and coverage holds at a high ratio. The classic mistake is lowering the ratio to fix an X-masking loss; it barely helps because the driver is the X-source, and the masking report tells you which. Always baseline against uncompressed."
16. Interview / Review Questions
17. Key Takeaways
- Compression is a three-way trade-off: ratio ↑ → test time ↓ (1.4), but coverage-risk ↑ (care-bit density) and X-sensitivity ↑ — the ratio is not free.
- Coverage risk from the ratio: higher ratio → fewer care bits satisfiable → dense (hard) faults split or drop (7.2); well-designed → negligible loss, aggressive → measurable.
- X-handling is the bigger risk: unknown (X) values (uninitialized/non-scan logic, memories, analog, uncontrolled multi-cycle) enter the XOR compactor, and an X on any chain corrupts the compacted output, masking real detections.
- X-masking blocks X-carrying chains — but also masks real fault effects on them, so it's itself a coverage trade (spends coverage to buy X-tolerance).
- The best lever is X-source reduction — tie/initialize/scan the source, bypass/initialize memories in scan and MBIST them (Chapter 8) — so less masking is needed and coverage holds at a high ratio; masking is a fallback for residual X, and a compressed-coverage loss is usually X-masking (fix the source), not the ratio. Next: 7.5 — debugging a compression loss.
18. Quick Revision
Compression vs coverage vs X-handling. Three-way trade: ratio ↑ → test time ↓ (1.4) BUT coverage-risk ↑ (care-bit density → dense faults split/drop, 7.2) + X-sensitivity ↑. X-sources (uninit/non-scan/MEMORY/analog/multi-cycle) → an X on any chain corrupts the XOR compactor → masks detections. X-MASKING gates off X-carrying chains BUT also masks real fault effects there → masking SPENDS coverage. BEST LEVER: reduce X-sources at the SOURCE (tie/init/scan/MBIST Ch8) → less masking → coverage held at high ratio; masking = fallback for residual X. Compressed-coverage loss is usually X-masking (fix the source), NOT the ratio → check the masking report; baseline vs uncompressed. Next: 7.5 — debugging a compression loss.