Working Example: Debugging a Compression Loss

Chapter 7 · Section 7.5 · Test Compression — chapter capstone

Project thread — the mini-SoC's compressed patterns lose coverage to a non-scan memory X-source; fixing it at the source recovers coverage and motivates MBIST (Chapter 8).

1. Why Should I Learn This?

This is the whole chapter applied — and the methodology to recover any compressed-coverage loss without giving up the ratio.

• Baseline compressed vs uncompressed (the true achievable) — the gap is the loss.
• Diagnose: X-masking (X-source) vs care-bit over-constraint (ratio) vs mask misconfig (7.4).
• Localize via the masking report — which chains, how often, traced to X-sources / care-bit density.
• Fix at the cause: reduce X-sources at the source (common) → coverage recovers at the same ratio.

2. Real Silicon Story — the mini-SoC's memory that hid coverage

The mini-SoC had closed and signed off its uncompressed coverage (Chapter 6). Under compression, coverage came back below the baseline, and the schedule pressure produced the usual reflex: lower the ratio. It barely helped — and it gave back the test-time savings compression was supposed to deliver.

Baselining made the gap precise, and the masking report made the cause obvious: a large block of chains was masked every cycle a non-scan on-chip memory emitted X during scan. That masking blocked the memory's X — but also masked the real fault effects on those chains, throwing away coverage across the region fed into the compactor from there.

The fix was at the source: initialize/bypass the memory during scan (drive its outputs to a known value in test) and plan MBIST to test the memory itself (Chapter 8). The masking shrank dramatically, and compressed coverage returned to the uncompressed baseline — at the original high ratio. Lesson: debug a compressed loss by baseline → diagnose → localize → fix at the cause, and when it's X-masking, fix the X-source, not the ratio.

3. Factory Perspective — the debug through each lens

• What the test engineer sees: the compressed-vs-uncompressed gap and the masking report — the two artifacts that localize and diagnose the loss.
• What the yield engineer sees: that the masked region was an escape hot-spot (its faults weren't really tested) — fixing it cuts escapes (DPPM, 1.5).
• What the RTL/DV / memory engineer sees: that their X-source (the non-scan memory) drove the masking — fixing it at the source (init/bypass/scan/MBIST) is their lever (6.3/6.4/Ch8).
• What management cares about: that the loss was recovered at the same ratio by a source fix — keeping both the coverage and the test-cost win (1.4), better than lowering the ratio.

4. Concept — the compression-loss debug loop

Step 1 — Baseline against uncompressed:

• The uncompressed coverage is the true achievable (6.5). Run both; the gap = the compression loss to explain. Never debug the compressed number alone.

Step 2 — Diagnose the cause (7.4):

• (a) X-masking: X-sources corrupt the compactor; masked chains lose real fault effects → coverage loss. (Most common.)
• (b) Care-bit over-constraint: the ratio is too aggressive; dense patterns can't be satisfied → split/drop (7.2/7.3).
• (c) Mask/compactor misconfig: masking is wrong (too aggressive / mistimed) — a setup bug.

Step 3 — Localize (6.3 methodology):

• Find which chains/regions lose coverage. Read the masking report: how many chains masked, when, where.
• Heavy masking near an X-source → (a). Light masking but dense faults splitting → (b). Unexpected masking pattern → (c).

Step 4 — Fix at the cause:

• (a) Reduce the X-source at the source (the best lever, 7.4): initialize/bypass the memory in scan, scan non-scan flops, tie uninitialized logic, control multi-cycle paths (4.4); MBIST the memory (Chapter 8). → less masking → coverage recovers at the same ratio.
• (b) Lower the ratio or add test points (6.4) to thin care bits (7.2).
• (c) Fix the mask configuration (timing/scope).

Step 5 — Re-baseline:

• Re-run; compressed coverage should now match uncompressed. If not, iterate on the next cause/region.

5. Mental Model — a leak detective, at the merge point

Debugging a compression loss is like being a leak detective where many pipes merge into one meter (the compactor).

• The meter reads wrong (compressed coverage low). First, you compare it to the sum of the individual pipes (the uncompressed baseline) — the difference is the leak to find.
• You ask which kind of problem: is muddy water (an X) entering the merge and fouling the meter (X-masking), or are you demanding too much flow through a narrow inlet (an aggressive ratio / dense care bits), or is a valve set wrong (mask misconfig)?
• You walk the pipes (localize) and read the valve log (masking report): which pipes are shut off, and when. Many pipes shut near one dirty source → it's the muddy water.
• The fix isn't to narrow the whole system (lower the ratio) — it's to clean the dirty source (init/bypass the memory) so you stop shutting good pipes. The meter reads right again at full flow.

Compare to the baseline, find the kind of leak, walk to the source, clean it there — and you keep full flow (the ratio).

6. Working Example — the mini-SoC memory X-source, fixed

Work the case end to end:

# Compression-loss debug on the mini-SoC - REPRESENTATIVE, SIMPLIFIED, tool-neutral:
  Step 1 BASELINE:  uncompressed coverage = 99.4% ; compressed (ratio 30x) = 95.8%  -> GAP = 3.6% to explain
  Step 2 DIAGNOSE:  masking report shows ~heavy masking; NOT dense-pattern splitting -> suspect X-MASKING (7.4)
  Step 3 LOCALIZE:  masked chains concentrate around U_mem (a NON-SCAN on-chip memory) -> its X floods the compactor
                    every cycle -> flow masks those chains -> real fault effects on them are LOST -> coverage gap
  Step 4 FIX (at the source): initialize/bypass U_mem in scan (drive outputs to a known value in test) + plan MBIST (Ch8)
                    -> the memory no longer emits X into the compactor -> masking shrinks dramatically
  Step 5 RE-BASELINE: compressed coverage = 99.3% ~ uncompressed 99.4%  -> RECOVERED, at the SAME 30x ratio!
# The fix was the X-SOURCE, not the ratio. Lowering the ratio would have given back test time for little gain (7.4).

# If it had been CARE-BIT density instead (contrast) - REPRESENTATIVE:
  masking LIGHT, but a few DENSE (hard) faults split/undetected at 30x -> care-bit over-constraint (7.2/7.3)
  FIX: lower ratio to ~20x (more input variables) OR add TEST POINTS (6.4) to thin care bits -> those faults fit
# Diagnose FIRST (masking report) -> the cause dictates the fix (X-source vs ratio vs mask config).

The waveform shows the memory's X flooding the compactor, then masked:

7. Industry Flow — the debug feeds MBIST and signoff

Fixing the X-source recovers coverage and points at memory test (Chapter 8):

8. Debugging Session — compressed coverage low, ratio blamed

9. Common Mistakes

• Debugging the compressed number alone. Baseline against uncompressed — the gap is the loss (6.5).
• Lowering the ratio to fix an X-masking loss. The driver is the X-source — fix it at the source (7.4).
• Ignoring the masking report. It localizes the cause (heavy masking near an X-source vs dense-fault splitting).
• Masking harder instead of fixing the source. Source reduction keeps both coverage and ratio.
• Forgetting memories need their own test. A bypassed memory still needs MBIST (Chapter 8).

10. Industry Best Practices

• Always baseline compressed vs uncompressed — the gap defines the loss.
• Diagnose by cause (masking / care-bit / misconfig) via the masking report before fixing.
• Fix X-sources at the source (init/bypass/scan/MBIST) — recover coverage at the same ratio.
• Reserve ratio-lowering / test points for genuine care-bit-density losses (7.2/6.4).
• Re-baseline after each fix; iterate on the next region.

11. Senior Engineer Thinking

• Beginner: "Compressed coverage is low — lower the ratio."
• Senior: "First baseline vs uncompressed — the gap is the loss. Then the masking report: heavy masking near a non-scan memory = X-source, not ratio. I initialize/bypass the memory (and MBIST it, Ch8) so it stops flooding the compactor — masking shrinks, coverage recovers at the same ratio. Lowering the ratio would've cost test time for nothing. Fix the X-source; keep the ratio."

The senior baselines, reads the masking report, and fixes the X-source — never lowers the ratio for an X-masking loss.

12. Silicon Impact

This capstone delivers the practical payoff of the whole chapter: a repeatable way to recover coverage lost to compression without surrendering the test-cost win (1.4). The decisive habit is to baseline against the uncompressed achievable — a compressed number alone is meaningless; the gap to uncompressed is the loss — and then to diagnose by cause (7.4) using the masking report: X-masking (X-sources corrupting the compactor), care-bit over-constraint (an aggressive ratio), or mask misconfiguration. The common, high-impact case is X-masking, and the worst mistake — the story's — is lowering the ratio to fix it, which barely helps (the X-source, not the ratio, is the driver) while giving back the very test-time savings compression exists to provide. The right fix is at the source: initialize/bypass/scan the X-source (very often a memory) so the flow masks far fewer chains, which restores the real fault effects on those chains and recovers coverage at the original high ratio. This is the 6.3 X-source lesson replaying at the compactor — and it directly motivates Chapter 8 (MBIST), because a bypassed memory still needs its own test (scan can't cover memory arrays, and the memory is a perennial X-source). For the RTL/DV and memory engineer, the takeaway is that compressed coverage is your X-sources' story: eliminating them at the source is what makes compression cheap and high-coverage, keeps the DPPM commitment (1.5) intact, and lets the mini-SoC's signed-off patterns run at full compression. With that, Chapter 7 closes the cost side of the DFT flow (coverage closed in Chapter 6, test time cut here), and the curriculum turns to the defect classes scan/ATPG can't reach — memories (Chapter 8) and beyond.

13. Engineering Checklist

• Baselined compressed coverage against uncompressed — quantified the gap.
• Diagnosed the cause (X-masking / care-bit / misconfig) via the masking report.
• Localized the loss (which chains/regions; which X-source).
• Fixed at the cause — reduced the X-source at the source (init/bypass/scan; MBIST, Ch8) for the common case.
• Re-baselined — confirmed compressed coverage matches uncompressed at the ratio.

14. Try Yourself

1. Given uncompressed 99.4% and compressed 95.8%, state the gap and what it represents.
2. From a masking report showing heavy masking near a memory, diagnose the cause (X-masking, not ratio).
3. Fix at the source: initialize/bypass the memory; show masking shrinks and coverage recovers at the same ratio.
4. Contrast with a care-bit-density loss (light masking, dense faults split) → fix by ratio/test points.
5. Explain why the bypassed memory still needs MBIST (Chapter 8).

The methodology is tool-neutral. Real coverage/masking come from the compression tool; MBIST is Chapter 8. No paid tool required to practice the loop.

15. Interview Perspective

• Weak: "If compressed coverage is low, reduce the compression ratio."
• Good: "Baseline against uncompressed, then figure out if it's masking or the ratio, and fix that."
• Senior: "I baseline compressed vs uncompressed — the gap is the loss. Then I diagnose with the masking report: heavy masking concentrated near a non-scan memory means X-masking — the memory floods the compactor with X, we mask those chains, and masking also drops their real fault effects. The fix is at the source: initialize/bypass the memory in scan (and MBIST it, Ch8), so the chains need no masking, fault effects are observed again, and coverage recovers at the same ratio — keeping the test-cost win. Lowering the ratio wouldn't help (the driver is the X-source) and would cost test time. If instead masking were light but dense faults split, that'd be care-bit density → lower the ratio or add test points. Baseline, diagnose, localize, fix at the cause, re-baseline."

16. Interview / Review Questions

17. Key Takeaways

• Debug a compression coverage loss with a loop: baseline against uncompressed (the true achievable — the gap is the loss), diagnose the cause, localize, fix at the cause, re-baseline.
• The three causes (7.4): X-masking (X-sources corrupt the compactor → masked chains lose fault effects — most common), care-bit over-constraint (aggressive ratio → dense patterns split/drop), or a mask/compactor misconfiguration.
• Localize with the masking report: heavy masking concentrated near an X-source → X-masking; light masking with dense faults splitting → care-bit density; unexpected masking → misconfig.
• Fix at the cause: for the common X-masking case, reduce the X-source at its source (initialize/bypass/scan the memory, MBIST it — Chapter 8) → less masking → coverage recovers at the same ratio; don't lower the ratio for an X-masking loss (it sacrifices test time for little gain).
• This is the 6.3 X-source lesson at the compactor — and since a bypassed memory still needs its own test, it motivates MBIST (Chapter 8); with coverage recovered at full compression, the DPPM commitment (1.5) holds and the test-cost win (1.4) is kept. Next: Chapter 8 — Memory Test & MBIST (testing the memories scan/ATPG can't).

18. Quick Revision

Debugging a compression loss (Ch7 capstone). LOOP: (1) BASELINE compressed vs UNCOMPRESSED (true achievable, 6.5) → the GAP is the loss; (2) DIAGNOSE (7.4): X-masking (X-source) vs care-bit over-constraint (ratio) vs mask misconfig; (3) LOCALIZE via the MASKING REPORT (which chains masked, where); (4) FIX AT THE CAUSE — common case is X-masking → reduce the X-SOURCE at the source (init/bypass/scan the memory + MBIST Ch8) → less masking → coverage recovers AT THE SAME RATIO; else lower ratio / test points (care-bit) or fix mask config; (5) RE-BASELINE. Concrete: a non-scan MEMORY floods the compactor with X → heavy masking → coverage loss → initialize/bypass it → recovered at 30x. Don't lower the ratio for an X-masking loss (fix the source). Motivates MBIST (Ch8). Next: Chapter 8 — Memory Test & MBIST.