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
    • Latches and Time Borrowing
    • Clock Gating Checks
    • Recovery, Removal and Async
    • Pulse Width and Min Period
      • Minimum Pulse Width
      • Minimum Period
      • Duty Cycle Distortion
      • Pulse Width Signoff
  • Multi-Corner Multi-Mode Signoff16
  • OCV, AOCV, POCV and Variation16
  • Crosstalk and Noise16
  • ECO and Closure16
  • STA Debug Playbook16
  • STA Interview Prep26
  • Capstone Timing Signoff Lab4
Loading lesson

‹Pulse Width and Min Period
  1. Topics
  2. Static Timing Analysis
  3. Beyond Setup and Hold
  4. Pulse Width and Min Period
  5. Duty Cycle Distortion

Part 4 · Beyond Setup and Hold · All levels

Duty Cycle Distortion

If rising and falling edges travel at different speeds through the clock tree, one phase grows and the other shrinks by the accumulated difference.

On this page

    Why it matters

    Real buffers do not delay rising and falling edges equally. Through a tree of many stages the difference accumulates, and the duty cycle at the leaf is not the duty cycle at the root. The narrower phase is the one that violates the pulse width check.

    Worked example

    example.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    # 1 GHz clock, 50% duty at the source. 12 non-inverting buffer stages.
    period = 1.00
    rise_d, fall_d, stages = 0.060, 0.070, 12                 # per-stage delays, ns (illustrative)
    shift = stages * (fall_d - rise_d)                         # 0.12: how much later the falling edge arrives
    high_leaf = 0.50 + shift
    low_leaf = period - high_leaf
    min_low = 0.42
    slack_low = low_leaf - min_low
    assert abs(shift - 0.12) < 1e-9
    assert abs(high_leaf - 0.62) < 1e-9 and abs(low_leaf - 0.38) < 1e-9
    assert abs(slack_low - (-0.04)) < 1e-9
    # balanced with inverting stages in pairs: rise and fall delays swap each stage, so they cancel
    pairs = stages // 2
    rise_path = fall_d + rise_d       # inverter 1 output falls, inverter 2 output rises
    fall_path = rise_d + fall_d       # inverter 1 output rises, inverter 2 output falls
    assert pairs == 6 and abs(rise_path - fall_path) < 1e-12
    print("PASS: leaf high", round(high_leaf, 2), "low", round(low_leaf, 2), "low slack", round(slack_low, 2))

    Each stage makes the falling edge 0.010 ns later than the rising edge, so after 12 stages the high phase is 0.12 ns longer: 0.62 ns instead of 0.50 ns. The low phase is the remainder of the period, 0.38 ns, and it misses a 0.42 ns limit by 0.04 ns. Nothing is wrong with any data path; the clock waveform itself is at fault.

    Ways to reduce the distortion

    Method

    Why it helps

    Use inverting stages in pairs

    A rising edge is slow through one stage and fast through the next, so the differences nominally cancel to first order if the pair is matched; residual mismatch remains and must be verified at the leaves.

    Use balanced rise/fall cells for clock trees

    Rise and fall delays are closer by design

    Shorten the tree

    Fewer stages accumulate less difference

    Check the corner with the largest rise/fall difference

    The worst case is reported, not assumed

    What the review looks for

    • Duty cycle at the leaves is reported in each corner, against the nominal at the source.

    • Distortion is checked in the corners where rise and fall delays diverge most; which corner that is depends on the cell library.

    • Both phases are checked, not only the one that looks weak at the source.

    Common pitfall

    Assuming a 50% source clock gives a 50% leaf clock. The skew between rise and fall delays accumulates stage by stage.

    Interview

    Explain that high width plus low width is the period, so when one phase widens the other narrows by the same amount.

    Check yourself The tree has 20 stages and each makes the falling edge 0.005 ns later than the rising edge. By how much does the high phase change?

    20 × 0.005 = 0.10 ns longer; the low phase is 0.10 ns shorter.

    Related topics

    • Minimum Pulse Width

    • Next: Pulse Width Signoff

    • RTL: Clock Architecture

    Previous

    72 / 183

    Next: Pulse Width Signoff

    Up next

    Up nextPulse Width Signoff

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Minimum Pulse Width