Triaging the First Point of Divergence

Chapter 12 · Section 12.2 · GLS Debug Methodology

Project thread — first-divergence anchored every debug in this book. This lesson generalizes it; 12.3 traces the first-divergence signal through the waveform to its source.

1. Why Should I Learn This?

First divergence is the difference between fixing the cause and chasing the symptoms.

• Everything after the first divergence is downstream propagation.
• Fix the first divergence → the wall of later symptoms clears.
• Method: earliest failure, confirm not-downstream, bisect, backward-trace.

It's the single highest-leverage technique — the anchor of 12.1's funnel.

2. Real Silicon Story — the debug that fixed the wrong flop

A team debugging a gate-level X fixed a flop that was clearly wrong in the waveform — but the failure persisted.

They had fixed a downstream symptom. The flop they fixed was X because an earlier flop (the first divergence) was X and propagated to it. Patching the downstream flop did nothing — the source kept re-injecting X. Finding the earliest wrong signal (a different, upstream flop) and fixing that cleared the entire failure, including the flop they'd been patching.

Lesson: debug the first divergence, not a conspicuous later one. A late failure is usually downstream of the real source — fix the source and the symptoms clear.

3. Concept — finding and using the first divergence

Why first divergence is the anchor:

• One root event (an X, a wrong value) propagates downstream (Ch6) into many later symptoms.
• The first divergence is the source-side point — closest to the root cause.
• Fix it → the downstream wall clears (they were all propagation).

How to find it:

1. Collect all failures (mismatches, Xs, violations) with timestamps.
2. Sort in time; take the earliest.
3. Confirm it's not itself downstream — trace one hop back: is its input already wrong at an even earlier time? If so, that's the real first divergence — repeat.
4. Bisect the window if the failure is far in: binary-search in time (halve the run, see which half diverges) to narrow when it first appears — efficient for long runs.

Then:

• Backward-trace the first-divergence signal to its source (12.3) and classify (12.1's categories).

The payoff:

• One sourced fix clears the wall — versus N wasted fixes on downstream symptoms.

Scope (accuracy):

• First divergence anchors functional/X/mismatch debug; it's a localization technique, tool-independent. GLS stays dynamic (0.3).

4. Mental Model — find where the river was first poisoned

A failure is a poisoned river — X (the poison) flows downstream.

• Downstream, many fish are sick (a wall of symptoms) — but treating fish downstream is useless while the poison keeps flowing.
• Walk upstream to find where the poison first enters (the first divergence) — the source.
• Stop it at the source and the whole river clears downstream.
• If the river is long, check the midpoint (bisect): is the water clean here? Then the source is downstream of this point; poisoned? Upstream — halve again.

Find where the river was first poisoned, plug it there — don't treat downstream fish.

5. Working Example — finding the first divergence

Finding the earliest failure (tool-neutral):

# First-divergence triage — REPRESENTATIVE (tool-neutral)
# failures collected with timestamps:
#   t=45  q_reg[7] = X
#   t=30  q_reg[3] = X
#   t=20  q_reg[1] = X   <- EARLIEST
#   t=50  out[2]   = X
# 1) earliest = q_reg[1] @ t=20
# 2) confirm not downstream: is q_reg[1].D already X before t=20? -> trace one hop back
#      if q_reg[1].D was driven X by u_src @ t=18 -> u_src is the REAL first divergence -> repeat
# 3) bisect (long run): does the failure exist at t=10? no -> between 10 and 20 -> narrow
# 4) backward-trace q_reg[1] (or u_src) to its SOURCE (12.3) -> classify (12.1) -> fix
# fixing the first divergence clears q_reg[3], q_reg[7], out[2] (all downstream).

Practical context (representative, tool-neutral):

# First-divergence method (tool-neutral):
#   1) dump failures WITH timestamps (mismatches, X, violations)
#   2) sort in time -> take the EARLIEST
#   3) confirm not-downstream: trace one hop back (is the input already wrong earlier?)
#   4) bisect the window in time for long runs (binary search when it first appears)
#   5) backward-trace to source (12.3), classify (12.1), fix -> downstream wall clears

First divergence vs downstream symptoms, as a real waveform:

6. Debugging Session — fixing a downstream symptom instead of the source

7. Common Mistakes

• Debugging the most conspicuous (usually latest) failure. It's downstream propagation.
• Not timestamping failures. You can't find the earliest without times.
• Not confirming not-downstream. The "earliest" may still be downstream of something earlier — trace one hop back.
• Not bisecting long runs. Binary-search in time to find when it first appears.
• Fixing symptoms, not the source. One sourced fix clears the wall.

8. Industry Best Practices

• Collect failures with timestamps and sort in time.
• Take the earliest, confirm it isn't downstream (one hop back).
• Bisect the failing window for long runs.
• Backward-trace to source (12.3) and fix there.
• Verify the wall clears after the source fix.

Senior Engineer Thinking

• Beginner: "This signal is clearly X — let me fix it."
• Senior: "Is it the first divergence, or downstream of an earlier one? Let me sort failures in time, take the earliest, confirm it isn't itself downstream, and trace that to the source. Fixing a late symptom won't help."

The senior always locates the first divergence before touching anything.

Silicon Impact

First-divergence triage is the highest-leverage debug technique because gate-level failures fan out: one root X becomes a wall of downstream symptoms (Ch6). Debugging a late symptom wastes effort and, worse, can "fix" the wrong thing — patching a downstream signal that masks the visible failure while the real source still ships (0.3). Finding the earliest wrong signal, confirming it's not itself downstream, and tracing that to source turns a wall of X into a single sourced fix — fast and correct. Because every gate-level debug (FSM X, timing-injection flood, scan X) reduces to this, mastering first-divergence triage is what makes the whole methodology (12.1) work, and what keeps real root causes from hiding behind their own propagation.

Engineering Checklist

• Collected failures with timestamps; sorted in time.
• Took the earliest as the first-divergence candidate.
• Confirmed not-downstream (traced one hop back).
• Bisected the window for long runs.
• Backward-traced to source (12.3) and fixed there — wall cleared.

Try Yourself

1. Take a failure with a wall of X and collect the failing signals with timestamps.
2. Observe: the most conspicuous X is usually the latest (most fanned-out) — not the source.
3. Change: sort in time, take the earliest, confirm it isn't downstream (trace one hop back), and fix that source.
4. Expect: the entire wall clears from one fix — proving the later Xs were downstream propagation.

First-divergence triage is a discipline, tool-independent (any simulator with timestamped dumps). No paid tool required.

Interview Perspective

• Weak: "I fix the signal that's obviously wrong."
• Good: "I find the first point of divergence — the earliest wrong signal — because later ones are downstream."
• Senior: "First divergence is the anchor: I collect failures with timestamps, take the earliest, confirm it isn't itself downstream (trace one hop back), bisect the window for long runs, and backward-trace to source. Everything after the first divergence is propagation, so one sourced fix clears the wall — debugging a conspicuous late symptom just chases fanout."

9. Interview / Review Questions

10. Key Takeaways

• The first point of divergence — the earliest time/signal where behavior first goes wrong — is the source-side anchor of every gate-level debug.
• Everything after it is downstream propagation (Ch6), so fixing the first divergence clears the wall of later symptoms; debugging a later (often more conspicuous) failure just chases fanout.
• Find it: collect failures with timestamps → sort in time, take the earliest → confirm it isn't itself downstream (trace one hop back) → bisect the window in time for long runs.
• Then backward-trace the first-divergence signal to its source (12.3), classify (12.1), and fix at the source — the wall clears.
• First-divergence is a localization technique, tool-independent — the highest-leverage step in the funnel; GLS stays dynamic (STA/static-CDC/ATPG own their signoffs, 0.3/9.1/11.1). Next: 12.3 — waveform debugging at the gate level.

Quick Revision

First point of divergence = earliest wrong signal/time = the source-side anchor. Everything after it is downstream propagation (Ch6) — fix the first divergence, the wall clears. Method: failures + timestamps → sort → earliest → confirm not-downstream (one hop back) → bisect window → backward-trace to source (12.3) → fix. Debugging a conspicuous late symptom chases fanout. The highest-leverage step of the funnel. Next: 12.3 — waveform debugging at the gate level.