DFT · Chapter 9 · Logic BIST (LBIST)

Signature Analysis & Aliasing

A MISR compacts a huge response stream into a small fixed-width signature, and signature analysis compares the chip's signature to a precomputed good-machine value to decide pass or fail. The fundamental risk is aliasing: because compaction is lossy, many response streams map to the same signature, so a faulty stream can by chance produce the good signature and let the fault escape as a false pass. Aliasing can never be zero, but its probability is roughly one over two to the power of the MISR width, so a 32-bit MISR makes it negligible while a narrow one aliases far too often. This contrasts with per-pattern comparison on a tester, which has no aliasing but needs all the golden data. The signature also gives only pass or fail with no per-pattern diagnosis. You reduce aliasing by widening the MISR and taking multiple signatures.

Intermediate13 min readDFTSignature AnalysisAliasingMISRCompaction

Chapter 9 · Section 9.3 · Logic BIST (LBIST)

Project thread — the mini-SoC's LBIST MISR width is chosen here to make aliasing negligible; 9.4 keeps the signature valid (X-free), 9.5 deploys it.

1. Why Should I Learn This?

The signature is LBIST's whole result — so how reliably it reflects the truth (aliasing) and what it can't tell you (diagnosis) are essential.

Signature analysis: compare the chip's MISR signature to a precomputed golden → pass/fail.
Aliasing: a faulty stream compacts to the good signature → a false pass. Fundamental (lossy compaction).
P(alias) ~ 1 / 2^k for a k-bit MISR — a wide MISR (e.g. 32-bit) makes it negligible (not zero).
Signature = pass/fail only — no per-pattern diagnosis (vs ATPG). Mitigate with width + multiple signatures.

The five questions — signature analysis & aliasing

1 — Why does it exist? Because you can't ship all the golden response data for self-test — compaction into a signature is the only compact way to check on-chip.
2 — What manufacturing problem does it solve? It makes an on-chip pass/fail decision from a tiny signature — with aliasing as the controllable cost.
3 — What happens if it's mishandled? A narrow MISR → high aliasing → faulty parts pass (escapes, 1.5); or you forget you have no diagnosis.
4 — Which team owns it? DFT (MISR width, multiple signatures); verification (golden); safety (aliasing vs required coverage, 9.5).
5 — How does it connect up/down-stream? MISR (9.2) → signature analysis + aliasing (this lesson) → X keeps the signature valid (9.4) → in-field/safety coverage (9.5).

2. Real Silicon Story — the narrow MISR that let faults escape

To save a little area, a team used a narrow (8-bit) MISR for their LBIST. It worked in the lab — good parts passed, obviously-broken parts failed. Then the field escape rate was higher than expected for parts that had passed LBIST.

The cause was aliasing. With an 8-bit MISR, the aliasing probability is ~1/256 — so roughly 1 in 256 faulty response streams compacts to the same signature as the good machine and passes LBIST anyway. That's a real, non-negligible fraction of faulty parts escaping through a false pass — exactly the kind of latent escape LBIST was supposed to catch (9.5). The MISR was too narrow to make aliasing negligible.

Widening the MISR to 32 bits dropped aliasing to ~2^-32 — vanishingly small — and the escape rate through LBIST fell to negligible. Lesson: aliasing is fundamental (compaction is lossy, never zero), but its probability is ~1/2^k — so a wide-enough MISR makes it negligible, and a narrow MISR is a silent escape source.

3. Factory Perspective — signatures through each lens

What the DFT engineer sees: the MISR width (aliasing ~1/2^k) as a design knob, and whether multiple/intermediate signatures are needed for diagnosis.
What the yield/reliability engineer sees: that a narrow MISR is an aliasing-driven escape source (false passes) — a DPPM/safety risk (1.5).
What the verification engineer sees: that the golden signature must be exact (9.2), and that no per-pattern diagnosis means debugging a fail needs intermediate signatures or a rerun.
What management cares about: that MISR width trades tiny area for aliasing safety — an easy call for safety-critical parts (9.5) — and that LBIST can't diagnose (a support consideration).

4. Concept — compaction, aliasing, and the limits

Signature analysis (the check):

The MISR folds the entire response stream (all K patterns, all chains, all cycles) into one fixed-width signature.
A golden signature is precomputed by simulating the good machine for the exact config (9.2).
Compare: chip signature == golden → pass; != → fail.

Aliasing (the fundamental risk):

Compaction is lossy: the space of possible response streams is astronomically larger than the space of signatures, so many streams map to each signature.
Aliasing = a faulty stream mapping to the same signature as the good one → the fault escapes as a false PASS.
It can never be zero — a small signature cannot uniquely encode a huge space.

The aliasing probability (the controllable part):

For a k-bit MISR, P(aliasing) ~ 1 / 2^k (assuming the MISR spreads errors well — the LFSR feedback does).
8-bit → ~1/256 (bad — real escapes); 16-bit → ~1/65536; 32-bit → ~2^-32 (negligible).
So MISR width directly controls aliasing — wider = safer, at tiny area cost.

The contrast with per-pattern compare (ATPG):

ATPG on a tester compares every response exactly → no aliasing, and full per-pattern diagnosis — but needs all the golden data and a tester.
LBIST trades a negligible (with a wide MISR) aliasing risk for a tiny signature and no tester.

The other limitation — no diagnosis:

The signature is pass/fail only: a fail says something is wrong, not which pattern or fault (unlike ATPG's per-pattern data).
Mitigations: multiple / intermediate signatures (snapshot the MISR at several points) → narrows aliasing further and gives limited diagnosis (which segment failed); rerun with ATPG for full diagnosis.

Figure 1 - signature compaction and aliasing (representative). A HUGE response stream (all K patterns x chains x cycles) is folded by the MISR into ONE small signature. Because the stream space is ASTRONOMICALLY larger than the signature space, compaction is LOSSY: many streams map to each signature. ALIASING = a FAULTY stream mapping to the SAME signature as the GOOD machine -> a FALSE PASS (the fault escapes). Aliasing is FUNDAMENTAL (never zero) but its probability is ~1/2^k for a k-bit MISR -> a WIDE MISR (e.g. 32-bit -> ~2^-32) makes it negligible; a NARROW MISR (8-bit -> ~1/256) lets faults escape.

5. Mental Model — a checksum on a huge file

A signature is like a checksum (hash) over a giant file — compact, fast to compare, but not injective.

You don't email someone the entire file to prove it's correct — you send a short checksum (the signature). They recompute it and compare. Match → almost certainly the same file.
'Almost' is the catch: a checksum is much smaller than the file, so different files can share a checksum (a collision — aliasing). A corrupted file could, by bad luck, have the same checksum as the good one and pass — a false OK.
Collisions are fundamental (you can't uniquely represent every possible file in a few bytes) — but a longer checksum makes them astronomically unlikely: a 32-bit checksum collides ~1 in 4 billion, a short one far more often. So you choose a wide checksum for anything that matters.
And a checksum tells you 'the file is wrong', not which byte — no diagnosis. If you need to know where, you keep checksums of sections (intermediate signatures).

A signature is a checksum of the chip's responses — pick it wide enough that collisions (aliasing) are negligible, and remember it says wrong, not where.

6. Working Example — MISR width vs aliasing

Put numbers on aliasing and the diagnosis limit:

Azvya Education Pvt. Ltd.VLSI Mentor

Snippet

# Signature analysis + aliasing - REPRESENTATIVE, SIMPLIFIED, tool-neutral:
  Response stream: K=10,000 patterns x 120 chains x ~170 cycles -> ~200 MILLION response bits
  MISR compacts ALL of that into a k-bit SIGNATURE:
    k = 8  bits -> P(alias) ~ 1/2^8  = ~1/256      -> a real fraction of faulty parts PASS (escape!) -> BAD
    k = 16 bits -> P(alias) ~ 1/2^16 = ~1/65,536
    k = 32 bits -> P(alias) ~ 1/2^32 = ~2.3e-10    -> NEGLIGIBLE (never zero) -> GOOD
  -> ALIASING is fundamental (lossy compaction) but its probability ~ 1/2^k -> choose a WIDE MISR.
# vs ATPG per-pattern compare (tester): NO aliasing (every response checked) but needs ALL golden data + a tester.

Azvya Education Pvt. Ltd.VLSI Mentor

Snippet

# The no-diagnosis limit + mitigation - REPRESENTATIVE:
  A single final signature: FAIL tells you SOMETHING is wrong, NOT which pattern/fault (no diagnosis).
  MITIGATION: MULTIPLE / INTERMEDIATE signatures -- snapshot the MISR after segments (e.g. every 1000 patterns)
    -> narrows aliasing further AND localizes the failing SEGMENT (limited diagnosis) ; rerun ATPG for full diagnosis.
# Signature = compact pass/fail; diagnosis is ATPG's strength (Ch5). LBIST + ATPG complement (9.1).

7. Industry Flow — precompute golden, run, compact, compare

Signature analysis is a compact check with a fundamental (but controllable) aliasing risk:

Figure 2 - signature analysis flow (representative). PRECOMPUTE the GOLDEN signature by simulating the good machine for the exact config (9.2). RUN LBIST: the PRPG drives K patterns, the MISR ACCUMULATES all responses into a signature (lossy compaction). COMPARE the chip signature to golden -> pass/fail. The ALIASING RISK (a faulty stream matching the good signature -> false pass) is ~1/2^k -> a WIDE MISR makes it negligible. For DIAGNOSIS (which the single signature lacks), take MULTIPLE/INTERMEDIATE signatures or rerun ATPG. Choose MISR width for aliasing; add intermediate signatures for diagnosis.

8. Debugging Session — a narrow MISR lets faults escape

LBIST passes obviously-broken parts sometimes and the field escape rate through LBIST is higher than expected; the MISR is narrow (8-bit) so aliasing probability is ~1/256, meaning a real fraction of faulty response streams compact to the good signature and pass -- the fix is to widen the MISR (e.g. 32-bit) to make aliasing negligible, understanding aliasing is fundamental but controllable by width

ALIASING ~1/2^k — A NARROW MISR IS A SILENT ESCAPE SOURCE; WIDEN IT

Symptom

Parts that passed LBIST are escaping to the field at a higher-than-expected rate — and occasionally a known-faulty part passes LBIST in the lab. The MISR is narrow (8-bit), chosen to save area.

Root Cause

The MISR is too narrow, so aliasing — a faulty response stream compacting to the good signature — happens at a non-negligible rate (~1/256 for 8 bits), letting a real fraction of faulty parts pass LBIST as false passes. Signature analysis is inherently lossy: the MISR folds an astronomically large response stream into a k-bit signature, so many streams map to each signature — aliasing is fundamental and can never be zero. What makes it manageable is that its probability is ~1/2^k, so the MISR width is the knob. At k = 8, P(aliasing) ~ 1/256 — meaning roughly 1 in 256 faulty response streams coincidentally produces the same signature as the good machine and passes. Across a production run, that's a real, steady fraction of faulty parts escaping through a false pass — precisely the latent/field escapes LBIST exists to prevent. The narrow MISR wasn't 'broken'; it was under-sized for the job, trading a tiny area saving for a ~0.4% aliasing escape — a bad trade for any quality-sensitive part, and a dangerous one for safety (9.5). (This is distinct from an X corrupting the signature, 9.4 — here the signature is valid, it just collides.)

Fix

Widen the MISR so aliasing is negligible — a 32-bit MISR gives ~2^-32 aliasing — and add intermediate signatures if diagnosis is needed; aliasing is fundamental but controllable by width. Increase the MISR width (e.g. 8 → 32 bits): aliasing drops from ~1/256 to ~2.3e-10, i.e. from a real escape rate to effectively never, at a tiny area cost (a few dozen flops + XORs). Confirm the good-machine golden is recomputed for the wider MISR (config change → new golden, 9.2). If the part also needs diagnosis (LBIST gives none from a single signature), add multiple/intermediate signatures (snapshot the MISR per segment), which both narrow aliasing further and localize the failing segment, and rerun ATPG on the tester for full per-fault diagnosis. The principle to lock in: signature analysis compacts a huge response stream into a small signature compared to a precomputed golden, so it is fundamentally lossy and subject to aliasing — a faulty stream compacting to the good signature (a false pass) — which can never be zero but has probability about 1/2^k for a k-bit MISR, so a wide MISR (e.g. 32-bit) makes aliasing negligible while a narrow one (8-bit ~1/256) is a silent escape source; and because a single signature gives pass/fail with no per-pattern diagnosis, use multiple or intermediate signatures (or an ATPG rerun) when localization is needed. (The MISR is 9.2; X corrupting the signature is 9.4; ATPG's per-pattern diagnosis is Chapter 5; safety coverage is 9.5.)

9. Common Mistakes

Under-sizing the MISR to save area. P(alias) ~ 1/2^k — a narrow MISR is a silent escape source; go wide (e.g. 32-bit).
Believing aliasing can be zero. It can't (lossy compaction) — only made negligible by width.
Expecting diagnosis from a signature. It's pass/fail only — use intermediate signatures or ATPG rerun.
Forgetting the golden must match the (wider) config. Change k → recompute golden (9.2).
Comparing LBIST to ATPG on diagnosis. ATPG has per-pattern diagnosis and no aliasing — LBIST complements it (9.1).

10. Industry Best Practices

Choose a wide MISR (e.g. 32-bit) so aliasing (~1/2^k) is negligible — tiny area for big safety.
Recompute the golden whenever the config (including MISR width) changes.
Use multiple/intermediate signatures for limited diagnosis and extra aliasing margin.
Rerun ATPG (tester) for full diagnosis of an LBIST fail.
Size aliasing to the safety/DPPM requirement (9.5/1.5) — never let it be an escape source.

11. Senior Engineer Thinking

Beginner: "LBIST passes good parts and fails bad ones — the signature works."
Senior: "How wide is the MISR? Aliasing ~1/2^k — an 8-bit MISR aliases ~1/256, so a real fraction of faulty parts pass (escapes). I go 32-bit → ~2^-32, negligible. Aliasing is fundamental (lossy), never zero — I just make it negligible. And a signature has no diagnosis — for that I use intermediate signatures or rerun ATPG."

The senior sizes the MISR width to make aliasing negligible and knows the signature can't diagnose.

12. Silicon Impact

Signature analysis is the efficiency that makes LBIST possible — replacing hundreds of millions of response bits with one small number compared on-chip — and aliasing is the fundamental cost of that efficiency, the property every DFT engineer must quantify and control. The key facts are simple and unforgiving: compaction is lossy, so aliasing (a faulty stream matching the good signature → a false pass) can never be zero; but its probability is ~1/2^k for a k-bit MISR, so it is fully controllable by width — a 32-bit MISR makes it ~2^-32 (negligible), while a narrow one (8-bit → ~1/256) is a silent, steady escape source that defeats the purpose of LBIST (the story) and is outright dangerous for safety parts (9.5). This makes MISR width a real quality knob: a few dozen flops buy the difference between negligible and percent-level aliasing escapes — an easy call. The contrast with ATPG frames the trade cleanly: per-pattern comparison on a tester has no aliasing and full diagnosis, but needs all the golden data; LBIST trades a negligible (well-sized) aliasing risk for a tiny signature and tester-independence — the two are complementary (9.1). The other limitation — a signature gives pass/fail with no per-pattern diagnosis — is why multiple/intermediate signatures exist (extra aliasing margin plus segment-level localization) and why a serious LBIST fail is often rerun under ATPG for full diagnosis. For the DFT/safety engineer, the takeaway is to size the MISR so aliasing is negligible against the DPPM/safety requirement (1.5/9.5) and to plan for the no-diagnosis limit — the groundwork for keeping the mini-SoC's LBIST signature both valid (X-free, 9.4) and trustworthy as it moves to in-field/safety duty (9.5).

13. Engineering Checklist

Chose a MISR width so aliasing (~1/2^k) is negligible vs the DPPM/safety requirement (e.g. 32-bit).
Recomputed the golden for the exact config (including MISR width, 9.2).
Added multiple/intermediate signatures if diagnosis or extra aliasing margin is needed.
Planned ATPG rerun (tester) for full diagnosis of an LBIST fail.
Confirmed aliasing is not an escape source (wide MISR) — distinct from X corrupting the signature (9.4).

14. Try Yourself

Explain why compaction is lossy and therefore aliasing can never be zero.
Compute P(aliasing) for 8-, 16-, and 32-bit MISRs (~1/2^k) — note the escape implication of 8-bit.
Contrast LBIST signature (aliasing, no diagnosis) with ATPG per-pattern compare (no aliasing, full diagnosis).
Add intermediate signatures and explain how they narrow aliasing and give segment diagnosis.
Size a MISR width so aliasing is negligible against a target DPPM/safety level (9.5/1.5).

The math is tool-neutral. Real signatures/aliasing come from the LBIST flow. No paid tool required to reason about aliasing.

15. Interview Perspective

Weak: "The MISR makes a signature you compare to a good one."
Good: "Compaction is lossy so a faulty response can alias to the good signature; a wider MISR reduces that."
Senior: "Signature analysis compares the MISR's compacted signature to a precomputed golden → pass/fail. The fundamental risk is aliasing: because compaction is lossy (a huge response stream → a small signature), a faulty stream can coincidentally produce the good signature → a false pass. Aliasing can't be zero, but its probability is ~1/2^k for a k-bit MISR — 8-bit ~1/256 (a real escape source), 32-bit ~2^-32 (negligible) — so MISR width is the knob. Versus ATPG per-pattern compare: no aliasing and full diagnosis, but needs all golden data and a tester — LBIST trades a negligible (wide-MISR) aliasing risk for a tiny signature. And a signature is pass/fail only — no per-pattern diagnosis — so for localization I use intermediate signatures or rerun ATPG."

16. Interview / Review Questions

17. Key Takeaways

Signature analysis compacts the entire response stream into one small signature compared to a precomputed golden → pass/fail — the efficiency that makes on-chip self-test feasible.
Aliasing — a faulty stream compacting to the good signature (a false pass) — is fundamental because compaction is lossy (many streams map to each signature) and can never be zero.
Its probability is ~1 / 2^k for a k-bit MISR, so MISR width controls it: 8-bit ~1/256 (a real escape source), 32-bit ~2^-32 (negligible) — wider is safer, at tiny area.
Per-pattern comparison (ATPG on a tester) has no aliasing and full diagnosis but needs all golden data — LBIST trades a negligible (wide-MISR) aliasing risk for a tiny signature and tester-independence (complementary, 9.1).
A single signature is pass/fail only — no per-pattern diagnosis — so use multiple/intermediate signatures (also extra aliasing margin) or rerun ATPG to localize; size aliasing against the DPPM/safety requirement (1.5/9.5). Next: 9.4 — X-handling & X-bounding in LBIST.

18. Quick Revision

Signature analysis & aliasing. The MISR compacts a HUGE response stream into ONE small SIGNATURE, compared to a precomputed GOLDEN → pass/fail. ALIASING = a FAULTY stream compacting to the GOOD signature → a FALSE PASS (escape). It's FUNDAMENTAL (compaction is lossy, never zero) but P(alias) ~ 1/2^k for a k-bit MISR → 8-bit ~1/256 (bad, real escapes); 32-bit ~2^-32 (negligible) → WIDEN the MISR (tiny area). vs ATPG per-pattern compare: NO aliasing + full diagnosis, but needs ALL golden + a tester. Signature = pass/fail ONLY, NO diagnosis → use multiple/intermediate signatures (localize + extra margin) or rerun ATPG. Size aliasing to the DPPM/safety need. Next: 9.4 — X-handling & X-bounding in LBIST.