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

  • Logic Synthesis Glossary
  • Logic Synthesis Cheatsheet
  • Synthesis Foundations14
  • Logic Optimisation and Mapping20
  • Constraints and Timing15
  • Sequential, FSM and Memory19
  • Datapath Synthesis14
  • Area, Power and Test14
  • Verification, ECO and Handoff15
  • Flows and Debugging15
    • Scripted Flows and Regression
    • Debugging QoR
    • Simulation-Synthesis Mismatch
      • Sensitivity Lists and Races
      • Blocking and Non-Blocking Assignments
      • X Pessimism, Optimism, and Init
      • Case Priority and Wildcards
      • Directives, Widths, and Gate Simulation
  • Interview and Judgment11
Loading lesson

‹Simulation-Synthesis Mismatch
  1. Topics
  2. Logic Synthesis
  3. Flows and Debugging
  4. Simulation-Synthesis Mismatch
  5. Sensitivity Lists and Races

Part 8 · Flows and Debugging · Intermediate

Sensitivity Lists and Races

Incomplete sensitivity lists and races: why simulation stalls while the gates do not.

On this page

    The event list has no hardware

    A synthesis tool ignores the event list and builds the block body as combinational logic. Simulation obeys the list and re-evaluates only when a listed signal changes.

    That split is the whole bug class. Any signal that is read but not listed simulates stale and synthesizes live.

    A stale output

    Consider always @(a) y = a & b. Toggling b alone leaves y frozen in simulation, while the gates follow b at once.

    The Yosys script below proves the point: both lists build identical logic, so the simulation difference is the entire mismatch.

    yosys
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    read_verilog <<EOV
    module gold(a, b, y);
    input a;
    input b;
    output y;
    reg y;
    always @* y = a & b;
    endmodule
    module gate(a, b, y);
    input a;
    input b;
    output y;
    reg y;
    always @(a) y = a & b;
    endmodule
    EOV
    hierarchy -check
    proc
    opt
    miter -equiv -flatten -make_outputs gold gate m
    hierarchy -top m
    sat -prove trigger 0 -verify m
    log PASS: incomplete list builds the same AND gates

    Races between concurrent blocks

    Zero-delay blocks scheduled in one timestep run in an order the standard leaves undefined. Two simulators may therefore evaluate the same step differently.

    Pattern

    Simulation risk

    Safe form

    Two blocks driving one variable

    Last write wins, order unknown

    Exactly one driver per variable

    Reading another block's blocking update

    Value depends on run order

    Non-blocking updates sampled at the clock

    Stimulus racing the design at time zero

    Unknown initial sample

    Drive stimulus before the first clock

    The rule

    Write combinational blocks with always_comb, which infers the full list. Reserve explicit event lists for clocked logic and testbench timing.

    Common pitfall

    Adding the missing signal to the list fixes simulation but changes nothing in the gates. The gates were already right; the testbench had been checking a stale value.

    Interview

    Likely probe: why always @(a) versus always @* simulates differently yet synthesizes the same. The list is a simulation schedule with no hardware meaning.

    Check yourself always @(a) y = a & b runs while b toggles and a stays still. What does RTL simulation show, and what do the gates do?

    Simulation holds the old y because a never moves. The gates track a & b continuously, since synthesis ignored the list.

    Check yourself Two zero-delay blocks update in one timestep. Why can two simulators disagree?

    Block order within a timestep is undefined. Each simulator picks a legal order, so opposite orders give opposite samples.

    Related topics

    • Next: Blocking and non-blocking

    • Synthesizable RTL and inference

    • Latch inference

    Previous

    124 / 139

    Next: Blocking and Non-Blocking Assignments

    Up next

    Up nextBlocking and Non-Blocking Assignments

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • X Pessimism, Optimism, and Init
    • Case Priority and Wildcards
    • Directives, Widths, and Gate Simulation