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

  • RTL Foundations57
  • Combinational Design58
  • Sequential Design61
  • FSM & Control66
  • Timing & Clocking64
  • Reset & CDC58
  • Memory & Buses94
  • Advanced RTL60
    • Parameterization and Generate Hub
    • Top-Level Integration Hub
    • Synthesis Intent Hub
    • Style and Static Checks Hub
      • Style conventions that reduce review friction
      • Lint, RDC, and waiver policy
      • Waiver rules that scale
      • Key takeaways
      • Common pitfalls
      • Worked Examples and Waveforms
      • Corner Cases and Stress Tests
      • Integration and Sign-off Notes
    • Assertions in RTL Hub
    • Formal Verification Basics Hub
    • Reusable SystemVerilog for RTL
  • Senior & Interview175
  • Glossary and Notation
Loading lesson

‹Style and Static Checks Hub
  1. Topics
  2. RTL Design
  3. Advanced RTL
  4. Style and Static Checks Hub
  5. Waiver rules that scale

Part 8 · Advanced · Advanced

Waiver rules that scale

Waiver anatomy, narrow scope, and review discipline that keep static checks useful.

On this page

    Why this matters

    A file-level waiver silences a rule for every later edit, and a copied waiver carries a rationale that does not fit the new site. The waiver list becomes the place where real bugs hide.

    After this lesson you can: write a waiver with all five fields, scope it to one site, and review a waiver change with the same care as new logic.

    A waiver has five parts

    A waiver records an intentional exception, not an ignored bug. Every entry carries the same five fields.

    Field

    What it records

    Rule ID

    The exact rule being waived, so the waiver dies if the rule is renamed

    Scope

    The narrowest site: one line, signal, or instance

    Rationale

    Why the behavior is intentional and safe

    Owner

    Who defends the waiver at review

    Expiry

    When it is revisited: a date or a design change

    An entry missing any field is a guess. Review sends it back for the missing fact.

    Keep the scope narrow

    Waive the site, never the rule. A file-level waiver silences the rule for future edits too.

    • Scope to the instance or signal, so new violations still fail.

    • One entry per site, so each rationale is checked on its own facts.

    • Prefer inline waivers next to the code over central files when the tool allows both.

    Diagram
    # Illustrative waiver file (not tool output). One entry per intentional site.
    # rule | scope | rationale | owner | expiry
    ASYNC-RST | rst_sync assert path | Reset must take effect without a running clock; release is synchronized | team-rtl | revisit if the reset tree changes

    Review waiver deltas like RTL

    Waiver changes ride the same review as functional changes. A new waiver needs the same evidence as new logic.

    Track the count per rule over time. A rising count means the style is drifting, not that the tool is noisy.

    Common pitfall

    Copying a waiver entry to a new site copies its rationale too. The new site has different facts, so it needs its own entry and its own review.

    Interview

    Likely probe: when would you refuse a waiver. Refuse when the RTL fix is cheap, when the scope is wider than the site, or when no expiry is given.

    Check yourself A waiver names the rule and the rationale but no scope or expiry. What breaks first?

    Scope: the waiver covers more code than reviewed, so later violations hide inside it. Expiry rots next: nobody revisits it.

    Check yourself The waiver count for one rule doubles in a month with no design change. What does that trend mean?

    The team is waiving a style habit instead of fixing it. The fix belongs in the shared template or the style rule.

    Testbench

    The reset synchronizer behind the waiver above, plus a check of async assert and two-cycle release.

    rst_sync.sv
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    module rst_sync (
      input  logic clk_i,
      input  logic rst_n_i,
      output logic rst_n_o
    );
      logic meta_q, sync_q;
    
      // Intent: assert without a clock, release over two flops. A rule that
      // requires fully synchronous resets is waived here; see the waiver file.
      always_ff @(posedge clk_i or negedge rst_n_i) begin
        if (!rst_n_i) begin
          meta_q <= 1'b0;
          sync_q <= 1'b0;
        end else begin
          meta_q <= 1'b1;
          sync_q <= meta_q;
        end
      end
    
      assign rst_n_o = sync_q;
    endmodule
    

    Remember

    • A waiver records an intentional exception; a missing field means the entry is a guess.

    • Waive the site, never the rule: scope to the instance or signal, one entry per site.

    • A rising waiver count per rule means the style is drifting.

    Rule of thumb: refuse a waiver when the RTL fix is cheap, the scope is wider than the site, or no expiry is given.

    How this was checked

    Reset synchroniser bench run with Icarus Verilog 13.0 (2026-10-16): prints PASS. It is a finite digital check of asynchronous assert and two-cycle release. It does not model metastability or establish RDC signoff for data from independently reset sources.

    Keep going

    • Interview: run a mock interview on this topic

    Related topics

    • Style conventions that reduce review friction

    • Lint, RDC, and waiver policy

    • Canonical reset-release template and physical limits

    Previous

    487 / 694

    Next: Key takeaways

    Up next

    Up nextKey takeaways

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Style conventions that reduce review friction
    • Common pitfalls
    • Worked Examples and Waveforms