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
  • Factory & Configuration15
    • UVM Factory: Registration, Overrides and Debug
      • The Factory: Swapping Classes Without Editing the Env
      • Registration Macros: What uvm_component_utils Writes for You
      • The type_id::create Pattern
      • Override Resolution: Who Wins
      • Override Timing, Safety and Debug
      • Factory Advanced: Parameterized, Abstract and By-Name
      • Command-Line Overrides
      • Overriding Items and Sequences
    • config_db and Resources
  • 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

‹Factory & Configuration
  1. Topics
  2. UVM Verification
  3. Factory & Configuration
  4. UVM Factory: Registration, Overrides and Debug

Part 3 · Factory & Configuration · Intermediate

UVM Factory: Registration, Overrides and Debug

How the factory registers classes, builds them with create, resolves overrides, and how tests use it to swap behaviour without editing the env.

  • 8topics
  • 8lessons
On this page

    The factory is how one test turns the DMA bench's stream driver into a packet-truncating driver, and another turns the scoreboard into one that owns end of test, without a single edit to the env or the agents. This topic takes you from the one-line registration macro to the questions senior interviews ask: which of two overrides wins, why an override that is clearly registered never runs, and how to steer a regression from the command line.

    What you will be able to do

    • Explain what the factory stores and what happens inside every type_id::create call.

    • Predict which class gets built when type and instance overrides compete, including chained overrides.

    • Place overrides at the right moment in build_phase, and debug one that silently does nothing.

    • Handle the advanced cases: parameterized and abstract classes, by-name overrides, command-line overrides, and overrides for sequence items and sequences.

    Learning path: registry, macros, create, resolution, timing and debug, then three advanced lessons.
    Read the first five in order. The last three are independent and build on the resolution rules.

    The lessons

    Lesson

    What you learn

    The factory: swapping classes without editing the env

    What the registry holds, and how dma_truncate_test replaces the stream driver with one line.

    Registration macros

    What uvm_component_utils and uvm_object_utils generate, and why the constructor shape matters.

    The type_id::create pattern

    create versus new, the factory's own create methods, and the context argument for objects.

    Override resolution: who wins

    The one home for the rules: instance overrides first (first match wins), then type overrides, then chaining.

    Override timing, safety and debug

    When to set an override, why a derived scoreboard's methods never ran, and the debug toolkit.

    Factory advanced: parameterized, abstract and by-name

    Chaining, *_param_utils, abstract registration, by-name overrides, and the inherited type_id trap.

    Command-line overrides

    +UVM_TESTNAME, +uvm_set_type_override, +uvm_set_inst_override and +uvm_set_config_* in a regression.

    Overriding items and sequences

    The context argument of create, path-scoped item overrides, and swapping a sequence inside a virtual sequence.

    Interview

    Typical factory questions at a senior loop: type versus instance override and which wins; two instance overrides that both match; why an override set in the test had no effect; how to override a parameterized class; and how a regression picks a test and an override from the command line. Each has a home lesson above.

    Related topics

    • Up: Factory & Configuration

    • Next topic: config_db and resources

    PreviousNext: The Factory: Swapping Classes Without Editing the Env

    Up next

    Up nextThe Factory: Swapping Classes Without Editing the Env

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • config_db and Resources