Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • How to Use This Course
  • Reading Path
  • STA Glossary
  • STA Metrics Reference
  • STA Mastery Cheatsheet
  • Timing Paths and Checks16
  • Constraints & SDC Fundamentals20
  • Delay Graph & Path Analysis16
  • Beyond Setup and Hold16
  • Multi-Corner Multi-Mode Signoff16
  • OCV, AOCV, POCV and Variation16
  • Crosstalk and Noise16
    • Delta Delay Mechanism
    • Noise and Glitch Analysis
      • Glitch Height and Width
      • Noise Immunity
      • Functional Failure Risk
      • Noise Review
    • SI ECO Fix Order
    • SI Signoff Reports
  • ECO and Closure16
  • STA Debug Playbook16
  • STA Interview Prep26
  • Capstone Timing Signoff Lab4
Loading lesson

‹Noise and Glitch Analysis
  1. Topics
  2. Static Timing Analysis
  3. Crosstalk and Noise
  4. Noise and Glitch Analysis
  5. Glitch Height and Width

Part 7 · Crosstalk and Noise · All levels

Glitch Height and Width

A quiet victim held by its driver sees a pulse whose height depends on the coupling ratio, the aggressor's edge rate and the victim's time constant.

On this page

    Why it matters

    The simplest bound on a coupled glitch is a capacitive divider, but real glitches are smaller because the victim driver holds the net while the aggressor moves. The reduction depends on how fast the aggressor switches compared with how fast the victim recovers. Understanding the dependence tells you which fixes work.

    The model

    Diagram
    upper bound (aggressor infinitely fast, victim not held):  V_peak = Vdd * Cc / (Cc + Cg)
    victim held by a driver R, aggressor ramp of duration Tr, tau = R * (Cc + Cg):
    V_peak = (Cc * R * Vdd / Tr) * (1 - exp(-Tr / tau))
    example.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    import math
    Vdd, Cc, Cg, R = 0.8, 6.0, 8.0, 2000.0          # volt, fF, fF, ohm (illustrative)
    tau = R * (Cc + Cg) / 1000.0                    # ps
    def peak(R_ohm, tr_ps, tau_ps):
        return (Cc * R_ohm / 1000.0) * Vdd / tr_ps * (1 - math.exp(-tr_ps / tau_ps))
    bound = Vdd * Cc / (Cc + Cg)
    fast = peak(R, 10.0, tau)
    slow = peak(R, 40.0, tau)
    strong = peak(1000.0, 10.0, 1000.0 * (Cc + Cg) / 1000.0)
    assert round(tau, 1) == 28.0
    assert round(bound, 3) == 0.343 and round(fast, 3) == 0.288 and round(slow, 3) == 0.182 and round(strong, 3) == 0.245
    assert slow < fast < bound and strong < fast
    print("PASS: bound", round(bound, 3), "V; fast aggressor", round(fast, 3), "; slow aggressor", round(slow, 3), "; stronger victim driver", round(strong, 3))

    Case

    Peak (V, 0.8 V supply)

    Why

    Upper bound (infinitely fast aggressor, no holding)

    0.343

    Pure capacitive divider Cc/(Cc+Cg)

    Aggressor edge 10 ps, victim driver 2 kΩ

    0.288

    Driver holds the net a little during the edge

    Aggressor edge 40 ps, victim driver 2 kΩ

    0.182

    A slower edge gives the driver time to hold

    Aggressor edge 10 ps, victim driver 1 kΩ

    0.245

    A stronger driver recovers faster

    The divider bound is 0.343 V on a 0.8 V supply. The actual peak is smaller, and falls both when the aggressor edge is slower (0.182 V at 40 ps) and when the victim's driver is stronger (0.245 V with half the resistance). The glitch width is related to the same time constant: the pulse lasts roughly as long as the aggressor edge plus the victim's recovery time. These are first-order estimates for intuition; signoff uses the extracted network and the actual cell models.

    What the review looks for

    • Peak height and width are both reported for each victim; a report with height only misses half of the receiver's criterion.

    • The worst victims are those with weak drivers, large coupling, and fast aggressors.

    • Noise analysis uses the same extraction and the same corner set as delay analysis.

    Common pitfall

    Believing that slowing the aggressor is free. A slower edge reduces the glitch, but it changes the aggressor's own delay and may create a setup problem on its path.

    Interview

    Give the divider bound, then say what moves the real value below it.

    Check yourself Which two changes lower the glitch on a victim without touching the wires?

    A stronger victim driver (smaller R, quicker recovery) and a slower aggressor edge (a weaker aggressor driver or added slew).

    Related topics

    • Next: Noise Immunity

    Previous

    110 / 183

    Next: Noise Immunity

    Up next

    Up nextNoise Immunity

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Functional Failure Risk
    • Noise Review