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;
uvm_factory        factory = uvm_factory::get();
 
// 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
 
// ── Walking the chain manually (step by step) ────────────────────────
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 → %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
// ================================================================