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 Paths
  • Concept Map
  • Meet DCRouter
  • Glossary
  • Part 0: What Verification Is8
  • Part 1: What Can Go Wrong11
  • Part 2: Specifications as Checkable Rules8
  • Part 3: Observability and Controllability7
  • Part 4: Stimulus11
  • Part 5: Checking11
  • Part 6: Coverage10
  • Part 7: Formal and Simulation10
  • Part 8: Verification Levels and Reuse8
  • Part 9: Planning and Risk9
  • Part 10: Emulation and Prototyping8
  • Part 11: Post-Silicon Validation8
  • Part 12: Bug Economics8
  • Part 13: Debug7
  • Part 14: Sign-Off7
  • Part 15: Verification in Context8
    • Functional Safety Verification
    • Security Verification
    • Low-Power Verification Strategy
    • CDC and RDC in the Plan
    • Verifying Processors
    • Verifying AI Accelerators
    • Verifying Configurable IP
    • Drills: Verification in Context
  • Part 16: Case Studies5
  • Part 17: Capstones5
  • Part 18: Interview Preparation6
Loading lesson

‹Part 15: Verification in Context
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 15: Verification in Context
  4. Low-Power Verification Strategy

Part 15 · Verification in Context · Senior (S)

Low-Power Verification Strategy

Low-power design adds two kinds of risk: functional power-management logic (sleep, wake, clock gating) and structural power intent (domains switched off, isolation, retention, level shifting). The first is ordinary verification; the second needs power-aware simulation and static checks. How to put both in the plan, with DCRouter's three low-power bugs as the reference point.

On this page

    Note

    Level: Senior (S) · Answers: What changes for safety, security, processors and AI hardware?

    Before this: Performance and Power Verification

    Three of DCRouter's 24 planted bugs are low-power bugs (BUG_20, 21, 22): sleeping with an output locked, port 3 unable to wake the router, credits lost while asleep. All three are functional: ordinary simulation caught them once the stimulus paused and the checks looked (Parts 4 and 5). Now the SoC team adds a power switch that turns DCRouter's domain off entirely. The bugs that move into the plan are different in kind, and ordinary simulation cannot see them.

    What does a low-power verification strategy contain?

    The obvious answer, and why it breaks

    The obvious plan treats power features like any other features and tests them in ordinary RTL simulation. That works for functional power logic, which is just logic. A powered-off domain, however, does not exist in plain RTL simulation: every signal stays at its last value. Isolation that should clamp outputs, retention that should save state, and sequencing that should order supplies and resets are invisible unless the simulator models power.

    The idea: two kinds of low-power risk

    Kind

    Examples

    Verified by

    Functional power management

    Sleep entry and exit rules, wake sources, clock gating enables, power-controller state machines

    Ordinary simulation and assertions (DCRouter's R13, lesson 5.3); formal where properties are written (lesson 7.9's credit conservation covers credits during sleep)

    Structural power intent

    Domains, supplies, switches, isolation cells, retention registers, level shifters (fact V10)

    Static power-intent checks and power-aware simulation

    The interaction

    Software and power controller sequencing domains while traffic is in flight

    Power-aware chip-level tests with real software (lesson 8.5)

    What each method finds

    Method

    Finds

    Static power-intent checks

    Missing isolation or level shifters on crossings; retention specified on the wrong registers; supply connection errors

    Power-aware simulation

    Logic reading corrupted outputs of an off domain; state not restored after power-up; wrong isolation values; sequencing races

    Ordinary simulation (and formal where properties are written)

    Functional sleep and wake logic, wake sources, idle detection (DCRouter's BUG_20, 21, 22)

    Power-aware emulation and silicon

    Long software flows through many power transitions

    Low power in the plan

    • Features for each power mode and each transition, including transitions with work in flight (lesson 11.7's escape class).

    • Coverage of the power state machine: every state, every transition, every wake source.

    • The power intent reviewed and checked statically before power-aware simulation.

    • Power-aware regression tier for domain-switching tests.

    • Software power-management sequences as chip-level scenarios.

    How real teams verify low power

    Practice

    Purpose

    Power intent in UPF maintained with the RTL

    One description used by simulation, implementation and checks

    Static checks on every power-intent change

    Structural errors caught cheaply

    Power-aware simulation of every domain transition

    Isolation, retention and sequencing exercised

    What breaks

    A team (illustrative) verified a block's sleep logic thoroughly in ordinary simulation and signed off. In silicon the block's domain was switched off by the power controller while a neighbouring block still read one of its status outputs, which was clamped to the wrong value because its isolation cell had been specified with the wrong clamp value. Ordinary simulation held the output at its last, correct-looking value; only power-aware simulation, which models the domain switching off and the isolation cells taking over, would have shown the bad clamp.

    Why this matters

    Senior lens. Split low-power verification into functional power logic (ordinary methods) and structural power intent (static checks and power-aware simulation), and plan both. Cover every power state, transition and wake source, especially transitions with work in flight, and test the software's power sequences at chip level.

    Interview

    Asked: "What does power-aware simulation find?"

    Weak answer: Power consumption.

    Strong answer: Bugs in structural power intent that ordinary RTL simulation can't see, because in plain simulation a switched-off domain keeps its last values. Power-aware simulation corrupts off-domain signals and state, so it finds logic reading an off domain's outputs without proper isolation, wrong clamp values, state not retained or restored, and sequencing races between supplies, resets and traffic. Functional power logic like sleep and wake rules is still verified with ordinary simulation and formal; static checks catch missing isolation and level shifters.

    Follow-ups: (1) What do static power checks find? (2) Why weren't DCRouter's low-power bugs power-aware bugs?

    Check yourself Why did ordinary simulation catch BUG_20, 21 and 22?

    They are functional bugs in DCRouter's sleep logic, which ordinary simulation models; no power domain is switched off.

    Check yourself What does plain RTL simulation show for the outputs of a switched-off domain?

    Their last values, as if the domain were still on, hiding isolation and retention bugs.

    Key takeaways

    • Low power has two kinds of risk: functional power logic and structural power intent.

    • Functional logic needs ordinary methods; power intent needs static checks and power-aware simulation.

    • Plan every power state, transition and wake source, especially with work in flight.

    Keep going

    Next: Lesson 15.4, CDC and RDC in the Plan. Clock- and reset-domain crossings in the plan.

    Related topics

    • Part 15 overview: Verification in Context

    • Low-power verification course: Power-Aware Simulation

    Previous

    139 / 160

    Next: CDC and RDC in the Plan

    Up next

    Up nextCDC and RDC in the Plan

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Functional Safety Verification
    • Verifying Processors
    • Verifying AI Accelerators