GLS Debug Drills

Chapter 15 · Section 15.3 · Interview & Signoff Review Preparation

Project thread — drills build the reflex from the whole book's method. 15.1 concepts, 15.2 scenario walk, 15.3 drills, 15.4 signoff checklist, 15.5 readiness self-assessment.

1. Why Should I Learn This?

Knowing the method (15.2) isn't enough — you need it to fire automatically, and that takes reps.

• Drills = symptom → method → root cause → fix, across every class.
• Repetition turns a deliberate procedure into a reflex.
• The reflex is what a whiteboard and a 2 a.m. failure both need.

This is the practice half of interview prep (15.1 concepts, 15.2 walk).

2. Real Silicon Story — the engineer who'd done the reps

Two engineers hit a wall of gate-level X before tape-out. One deliberated — "where do I even start?" — and lost hours. The other, who'd done the drills, immediately ran the reflex: real-vs-artifact (real) → first divergence (one flop) → trace (unreset flop) → fix (reset) — root cause in minutes.

Same knowledge, different fluency. The drilled engineer didn't think about the method; the method fired automatically, the way a trained response does under pressure.

Lesson: the method must be a reflex, not a recollection. Drills — running symptom → method → root cause across the classes, repeatedly — are what build that fluency for the whiteboard and the real chip.

3. Concept — the drill loop and the class coverage

The drill loop (identical every time):

1. Symptom — a wall of X, a $hold firing, a scan mismatch, a bus glitch, etc.
2. Apply the funnel (12.1) — real-vs-artifact first (expected X / setup issue vs real bug, 8.4/12.6).
3. First divergence (12.2) — the earliest wrong signal/time.
4. Trace to source (12.3) — backward through the logic to the root.
5. Root cause + fix — name it, fix at the source.

Cover every class (so the reflex generalizes):

• X-source (Ch6): wall of X → trace to uninitialized flop / contention / unknown input.
• Timing (Ch8): $setup/$hold firing → real path vs artifact (corner/stimulus); hold = period-independent.
• Reset (Ch7): power-up X not clearing → reset gap / held reset / recovery-window release.
• CDC (Ch9): crossing X / reconvergence glitch → synchronizer / gray-code; can't model metastability.
• Low-power (Ch10): corruption on power-down → expected; check isolation/retention/sequencing.
• DFT (Ch11): every pattern mismatches → chain-level X / test-mode reset; pattern GLS ≠ coverage.
• Testbench (Ch5): false mismatch → edge sampling / edge-aligned stimulus (fix the run).

The point (accuracy):

• Repetition → reflex. The value isn't any single drill; it's running the same method across all classes until it's automatic. GLS is dynamic (0.3).

4. Mental Model — muscle memory, not a manual

Debug drills build muscle memory, the way a musician or athlete trains.

• You don't want to read the manual (recall the method) during the performance — you want the hands to know (the reflex fires).
• Scales and drills (symptom → method → root cause, repeated) build that — boringly, repeatedly, across many keys (classes).
• Under pressure (a whiteboard, a 2 a.m. failure), trained reflexes hold while deliberation crumbles.
• The specific drill doesn't matter; the reps across variety do — that's what makes the reflex general.

Run the scales until the method is muscle memory — then the performance takes care of itself.

5. Working Example — a drill set

A representative drill set (symptom → method → root cause):

# GLS DEBUG DRILLS - REPRESENTATIVE (symptom -> apply method -> root cause -> fix):
# DRILL 1 (X-source): wall of X on outputs
#   -> real-vs-artifact: real. first divergence: one flop. trace: UNRESET flop. fix: reset (Ch6/7)
# DRILL 2 (timing): $hold firing on a flop
#   -> real-vs-artifact: real (persists, fast corner, STA confirms). fix: add delay/skew (NOT slow clock, Ch8)
# DRILL 3 (reset): counter stuck at 0000 forever
#   -> value=0000 (not X) -> reset HELD asserted (polarity). fix: release reset (Ch7)
# DRILL 4 (CDC): a status bit glitches crossing domains
#   -> reconvergence of independently-synced bits. fix: synchronize a SINGLE signal (Ch9)
# DRILL 5 (low-power): a domain's outputs go X on power-down
#   -> EXPECTED corruption (10.2). check: does isolation clamp it? (Ch10)
# DRILL 6 (DFT): every scan pattern mismatches
#   -> chain-level X -> test-mode reset not applied. fix: reset chain before shift (Ch11)
# DRILL 7 (testbench): output mismatches every cycle on a correct netlist
#   -> edge sampling (reads pre-clk-to-Q). fix: strobe after settle (Ch5)
# Run them until the method fires AUTOMATICALLY.

Practical context (representative, tool-neutral):

# How to drill (tool-neutral):
#   1) pick a symptom (from a drill set / a past bug)
#   2) run the loop OUT LOUD: real-vs-artifact -> first divergence -> trace -> root cause -> fix
#   3) cover ALL classes (X/timing/reset/CDC/power/DFT/TB) so the reflex generalizes
#   4) time yourself; repeat until the method fires without deliberation
#   -> the goal is the REFLEX, not memorizing any single drill's answer

A drill symptom to diagnose (a $hold firing), as a real waveform:

6. Debugging Session — running a drill

7. Common Mistakes

• Memorizing drill answers instead of practicing the method.
• Drilling one class — cover all (X/timing/reset/CDC/power/DFT/TB) so the reflex generalizes.
• Skipping real-vs-artifact as the first move (12.1).
• Not timing yourself — pressure is part of the reflex.
• Deliberating instead of executing — the reflex is the goal.

8. Industry Best Practices

• Drill the loop across all classes until it's automatic.
• Run drills out loud and timed (whiteboard/pressure realism).
• Start every drill with real-vs-artifact (12.1).
• Use real past bugs as drills (they're the best symptoms).
• Rotate classes so the reflex is general, not narrow.

Senior Engineer Thinking

• Beginner: "I know the method — I'll recall it when I need it."
• Senior: "Under pressure, recall crumbles, reflex holds. I drill the loop across all classes until real-or-artifact → first divergence fires automatically — so a wall of X doesn't make me freeze, it makes me move."

The senior drills the method to reflex, so it executes under pressure without deliberation.

Silicon Impact

Drills convert knowing the method into executing it fast under pressure — and that fluency has direct silicon value: a real gate-level failure before tape-out is a time-critical event, and the engineer whose method is a reflex finds the root cause in minutes while the one who deliberates loses hours (or, freezing, guesses and mis-fixes, letting a bug ship, 0.3). The drilled reflex — real-vs-artifact first, first divergence, trace to source — is also what keeps debug honest under pressure: the temptation to waive a real X or disable checks to "make it pass" is strongest at 2 a.m., and a trained reflex resists it (the method says classify, don't silence). Preparing for the whiteboard (15.2) and building the on-the-job reflex are the same practice: reps across the classes until the method is muscle memory.

Engineering Checklist

• Ran the drill loop (real-vs-artifact → first divergence → trace → fix) across all classes.
• Practiced out loud and timed (whiteboard/pressure realism).
• Started every drill with real-vs-artifact (12.1).
• Used real past bugs as drills.
• Repeated until the method fires by reflex (no deliberation).

Try Yourself

1. Take the drill set above and run each out loud, timed — symptom → real-vs-artifact → first divergence → trace → root cause → fix.
2. Observe: the loop is identical across classes — only the symptom and source change.
3. Change: add drills from your own past bugs and rotate through all classes.
4. Expect: with reps, the method fires automatically — a symptom triggers "real or artifact? then first divergence" without deliberation. That's the reflex you want for the whiteboard and the real chip.

Drilling is a discipline, tool-independent. No paid tool required.

Interview Perspective

• Weak: "I understand the debug steps."
• Good: "I practice the method on different symptoms so I can apply it quickly."
• Senior: "I drill the loop — real-vs-artifact first, first divergence, trace to source — across every failure class (X/timing/reset/CDC/power/DFT/TB) until it's a reflex. Under pressure, a wall of X or a $hold firing doesn't make me deliberate; the method fires automatically and I land the root cause fast. It's the same fluency the whiteboard and a real tape-out failure both demand."

9. Interview / Review Questions

10. Key Takeaways

• Debug drills build the reflex — where 15.1 was concepts and 15.2 was the scenario walk, drills are repetition until the method is automatic.
• The drill loop is identical every time: symptom → apply the funnel (real-vs-artifact first, 12.1) → first divergence (12.2) → trace to source (12.3) → root cause → fix.
• Cover every failure class — X-source (Ch6), timing (Ch8), reset (Ch7), CDC (Ch9), low-power (Ch10), DFT (Ch11), testbench (Ch5) — so the reflex generalizes to novel symptoms.
• The value is not any single drill's answer — it's running the same method across all classes, repeatedly, timed, out loud, until it fires without deliberation.
• The reflex is what a whiteboard (15.2) and a real 2 a.m. tape-out failure both demand — and it keeps debug honest under pressure (classify, don't silence); GLS is dynamic (0.3). Next: 15.4 — GLS signoff review checklist.

Quick Revision

Debug drills = build the REFLEX (recall crumbles under pressure; reflex holds). Drill loop (identical every time): symptom → real-vs-artifact FIRST (12.1) → first divergence (12.2) → trace to source (12.3) → root cause → fix. Cover ALL classes (X/timing/reset/CDC/power/DFT/TB) so it generalizes. Run out loud, timed, repeatedly — the goal is the reflex, not memorized answers. Next: 15.4 — GLS signoff review checklist.