UVM Phases & Simulation Lifecycle

Phasing is the temporal backbone of UVM

Phasing lets dozens of independently written components agree on when to build, wire, drive stimulus, and check results — without central coordination in every component.

Phases topic map

Legend: [UVM] [PHASE] [RUN]

┌─────────────────────────────────────────────────────────────────────────┐
│  UVM PHASES — 13 topic hubs (each with 5–6 sub-lessons)                 │
├─────────────────────────────────────────────────────────────────────────┤
│  MOTIVATION    why phases │ overview │ function vs task                   │
│  BUILD-TIME    build │ connect │ elaboration/start                       │
│  RUN-TIME      run+objections │ 12 sub-phases │ objections deep dive     │
│  CLEANUP       extract │ check │ report │ final                           │
│  ADVANCED      domains/sync │ reset/jump │ phase debugging                │
└─────────────────────────────────────────────────────────────────────────┘

Phase timeline

BUILD (function, 0 time):  build → connect → end_of_elab → start_of_sim
RUN (task, consumes time):   run_phase ∥ 12 runtime sub-phases
CLEANUP (function):          extract → check → report → final

Topics and sub-topics

1. Why UVM Has Phases — 6 sub-lessons on the synchronization problem.

2. Phase Overview — 6 sub-lessons on scheduler traversal and the common list.

3. Function vs Task Phases — 6 sub-lessons on signatures and rules.

4. build_phase — 6 sub-lessons on top-down construction.

5. connect_phase — 6 sub-lessons on bottom-up TLM wiring.

6. end_of_elaboration & start_of_simulation — 6 sub-lessons on pre-time-zero checks.

7. run_phase & Objections — 6 sub-lessons on parallel run and ending simulation.

8. The 12 Runtime Sub-Phases — 6 sub-lessons on reset/configure/main/shutdown.

9. Objections Deep Dive — 6 sub-lessons on propagation, drain_time, ready_to_end.

10. extract, check, report, final — 6 sub-lessons on post-run cleanup.

11. Phase Domains & Synchronization — 6 sub-lessons on independent schedules.

12. reset_phase & Phase Jump — 6 sub-lessons on mid-simulation reset.

13. Phase Debugging — 6 sub-lessons on ordering bugs and objection leaks.

Key takeaways

• Phases give independent components a shared sense of time and order.

• Function phases are structural; task phases consume simulation time.

• Objections and drain_time decide when run_phase and runtime sub-phases end.

How to use this section

Keep the phase timeline diagram as your map. Each hub expands one segment of the lifecycle with theory, walkthroughs, and debug checklists.

• Always call super in phase methods unless you intentionally override parent behavior.

• Unmatched objection raises are the #1 cause of hung simulations.

• Use phase trace and objection debug when behavior 'works once' but hangs at end.