UVM Factory Debug

// Add to your base_test or any top-level component — remove before tapeout
function void start_of_simulation_phase(uvm_phase phase);
    super.start_of_simulation_phase(phase);
 
    // print(0) — show overrides only (recommended for routine debug)
    uvm_factory::get().print(0);
 
    // print(1) — show all registered types + overrides (verbose)
    uvm_factory::get().print(1);
endfunction

// Control factory print from the command line without editing source code
function void start_of_simulation_phase(uvm_phase phase);
    super.start_of_simulation_phase(phase);
 
    if ($test$plusargs("FACTORY_DEBUG")) begin
        `uvm_info("FACTORY", "Factory state at start_of_simulation:", UVM_LOW)
        uvm_factory::get().print(1);   // verbose — all types + overrides
    end else if ($test$plusargs("FACTORY_OVR")) begin
        uvm_factory::get().print(0);   // concise — overrides only
    end
endfunction
 
// Simulate with: vsim +FACTORY_DEBUG work.tb_top
// Or:            vsim +FACTORY_OVR  work.tb_top

// In apb_agent.sv — after build_phase creates the driver
function void start_of_simulation_phase(uvm_phase phase);
    super.start_of_simulation_phase(phase);
 
    // Check what type was actually created
    `uvm_info("AGENT",
        $sformatf("Driver type: %s  Path: %s",
                  drv.get_type_name(),
                  drv.get_full_name()),
        UVM_LOW)
 
    // Console output if override worked:
    //   UVM_INFO: Driver type: error_inject_driver  Path: ...apb_agent.drv
    // Console output if override FAILED:
    //   UVM_INFO: Driver type: apb_driver            Path: ...apb_agent.drv
endfunction
 
// ── Programmatic type check — fail simulation if wrong type ──────────
function void start_of_simulation_phase(uvm_phase phase);
    super.start_of_simulation_phase(phase);
    if (drv.get_type_name() != "error_inject_driver")
        `uvm_fatal("TYPE_CHK",
            $sformatf("Expected error_inject_driver, got %s. Override failed.",
                      drv.get_type_name()))
endfunction

// drv is declared as apb_driver but may hold error_inject_driver
error_inject_driver eid_drv;
 
if ($cast(eid_drv, drv)) begin
    // $cast returns 1 → drv IS error_inject_driver → override worked
    `uvm_info("CAST", "Override confirmed via $cast", UVM_LOW)
    eid_drv.set_error_rate(10);   // access override-specific method safely
end else begin
    // $cast returns 0 → drv is apb_driver → override did NOT work
    `uvm_warn("CAST", "Override failed — drv is base apb_driver type")
end
 
// Note: $cast() is non-destructive — it doesn't change drv or eid_drv
// if cast fails. This makes it safe for runtime type checking.

// ── find_override_by_type() traces one hop in the chain ──────────────
uvm_object_wrapper resolved;
// IEEE 1800.2 obtains the factory through the core service. `uvm_factory::get()`
// exists in most implementations as a shorthand, but the core-service form is
// the one the standard defines and the one that survives a UVM version bump.
uvm_coreservice_t  cs      = uvm_coreservice_t::get();
uvm_factory        factory = cs.get_factory();
 
// What does the factory give when apb_driver is requested at path "*.drv"?
resolved = factory.find_override_by_type(
    apb_driver::get_type(),    // requested type
    "uvm_test_top.env.apb_agent.drv"   // path context
);
 
`uvm_info("CHAIN",
    $sformatf("apb_driver resolves to: %s", resolved.get_type_name()),
    UVM_LOW)
 
// If override A→B→C is registered:
// find_override_by_type(A) returns C directly — factory follows the full chain
 
// ── Confirming the chain terminates where you expect ─────────────────
// NOTE: find_override_by_type already follows the WHOLE chain, so it returns
// the final type in one call - it does not step one hop. This loop therefore
// prints a single A -> C line and then terminates; it confirms the endpoint
// rather than enumerating the intermediate hops. To see the individual hops,
// read the Type Overrides table from factory::print() as shown below.
uvm_object_wrapper current = apb_driver::get_type();
uvm_object_wrapper next;
 
forever begin
    next = factory.find_override_by_type(current, "*");
    if (next == current) break;   // no further override — chain ends
    `uvm_info("CHAIN",
        $sformatf("  %s resolves to %s", current.get_type_name(),
                  next.get_type_name()), UVM_LOW)
    current = next;
end
`uvm_info("CHAIN", $sformatf("Final resolved type: %s", current.get_type_name()), UVM_LOW)

## factory::print(0) output when chain A→B→C is registered:
 
#### UVM Factory Configuration ####
--- Type Overrides ---
  Requested Type       Override Type
  -------------------- -------------------------
  apb_driver           protocol_driver          ←── Step 1: A → B
  protocol_driver      error_inject_driver      ←── Step 2: B → C
 
## Reading the chain: start from apb_driver
## apb_driver → protocol_driver → error_inject_driver (no further override)
## Factory creates: error_inject_driver
## Returned as:     apb_driver (base type)

## Simulation command:
## vsim +UVM_FACTORY_OVERRIDE_TRACE work.tb_top
 
## Output (one line per create() call):
 
UVM_INFO @ 0: Factory: create_component_by_type
  Requested: apb_driver
  Override:  error_inject_driver  (type override)
  Created:   error_inject_driver  path=uvm_test_top.env.apb_agent.drv
 
UVM_INFO @ 0: Factory: create_component_by_type
  Requested: apb_monitor
  Override:  (none)
  Created:   apb_monitor  path=uvm_test_top.env.apb_agent.mon
 
## Key reading: "Override: (none)" means original type used — no override matched
## "Override: error_inject_driver (type override)" means type override matched
## "Override: ... (instance override)" means instance override matched by path

// Drop this into any component's start_of_simulation_phase while debugging
// Remove before commit. Does not affect simulation behaviour.
 
function void start_of_simulation_phase(uvm_phase phase);
    super.start_of_simulation_phase(phase);
 
    if ($test$plusargs("FACTORY_DEBUG")) begin
        automatic string divider = {60{"="}};
        `uvm_info("DBG", divider, UVM_LOW)
        `uvm_info("DBG", $sformatf("Component: %s  Type: %s",
            get_full_name(), get_type_name()), UVM_LOW)
        `uvm_info("DBG", "Factory state:", UVM_LOW)
        uvm_factory::get().print(0);   // overrides only
        `uvm_info("DBG", divider, UVM_LOW)
    end
endfunction
 
// Run with: vsim +FACTORY_DEBUG +UVM_FACTORY_OVERRIDE_TRACE work.tb_top
// The combination gives you both the registry state and real-time resolution trace.

`include "uvm_macros.svh"
import uvm_pkg::*;
 
// Three related classes ─────────────────────────────────────────────
class base_txn extends uvm_sequence_item;
    `uvm_object_utils(base_txn)
    function new(string n="base_txn"); super.new(n); endfunction
endclass
 
class err_txn extends base_txn;
    `uvm_object_utils(err_txn)
    function new(string n="err_txn"); super.new(n); endfunction
endclass
 
class base_drv extends uvm_driver#(base_txn);
    `uvm_component_utils(base_drv)
    function new(string n, uvm_component p); super.new(n,p); endfunction
endclass
 
class print_test extends uvm_test;
    `uvm_component_utils(print_test)
    function new(string n, uvm_component p); super.new(n,p); endfunction
 
    function void build_phase(uvm_phase phase);
        // Register one type override
        base_txn::type_id::set_type_override(err_txn::get_type());
        super.build_phase(phase);
    endfunction
 
    task run_phase(uvm_phase phase);
        phase.raise_objection(this);
        $display("\n=== factory.print() output ===");
        uvm_factory::get().print(1);
        phase.drop_objection(this);
    endtask
endclass
 
module print_demo_top;
    initial run_test("print_test");
endmodule
 
// Annotated Expected Output:
//
// === factory.print() output ===
// #### Factory Configuration (classes=4, overrides=1) ####
//
// Object Types:                        ← uvm_object subclasses registered
//   base_txn
//   err_txn
//
// Component Types:                     ← uvm_component subclasses registered
//   base_drv
//   print_test
//
// Type Overrides:                      ← active type-level substitutions
//   base_txn → err_txn
//       [when base_txn requested, err_txn is given]
//
// Instance Overrides:                  ← path-specific substitutions
//   (none)
//
// Reading this: "base_txn → err_txn" means ANY call to
// base_txn::type_id::create() will return an err_txn object.
// If this override is unexpected, check your test's build_phase.

`include "uvm_macros.svh"
import uvm_pkg::*;
 
// Three driver types ────────────────────────────────────────────────
class base_drv extends uvm_component;
    `uvm_component_utils(base_drv)
    function new(string n, uvm_component p); super.new(n,p); endfunction
endclass
 
class slow_drv extends base_drv;
    `uvm_component_utils(slow_drv)
    function new(string n, uvm_component p); super.new(n,p); endfunction
endclass
 
class type_check_test extends uvm_test;
    `uvm_component_utils(type_check_test)
    base_drv drv;
    function new(string n, uvm_component p); super.new(n,p); endfunction
 
    function void build_phase(uvm_phase phase);
        base_drv::type_id::set_type_override(slow_drv::get_type());
        super.build_phase(phase);
        drv = base_drv::type_id::create("drv", this);
    endfunction
 
    task run_phase(uvm_phase phase);
        slow_drv sd;
        phase.raise_objection(this);
 
        // Method 1: get_type_name() — what type is it REALLY?
        $display("[TYPE] get_type_name(): %s", drv.get_type_name());
 
        // Method 2: $cast — does the actual type match our expectation?
        if($cast(sd, drv)) begin
            $display("[CAST] $cast to slow_drv: SUCCESS");
        end else begin
            $display("[CAST] $cast to slow_drv: FAIL — wrong type");
        end
 
        // Method 3: Factory lookup — what would factory return for this type?
        $display("[FACT] Factory override for base_drv:");
        uvm_factory::get().debug_pass_one(base_drv::get_type(),
                                            "debug", "uvm_test_top.drv");
 
        phase.drop_objection(this);
    endtask
endclass
 
module type_check_top;
    initial run_test("type_check_test");
endmodule
 
// Expected Output:
// [TYPE] get_type_name(): slow_drv        ← confirmed actual type
// [CAST] $cast to slow_drv: SUCCESS       ← cast confirms type compatibility
// [FACT] Factory override for base_drv: slow_drv (type override)

`include "uvm_macros.svh"
import uvm_pkg::*;
 
// Override chain: base → extended → specialized ────────────────────
class drv_v1 extends uvm_component;
    `uvm_component_utils(drv_v1)
    function new(string n, uvm_component p); super.new(n,p); endfunction
    virtual function string version(); return "v1"; endfunction
endclass
 
class drv_v2 extends drv_v1;
    `uvm_component_utils(drv_v2)
    function new(string n, uvm_component p); super.new(n,p); endfunction
    virtual function string version(); return "v2"; endfunction
endclass
 
class drv_v3 extends drv_v2;
    `uvm_component_utils(drv_v3)
    function new(string n, uvm_component p); super.new(n,p); endfunction
    virtual function string version(); return "v3"; endfunction
endclass
 
class chain_test extends uvm_test;
    `uvm_component_utils(chain_test)
    drv_v1 drv;
    function new(string n, uvm_component p); super.new(n,p); endfunction
 
    function void build_phase(uvm_phase phase);
        // Layer 1: VIP base package registers: drv_v1 → drv_v2
        drv_v1::type_id::set_type_override(drv_v2::get_type());
        // Layer 2: Your team adds: drv_v2 → drv_v3
        drv_v2::type_id::set_type_override(drv_v3::get_type());
        super.build_phase(phase);
        drv = drv_v1::type_id::create("drv", this);
    endfunction
 
    task run_phase(uvm_phase phase);
        phase.raise_objection(this);
        $display("\nOverride chain for drv_v1:");
        $display("  drv_v1 requested → factory checks override → drv_v2");
        $display("  drv_v2 override?  → factory checks override → drv_v3");
        $display("  drv_v3 override?  → none → FINAL RESULT: drv_v3");
        $display("\nActual drv type: %s version=%s",
                 drv.get_type_name(), drv.version());
 
        $display("\nfactory.print(1) shows the chain:");
        uvm_factory::get().print(1);
        phase.drop_objection(this);
    endtask
endclass
 
module chain_top;
    initial run_test("chain_test");
endmodule
 
// Expected Output:
// Override chain for drv_v1:
//   drv_v1 requested → factory checks override → drv_v2
//   drv_v2 override?  → factory checks override → drv_v3
//   drv_v3 override?  → none → FINAL RESULT: drv_v3
//
// Actual drv type: drv_v3  version=v3   ← chain fully resolved!
//
// factory.print(1):
// Type Overrides:
//   drv_v1 → drv_v2
//   drv_v2 → drv_v3
// ↑ Reading this: drv_v1 requests eventually resolves to drv_v3

`include "uvm_macros.svh"
import uvm_pkg::*;
 
// VIP agent that uses new() instead of type_id::create() ──────────
class bad_agent extends uvm_agent;
    `uvm_component_utils(bad_agent)
    drv_v1 drv;
    function new(string n, uvm_component p); super.new(n,p); endfunction
    function void build_phase(uvm_phase p);
        super.build_phase(p);
        drv = new("drv", this);   // ← VIP bug: uses new() not factory
    endfunction
endclass
 
class bypass_debug_test extends uvm_test;
    `uvm_component_utils(bypass_debug_test)
    bad_agent agent;
    function new(string n, uvm_component p); super.new(n,p); endfunction
 
    function void build_phase(uvm_phase phase);
        // Override registered — but will it work?
        drv_v1::type_id::set_type_override(drv_v2::get_type());
        super.build_phase(phase);
        agent = bad_agent::type_id::create("agent", this);
    endfunction
 
    task run_phase(uvm_phase phase);
        phase.raise_objection(this);
 
        $display("\n=== Diagnostic 1: factory.print() ===");
        uvm_factory::get().print(1);
        // Shows: drv_v1 → drv_v2 override IS registered
 
        $display("\n=== Diagnostic 2: actual driver type ===");
        $display("agent.drv type: %s", agent.drv.get_type_name());
        // Shows: drv_v1 ← override DIDN'T apply because new() was used
 
        $display("\n=== Root Cause: bad_agent uses new() instead of factory ===");
        $display("Fix: in bad_agent.build_phase, change:");
        $display("  drv = new('drv', this);                     // bypass");
        $display("To:");
        $display("  drv = drv_v1::type_id::create('drv', this); // factory");
 
        phase.drop_objection(this);
    endtask
endclass
 
module bypass_top;
    initial run_test("bypass_debug_test");
endmodule
 
// Expected Output:
// === Diagnostic 1: factory.print() ===
// Type Overrides:
//   drv_v1 → drv_v2      ← override IS registered
//
// === Diagnostic 2: actual driver type ===
// agent.drv type: drv_v1  ← STILL drv_v1! Override didn't apply
//
// === Root Cause: bad_agent uses new() instead of factory ===
// Fix: change drv = new(...) to drv = drv_v1::type_id::create(...)
//
// KEY INSIGHT: factory.print() shows override as registered,
// but get_type_name() shows it didn't apply.
// This signature means: new() bypass.

// ROOT CAUSE A: VIP uses new() instead of factory ─────────────────
// factory.print() shows: base_drv → err_drv
// get_type_name() shows: base_drv  ← wrong
// ❌ VIP code:
drv = new("drv", this);                              // bypass factory
// ✓ Fix:
drv = base_drv::type_id::create("drv", this);      // use factory
 
// ROOT CAUSE B: Override registered AFTER create() ─────────────────
// ❌ Wrong order in test.build_phase:
function void build_phase(uvm_phase phase);
    super.build_phase(phase);                            // ← creates drv here
    drv = base_drv::type_id::create("drv", this);    // ← using base type
    base_drv::type_id::set_type_override(err_drv::get_type()); // ← too late
endfunction
 
// ✓ Fix: override BEFORE super.build_phase()
function void build_phase(uvm_phase phase);
    base_drv::type_id::set_type_override(err_drv::get_type()); // ← FIRST
    super.build_phase(phase);                            // ← cascade uses override
    drv = base_drv::type_id::create("drv", this);    // ← gets err_drv ✓
endfunction
 
// ROOT CAUSE C: Instance override path is wrong ────────────────────
// ❌ Wrong path (agent is deeper than expected):
base_drv::type_id::set_inst_override(err_drv::get_type(),
    "uvm_test_top.drv");   // ← wrong: actually "uvm_test_top.agent.drv"
 
// ✓ Fix: use print_topology() to find correct path:
uvm_root::get().print_topology();  // run first to see actual paths
base_drv::type_id::set_inst_override(err_drv::get_type(),
    "uvm_test_top.agent.drv");  // ← correct path

// ❌ WRONG: type override changes ALL three agents' drivers
function void build_phase(uvm_phase phase);
    base_drv::type_id::set_type_override(err_drv::get_type());  // ← GLOBAL
    super.build_phase(phase);
    // agent0.drv → err_drv  ← intended
    // agent1.drv → err_drv  ← unintended side effect
    // agent2.drv → err_drv  ← unintended side effect
endfunction
 
// Debug: factory.print() clearly shows global scope
// Type Overrides: base_drv → err_drv  ← no path constraint = global
 
// ✓ CORRECT: instance override is path-specific
function void build_phase(uvm_phase phase);
    base_drv::type_id::set_inst_override(err_drv::get_type(),
        "uvm_test_top.agent0.drv");  // ← ONLY agent0
    super.build_phase(phase);
    // agent0.drv → err_drv  ← intended ✓
    // agent1.drv → base_drv ← untouched ✓
    // agent2.drv → base_drv ← untouched ✓
endfunction
 
// Verify with: foreach agent, print get_type_name() of each driver
// Confirm factory.print() now shows:
// Instance Overrides: uvm_test_top.agent0.drv: base_drv → err_drv

// ================================================================
// factory_debug_demo.sv — Complete Factory Debug Demonstration
// Shows all debug techniques: print(), get_type_name(), $cast,
// print_topology(), and override chain tracing
//
// Compile (Questa):
//   vlog -sv -L uvm_1_2 factory_debug_demo.sv
//   vsim -c -L uvm_1_2 factory_debug_top -do "run -all; quit"
//
// Compile (VCS):
//   vcs -sverilog -ntb_opts uvm-1.2 factory_debug_demo.sv && ./simv
//
// Compile (Xcelium):
//   xrun -sv -uvm factory_debug_demo.sv
// ================================================================
 
`include "uvm_macros.svh"
import uvm_pkg::*;
 
// ── Three-level hierarchy for all demos ───────────────────────────
class comp_a extends uvm_component;
    `uvm_component_utils(comp_a)
    function new(string n, uvm_component p); super.new(n,p); endfunction
    virtual function string label(); return "A"; endfunction
endclass
 
class comp_b extends comp_a;
    `uvm_component_utils(comp_b)
    function new(string n, uvm_component p); super.new(n,p); endfunction
    virtual function string label(); return "B"; endfunction
endclass
 
class comp_c extends comp_b;
    `uvm_component_utils(comp_c)
    function new(string n, uvm_component p); super.new(n,p); endfunction
    virtual function string label(); return "C"; endfunction
endclass
 
class obj_x extends uvm_sequence_item;
    `uvm_object_utils(obj_x)
    function new(string n="obj_x"); super.new(n); endfunction
endclass
 
class obj_y extends obj_x;
    `uvm_object_utils(obj_y)
    function new(string n="obj_y"); super.new(n); endfunction
endclass
 
// ── Complete debug test ────────────────────────────────────────────
class factory_debug_test extends uvm_test;
    `uvm_component_utils(factory_debug_test)
    comp_a c1, c2, c3;
 
    function new(string n, uvm_component p); super.new(n,p); endfunction
 
    function void build_phase(uvm_phase phase);
        // Setup: chain comp_a → comp_b → comp_c + instance exception
        comp_a::type_id::set_type_override(comp_b::get_type());   // chain step 1
        comp_b::type_id::set_type_override(comp_c::get_type());   // chain step 2
        comp_a::type_id::set_inst_override(                       // c2 stays at comp_b
            comp_b::get_type(), "uvm_test_top.c2");
        obj_x::type_id::set_type_override(obj_y::get_type());     // object override
 
        super.build_phase(phase);
        c1 = comp_a::type_id::create("c1", this);
        c2 = comp_a::type_id::create("c2", this);
        c3 = comp_a::type_id::create("c3", this);
    endfunction
 
    task run_phase(uvm_phase phase);
        obj_x obj;
        comp_b cb;
        comp_c cc;
        phase.raise_objection(this);
 
        // ── Debug Tool 1: factory.print() ─────────────────────────
        `uvm_info("DBG","\n=== TOOL 1: factory.print() ===",UVM_NONE)
        uvm_factory::get().print(1);
 
        // ── Debug Tool 2: get_type_name() ─────────────────────────
        `uvm_info("DBG","\n=== TOOL 2: get_type_name() ===",UVM_NONE)
        $display("  c1: %s (label=%s)", c1.get_type_name(), c1.label());
        $display("  c2: %s (label=%s)", c2.get_type_name(), c2.label());
        $display("  c3: %s (label=%s)", c3.get_type_name(), c3.label());
 
        // ── Debug Tool 3: $cast ────────────────────────────────────
        `uvm_info("DBG","\n=== TOOL 3: $cast verification ===",UVM_NONE)
        $display("  c1 castable to comp_c? %0b", $cast(cc, c1));
        $display("  c2 castable to comp_c? %0b", $cast(cc, c2));
        $display("  c2 castable to comp_b? %0b", $cast(cb, c2));
 
        // ── Debug Tool 4: print_topology() ────────────────────────
        `uvm_info("DBG","\n=== TOOL 4: print_topology() ===",UVM_NONE)
        uvm_root::get().print_topology();
 
        // ── Debug Tool 5: Object override check ───────────────────
        `uvm_info("DBG","\n=== TOOL 5: Object type check ===",UVM_NONE)
        obj = obj_x::type_id::create("obj");
        $display("  obj type: %s", obj.get_type_name());
 
        phase.drop_objection(this);
    endtask
endclass
 
module factory_debug_top;
    initial run_test("factory_debug_test");
endmodule
 
// ================================================================
// Expected Output:
//
// === TOOL 1: factory.print() ===
// Type Overrides:
//   comp_a → comp_b
//   comp_b → comp_c
//   obj_x  → obj_y
// Instance Overrides:
//   uvm_test_top.c2: comp_a → comp_b  ← stops chain for c2
//
// === TOOL 2: get_type_name() ===
//   c1: comp_c (label=C)   ← chain: a→b→c, resolved to comp_c
//   c2: comp_b (label=B)   ← inst override stops at b (doesn't follow type chain)
//   c3: comp_c (label=C)   ← chain: a→b→c, resolved to comp_c
//
// === TOOL 3: $cast verification ===
//   c1 castable to comp_c? 1   ← comp_c IS-A comp_c
//   c2 castable to comp_c? 0   ← comp_b is NOT comp_c
//   c2 castable to comp_b? 1   ← comp_b IS-A comp_b
//
// === TOOL 4: print_topology() ===
// uvm_test_top [factory_debug_test]
//   c1 [comp_c]
//   c2 [comp_b]    ← instance override stopped the chain here
//   c3 [comp_c]
//
// === TOOL 5: Object type check ===
//   obj type: obj_y   ← object override also works
// ================================================================