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
    • Clock Definition & Uncertainty
      • create_clock Rules
      • Waveform and Edge Cases
      • Uncertainty and Jitter
      • Source Versus Network Latency
    • Generated Clocks & Dividers
    • I/O Timing & Boundary Contracts
    • Exceptions & Audit Policy
    • Environment and Design Rules
  • Delay Graph & Path Analysis16
  • Beyond Setup and Hold16
  • 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

‹Clock Definition & Uncertainty
  1. Topics
  2. Static Timing Analysis
  3. Constraints & SDC Fundamentals
  4. Clock Definition & Uncertainty
  5. Waveform and Edge Cases

Part 2 · Constraints and SDC · All levels

Waveform and Edge Cases

The waveform argument sets edge times; non-default duty cycles and offsets change the launch-to-capture budget.

On this page

    Why it matters

    Most clocks are 50% duty, but not all: a 25% duty clock, an offset clock or a clock with a late falling edge changes the time between rising and falling edges, and so changes every half-cycle path. If the waveform is wrong, half-cycle budgets are wrong even when the period is right.

    Reading the waveform

    Diagram
    # not-run: SDC is not executable here
    create_clock -name c50 -period 10 -waveform {0 5}  [get_ports clk]    ;# 50% duty
    create_clock -name c25 -period 10 -waveform {0 2.5} [get_ports clk25] ;# 25% duty: high for 2.5, low for 7.5
    example.py
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    def half_cycle_budgets(period, rise, fall):
        high = (fall - rise) % period
        low = period - high
        return high, low
    h50, l50 = half_cycle_budgets(10.0, 0.0, 5.0)
    h25, l25 = half_cycle_budgets(10.0, 0.0, 2.5)
    assert (h50, l50) == (5.0, 5.0)
    assert (h25, l25) == (2.5, 7.5)
    # a rising-launch to falling-capture path gets the 'high' time as its budget, falling-to-rising gets 'low'
    print("PASS: 25% duty gives half-cycle budgets", h25, "and", l25, "ns")

    For a 25% duty clock, a path launched on the rising edge and captured on the falling edge has only 2.5 ns, not 5 ns. A falling-launch to rising-capture path has 7.5 ns. The edge-pair budget is the difference between the edges, not half the period.

    Offsets

    A clock can start with an offset, for example -waveform {2 7} for a 10 ns period: it rises at 2 ns and falls at 7 ns. Relative offsets between two clocks of the same period matter for paths between them; the closest launch/capture edge pair of the two waveforms sets the budget.

    What the review looks for

    • The waveform matches the real clock: duty cycle from the source (a PLL output, a divider) is stated in the clock documentation.

    • Half-cycle paths are reviewed explicitly; the report's launch and capture times for them equal the edge difference.

    • Clocks with non-default waveforms are called out in the constraint review notes.

    Common pitfall

    Assuming 50% duty on a divided clock. A divide-by-3 flop output has a duty cycle of 1/3 or 2/3 unless a specific structure forces 50%; the generated clock must say so or the half-cycle budgets are wrong.

    Interview

    If asked about a negative-edge flop on a 4 ns clock with 25% duty, work the budget: the edge difference decides, not T/2.

    Check yourself A rising-edge flop feeds a falling-edge flop. The clock is 8 ns with waveform {0 3}. What is the setup budget?

    3 ns, the time from the rising edge at 0 to the falling edge at 3, not 4 ns.

    Related topics

    • create_clock Rules

    • Next: Uncertainty and Jitter

    Previous

    23 / 183

    Next: Uncertainty and Jitter

    Up next

    Up nextUncertainty and Jitter

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Source Versus Network Latency