Why Test Time Is Money

Chapter 1 · Section 1.4 · Manufacturing Test Mindset

Project thread — the 4-bit counter's scan test, now measured in tester-seconds and shift cycles.

1. Why Should I Learn This?

Test time is a direct manufacturing cost, and understanding it explains half the DFT curriculum:

• Test cost/die = (tester $/second) × (seconds/die) — times millions of dies = a real BOM line.
• Scan shift dominates the seconds — chain length × patterns × shift cycles.
• Compression (Ch7) cuts shift time without cutting coverage — the biggest lever.
• Multi-site testing amortizes the tester across many dies at once.
• The real goal is coverage per test-second, not min time or max coverage alone.

2. Real Silicon Story — the coverage win that broke the budget

A team pushed ATPG coverage from 98% to 99.3% by adding patterns — a genuine quality win. Then the cost model came back: those extra patterns lengthened scan shift enough to raise test time per die by a noticeable fraction, and multiplied across tens of millions of dies, the added ATE time cost more than the escapes it prevented. Coverage went up; profit went down.

The fix wasn't to give the coverage back — it was to buy it more cheaply. With scan compression (Chapter 7), the same patterns shifted through many short chains from a few pins, cutting shift cycles dramatically, so coverage stayed at 99.3% while test time dropped below the original 98% budget. Lesson: coverage and test time are both costs, and the engineering goal is coverage per test-second — you don't choose between them, you make each second buy more coverage.

3. Concept — the cost model and where the seconds go

The test cost model:

• Test cost per die = (tester cost per second) × (test seconds per die).
• The tester (ATE) and handler are capital equipment costing millions; that cost is amortized over every die-second they run.
• Multiply per-die cost by production volume (millions of dies) → a real, large line item.

Where the test seconds go — scan shift dominates:

• A scan test shifts a pattern into the chains, captures one (or few) functional cycles, then shifts out the response while shifting in the next pattern.
• Shift cycles ≈ (scan-chain length) × (number of patterns) — and both are large, so shift dominates total test time; capture is a tiny fraction.
• Add multiple insertions (1.3) and the per-die time multiplies further.

The levers — buy coverage per second:

• Compression (Ch7): split one long chain into many short chains loaded from few pins via a decompressor → shift time falls by the compression ratio, coverage unchanged. Biggest lever.
• Pattern efficiency: fewer, denser patterns for the same coverage (ATPG optimization, Ch5).
• Balanced chains (Ch3): the longest chain sets shift time — balance chain lengths so none dominates.
• Multi-site / parallel test: test N dies simultaneously on one tester → the tester's cost is amortized across N dies.

The tension — coverage vs test time:

• Naively adding patterns raises coverage and shift time together.
• So the metric is coverage per test-second (efficiency), not minimum time or maximum coverage in isolation.

4. Mental Model — renting the world's most expensive stopwatch

Picture renting a machine by the second — an extraordinarily expensive stopwatch — and you must run every single part past it.

• The rental rate (tester $/second) is fixed and steep — it's capital equipment.
• Your bill = rate × seconds-per-part × number-of-parts. With millions of parts, every second per part is enormous in total.
• Most of each part's seconds are spent feeding a long tape through the machine — that's scan shift. The 'useful' moment (capture) is an instant; the feeding is what costs.
• Compression is like feeding several short tapes side-by-side instead of one giant tape — same information, far fewer seconds.
• Multi-site is renting one machine but testing several parts at once — you split the rental across them.
• You never just 'test faster by paying for a faster machine' — you feed less tape (compression) and share the rental (multi-site), while keeping the information (coverage) intact.

The game is maximum information per rented second — coverage per test-second.

5. Working Example — the counter's scan test time

Put representative numbers on the counter's scan test:

# Scan test-time model — REPRESENTATIVE (illustrative, order-of-magnitude):
  Scan-chain length        = 5,000 flops (one long chain)
  Number of patterns       = 2,000
  Shift cycles (approx)     = length x patterns = 5,000 x 2,000 = 10,000,000 shift cycles
  Shift clock              = 50 MHz  -> test time ~ 10,000,000 / 50e6 = 0.20 s/die  (shift DOMINATES; capture ~ negligible)
  Tester rate              = (some $/second)
  Cost/die = rate x 0.20 s ;  x 20,000,000 dies  ->  a large, real line item

Now apply the levers — coverage held constant:

# Levers (coverage UNCHANGED) — REPRESENTATIVE:
  COMPRESSION 10x : one 5,000 chain -> 10 chains of 500, loaded from few pins
                    shift cycles ~ 500 x 2,000 = 1,000,000  -> test time ~ 0.02 s/die  (10x cheaper, SAME coverage)
  MULTI-SITE 4x   : test 4 dies at once on one tester -> tester cost amortized /4 per die
  NAIVE +patterns : 2,000 -> 3,000 patterns for a little more coverage -> shift +50% -> cost +50%  (the trap)
# Metric that matters: COVERAGE PER TEST-SECOND. Compression + multi-site raise it; naive patterns lower it.

6. Industry Flow — where the test seconds are spent

Per pattern, the tester shifts in, captures, shifts out — and shift is nearly all of it:

7. Debugging Session — test cost per die is too high

8. Common Mistakes

• Ignoring test time until tapeout. Chain structure and compression are RTL/DFT-architecture decisions made early.
• Buying coverage with naive patterns. More patterns raise coverage and shift time — watch coverage per second.
• Thinking a faster tester is the fix. It doesn't reduce shift cycles — compression does.
• Dropping coverage to save time. That trades a small factory saving for a large field cost (escapes).
• Forgetting multi-site. Testing dies one at a time wastes the tester's amortizable capacity.

9. Industry Best Practices

• Budget test time early — it's driven by chain length, pattern count, and compression (design-time choices).
• Deploy scan compression — the single biggest test-time lever, at no coverage cost.
• Balance scan chains — the longest chain sets shift time; don't let one dominate.
• Use multi-site / parallel test — amortize the expensive tester across many dies.
• Optimize for coverage-per-second — the true efficiency metric, not raw time or raw coverage.

10. Senior Engineer Thinking

• Beginner: "Test cost is high — let's buy a faster tester or cut some patterns."
• Senior: "Shift is 95%+ of the seconds. A faster tester still shifts the same cycles; cutting patterns costs coverage (escapes). I compress (short chains from few pins) and balance chains to cut shift cycles, and go multi-site to amortize the tester — coverage stays, cost drops. The metric is coverage per test-second."

The senior attacks shift cycles and tester amortization, never coverage or raw tester speed.

11. Silicon Impact

Test time is one of the few DFT topics that shows up directly on the P&L. A fraction of a second of ATE time per die, multiplied by tens of millions of dies, is real money — enough that test cost can rival other line items in a high-volume product. Because scan shift dominates those seconds, the levers are architectural and set early: compression ratio (Ch7), chain count and balance (Ch3), and pattern efficiency (Ch5) — all rooted in the RTL's flop count and the DFT architecture. This is why the rest of the curriculum spends so much effort on efficiency: compression exists almost entirely to cut test time without cutting coverage, and it routinely delivers order-of-magnitude shift-time reductions. The trap to avoid in both directions is treating this as a single-variable problem — maximizing coverage while ignoring test time breaks the cost budget, and minimizing time by dropping coverage breaks quality (escapes, 1.2). The senior mindset holds both and optimizes coverage per test-second, which is exactly the quantity the whole scan/compression/ATPG stack is engineered to raise. Get this right and you ship high coverage at low test cost; get it wrong in either direction and you either overspend on the tester or underprotect the customer.

12. Engineering Checklist

• Built a test-time/cost model — tester $/s × seconds/die × volume.
• Confirmed scan shift dominates the seconds (profiled shift vs capture).
• Applied compression to cut shift cycles without cutting coverage.
• Balanced scan chains so the longest doesn't dominate.
• Used multi-site to amortize the tester; optimized for coverage per second.

13. Try Yourself

1. Model the counter's scan test: pick a chain length and pattern count, compute shift cycles and test time at a shift clock.
2. Multiply by a volume (say 20M dies) to see the total — feel how a fraction of a second scales.
3. Apply a 10× compression (chain length /10): recompute test time — note coverage is unchanged.
4. Apply 4-site parallel test: divide the per-die tester cost by 4.
5. Now add 50% more patterns naively — watch cost rise 50% for a small coverage gain, and compute coverage per second before/after to see why that's the wrong trade.

The arithmetic is tool-independent — a spreadsheet suffices. Real shift lengths and compression ratios come from the DFT/ATPG flow (Chapters 3, 5, 7). No paid tool required.

14. Interview Perspective

• Weak: "Testing takes time, which costs some money."
• Good: "Test cost is tester rate times test seconds per die; scan shift is most of the time."
• Senior: "Test cost per die = tester $/second × test seconds/die, times millions of dies — a real BOM line. Scan shift dominates the seconds (chain length × patterns); capture is an instant. So I cut cost by compression (many short chains from few pins → less shift, same coverage) and balanced chains, and I amortize the tester with multi-site. I never buy a faster tester to move the same shift, or drop coverage I need. The real metric is coverage per test-second."

15. Interview / Review Questions

16. Key Takeaways

• Test cost per die = (tester cost/second) × (test seconds/die) — and multiplied across millions of dies, it's a real, sometimes large, line item on the product's cost.
• Scan shift dominates the test seconds — shift cycles ≈ chain length × number of patterns — while capture is a negligible instant.
• Compression (Chapter 7) is the biggest lever: many short chains loaded from a few pins cut shift time by the compression ratio with coverage unchanged.
• Multi-site / parallel test amortizes the expensive tester across many dies at once; balanced chains stop the longest chain from dominating.
• The real objective is coverage per test-second — naive added patterns raise coverage and cost together, and neither a faster tester nor dropped coverage is the right answer. Next: 1.5 — DPPM & quality goals.

17. Quick Revision

Test time = money. Test cost/die = (tester $/s) × (seconds/die), × MILLIONS of dies → a real BOM line. SCAN SHIFT dominates the seconds (chain length × patterns); capture is an instant. Levers: COMPRESSION (many short chains from few pins → less shift, SAME coverage — Ch7), BALANCED chains (longest sets the time — Ch3), MULTI-SITE (test N dies at once, amortize the tester). Goal = coverage per test-second, not min time or max coverage alone. Not a faster tester (same shift) or dropped coverage (escapes). Next: 1.5 — DPPM & quality goals.