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

  • Start Here4
  • UVM Foundations14
  • UVM Phases & Simulation Lifecycle26
    • The Phase System
      • Why Phases Exist
      • The Phase Schedule: Common and Runtime Phases
      • Traversal Order Rules
      • Function Phases vs Task Phases
      • Signatures, Super Calls, and Debug
      • Inside the Phaser: Nodes, Imps and Schedules
    • UVM Phases: Build, Connect, Elaborate and Run
    • Objections Deep Dive: Drain Time and Propagation
    • Phase Debugging and End-of-Test Signoff
  • Factory & Configuration15
  • Transaction-Level Modeling (TLM)13
  • UVM Sequences & Stimulus21
  • UVM Agents & Protocol VIP21
  • Environment & Test Classes11
  • Checking & Coverage in UVM21
  • UVM Register Abstraction Layer (RAL)22
  • Advanced UVM in Practice13
  • Debug & Regression10
  • Coding Practice47
  • Verification in Industry Practice10
  • Senior Prep: Architecture, Leadership and Interviews32
Loading lesson

‹UVM Phases & Simulation Lifecycle
  1. Topics
  2. UVM Verification
  3. UVM Phases & Simulation Lifecycle
  4. The Phase System

Part 2 · Phases & Lifecycle · Intermediate

The Phase System

How the phaser orders every component: the schedule, the walk directions, function and task phases, exact signatures, and the phaser's own machinery.

  • 6topics
  • 6lessons
On this page

    Every component in a UVM testbench is written by someone who never sees the whole tree. The phaser, the part of the UVM library that schedules phases, is what lets those pieces agree on when to be created, when to be wired, when to run and when to stop. This topic explains that agreement from the outside in: first the rules you rely on every day, then the machinery underneath them.

    What you will be able to do

    • Draw the full phase schedule from memory, including run_phase running in parallel with the twelve runtime phases.

    • Predict the order in which the phaser visits every component of the DMA bench, and say which orders you must never depend on.

    • Explain why a driver's forever loop needs no exit, and why code placed after it never runs.

    • Spot a phase method the phaser will never call, by its signature alone.

    • Explain phase nodes, imps and states well enough to debug a phase_ready_to_end that never fires.

    Diagram: run_test starts the phaser, which runs function phases as zero-time walks and task phases as parallel threads ended by objections.
    Who calls your phase code. run_test hands control to the phaser; function phases are single walks over the tree, task phases fork a thread per component and end when the objections drop.

    Lessons in order

    Lesson

    What it answers

    Why Phases Exist

    Why components cannot simply build and wire themselves, shown on the DMA env.

    The Phase Schedule

    The nine common phases, the twelve runtime phases beside run_phase, and the course's key phase picture.

    Traversal Order Rules

    Top-down and bottom-up walks, the name-order surprise, and why connect really goes bottom-up.

    Function Phases vs Task Phases

    Zero-time walks versus forked threads, and how the phaser kills run_phase threads at the end.

    Signatures, Super Calls, and Debug

    Exact phase signatures, the old no-argument hooks, and how to prove a phase method runs.

    Inside the Phaser: Nodes, Imps and Schedules

    Phase nodes versus imp singletons, phase states, callbacks, and how run_test drives the graph.

    Interview

    The standard opener is "name the phases in order and say which consume time". The senior version adds: "and where do the runtime phases run relative to run_phase?" The answer, in parallel, is the subject of the second lesson.

    Related topics

    • Up: Phases & Lifecycle

    • Next topic: Build, Connect and Run

    PreviousNext: Why Phases Exist

    Up next

    Up nextWhy Phases Exist

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • UVM Phases: Build, Connect, Elaborate and Run
    • Objections Deep Dive: Drain Time and Propagation
    • Phase Debugging and End-of-Test Signoff