uvm_object vs uvm_component

// Inside any uvm_component:
 
// ── Identity ───────────────────────────────────────────────────
string my_name = get_name();          // "drv"  (just this component's name)
string full   = get_full_name();       // "uvm_test_top.env.apb_agent.drv"
string cls    = get_type_name();       // "apb_driver"
 
// ── Navigation ─────────────────────────────────────────────────
uvm_component par = get_parent();      // returns the apb_agent handle
uvm_component child;
 
// iterate all direct children
string child_name;
if (get_first_child(child_name)) begin
do begin
child = get_child(child_name);
`uvm_info("TOPO", child.get_full_name(), UVM_LOW)
end while (get_next_child(child_name));
end
 
// ── Lookup by path ─────────────────────────────────────────────
uvm_component found;
found = uvm_root::get().find("uvm_test_top.env.apb_agent.drv");
 
// ── Depth in the tree ──────────────────────────────────────────
int depth = get_depth();   // 0 = uvm_test_top, 1 = env, 2 = agent, 3 = driver

// ── Scenario: you want to swap apb_driver with error_inject_driver ──
 
// ❌ WRONG — direct new() bypasses the factory ──────────────────────
function void build_phase(uvm_phase phase);
drv = new("drv", this);   // always creates apb_driver, override impossible
endfunction
 
// In your test, you call:
// apb_driver::type_id::set_type_override(error_inject_driver::get_type());
// ...but it has NO effect because build_phase used new() directly.
 
// ✓ CORRECT — factory create() respects overrides ─────────────────
function void build_phase(uvm_phase phase);
drv = apb_driver::type_id::create("drv", this);
// Factory checks: "Is there an override for apb_driver?"
// If yes → creates error_inject_driver instead.
// If no  → creates apb_driver as written.
endfunction
 
// In your error injection test:
class error_inject_test extends base_test;
`uvm_component_utils(error_inject_test)
function void build_phase(uvm_phase phase);
// Override before super.build_phase() which triggers env.build_phase()
apb_driver::type_id::set_type_override(error_inject_driver::get_type());
super.build_phase(phase);
endfunction
endclass
 
// Result: env creates error_inject_driver without touching any env/agent code.

// ❌ WRONG — component created in run_phase
task run_phase(uvm_phase phase);
my_sub_monitor extra_mon;
extra_mon = my_sub_monitor::type_id::create("extra_mon", this);
// extra_mon EXISTS in the hierarchy but:
// ✗ Its build_phase()    was never called
// ✗ Its connect_phase()  was never called
// ✗ Its run_phase()      was never started
// ✗ config_db::get() will fail (get_full_name() path is wrong)
// Result: a broken component that silently does nothing
endtask

// ❌ WRONG — extending uvm_component for data that flows through TLM ports
class apb_txn extends uvm_component;   // ERROR: wrong base class
`uvm_component_utils(apb_txn)
rand bit [31:0] addr;
rand bit [7:0]  data;
function new(string name, uvm_component parent);   // must pass parent!
super.new(name, parent);
endfunction
endclass
 
// What breaks:
// ✗ Cannot use as TLM sequence_item — uvm_driver expects uvm_sequence_item
// ✗ Cannot clone() — components do not support clone
// ✗ Every "transaction" permanently occupies a slot in the hierarchy tree
// ✗ Sequences cannot start on it
// ✗ Randomize runs but factory override doesn't work via `uvm_object_utils

// In my_agent.sv (path = "uvm_test_top.env.apb_agent")
function void build_phase(uvm_phase phase);
super.build_phase(phase);
 
// ❌ WRONG — null parent disconnects driver from hierarchy
drv = apb_driver::type_id::create("drv", null);
// drv.get_full_name() → "drv"  (not "uvm_test_top.env.apb_agent.drv")
// uvm_config_db::get(this, "drv", "vif", vif) → FAILS
// Because the scoping path doesn't match
 
// ✓ CORRECT — 'this' = the agent, places driver as its child
drv = apb_driver::type_id::create("drv", this);
// drv.get_full_name() → "uvm_test_top.env.apb_agent.drv"  ✓
endfunction

// ════════════════════════════════════════════════════════════════
//  DECISION CHECKLIST
//
//  ✓ Is it data that moves between components?        → uvm_sequence_item
//  ✓ Is it a sequence that generates stimulus?        → uvm_sequence
//  ✓ Does it need build_phase / run_phase callbacks?  → uvm_component
//  ✓ Is there exactly one instance in the topology?   → uvm_component
//  ✓ Is it created and discarded repeatedly?          → uvm_object
//  ✓ Does it get cloned?                              → uvm_object
//  ✓ Does it flow through a TLM port?                 → uvm_sequence_item
// ════════════════════════════════════════════════════════════════
 
// ── uvm_object: one arg, uvm_object_utils, factory with no parent ──
class my_txn extends uvm_sequence_item;
`uvm_object_utils(my_txn)
function new(string name = "my_txn");
super.new(name);
endfunction
endclass
// Create:  my_txn::type_id::create("txn")  — no parent
 
// ── uvm_component: two args, uvm_component_utils, factory WITH parent ─
class my_driver extends uvm_driver #(my_txn);
`uvm_component_utils(my_driver)
function new(string name, uvm_component parent);
super.new(name, parent);
endfunction
function void build_phase(uvm_phase phase);
super.build_phase(phase);  // create sub-components here
endfunction
task run_phase(uvm_phase phase);
// drive DUT here
endtask
endclass
// Create:  my_driver::type_id::create("drv", this)  — parent = this (the agent)
 
// ── Key get_full_name() paths (knowing this is essential for config_db) ─
// uvm_test_top                               ← the test itself
// uvm_test_top.env                           ← environment
// uvm_test_top.env.apb_agent                 ← agent
// uvm_test_top.env.apb_agent.drv             ← driver
// uvm_test_top.env.apb_agent.mon             ← monitor
// uvm_test_top.env.apb_agent.seqr            ← sequencer
// uvm_test_top.env.scb                       ← scoreboard

`include "uvm_macros.svh"
import uvm_pkg::*;
 
// ── uvm_object: created on demand, garbage-collected when unreferenced
class simple_txn extends uvm_sequence_item;
`uvm_object_utils(simple_txn)
rand bit[7:0] data;
function new(string n="simple_txn"); super.new(n); endfunction
endclass
 
// ── uvm_component: created once in build_phase, lives forever
class lifecycle_test extends uvm_test;
`uvm_component_utils(lifecycle_test)
function new(string n, uvm_component p); super.new(n,p); endfunction
 
task run_phase(uvm_phase phase);
phase.raise_objection(this);
 
// Object: created on demand inside a task
begin
simple_txn txn = simple_txn::type_id::create("txn");
void'(txn.randomize());
$display("[OBJ] Created  @ %0t: data=%0h", $time, txn.data);
#10ns;
$display("[OBJ] Using    @ %0t: data=%0h", $time, txn.data);
end  // txn goes out of scope → eligible for GC
$display("[OBJ] txn out of scope — garbage collected");
 
// Component: already exists — we're inside it right now
$display("[COMP] I (%s) have existed since build_phase", get_full_name());
$display("[COMP] I will exist until simulation ends");
$display("[COMP] My depth in hierarchy: %0d", get_depth());
 
#5ns;
phase.drop_objection(this);
endtask
endclass
 
module lifecycle_top;
initial run_test("lifecycle_test");
endmodule
 
// Expected Output:
// [OBJ] Created  @ 0: data=a3
// [OBJ] Using    @ 10: data=a3
// [OBJ] txn out of scope — garbage collected
// [COMP] I (uvm_test_top) have existed since build_phase
// [COMP] I will exist until simulation ends
// [COMP] My depth in hierarchy: 1

`include "uvm_macros.svh"
import uvm_pkg::*;
 
class child_comp extends uvm_component;
`uvm_component_utils(child_comp)
function new(string n, uvm_component p); super.new(n,p); endfunction
function void build_phase(uvm_phase phase);
super.build_phase(phase);
$display("  [%s] build_phase — depth=%0d parent=%s",
get_name(), get_depth(), get_parent().get_name());
endfunction
endclass
 
class parent_test extends uvm_test;
`uvm_component_utils(parent_test)
child_comp child_a, child_b;
 
function new(string n, uvm_component p); super.new(n,p); endfunction
 
function void build_phase(uvm_phase phase);
super.build_phase(phase);
// Both children are placed under THIS component in the hierarchy
child_a = child_comp::type_id::create("child_a", this);
child_b = child_comp::type_id::create("child_b", this);
$display("[%s] I have %0d children", get_name(), get_num_children());
endfunction
 
task run_phase(uvm_phase phase);
phase.raise_objection(this);
`uvm_info("TEST", "Printing component topology:", UVM_NONE)
uvm_root::get().print_topology();
phase.drop_objection(this);
endtask
endclass
 
module hierarchy_top;
initial run_test("parent_test");
endmodule
 
// Expected Output:
// [uvm_test_top] I have 2 children
//   [child_a] build_phase — depth=2 parent=uvm_test_top
//   [child_b] build_phase — depth=2 parent=uvm_test_top
// uvm_test_top (parent_test)
//   child_a (child_comp)
//   child_b (child_comp)

`include "uvm_macros.svh"
import uvm_pkg::*;
 
// ── OBJECT: APB transaction — flows through testbench, created many times
class apb_txn extends uvm_sequence_item;   // ← uvm_object family
`uvm_object_utils(apb_txn)
rand bit[31:0] addr, data;
rand bit write;
function new(string n="apb_txn"); super.new(n); endfunction
function string convert2string();
return $sformatf("%s a=%0h d=%0h",write?"WR":"RD",addr,data);
endfunction
endclass
 
// ── COMPONENT: Scoreboard — exists once, receives transactions, checks them
class apb_scoreboard extends uvm_scoreboard;   // ← uvm_component family
`uvm_component_utils(apb_scoreboard)
uvm_analysis_imp#(apb_txn, apb_scoreboard) mon_imp;
apb_txn expected_q[$];   // queue of expected objects
int pass_cnt, fail_cnt;
 
function new(string n, uvm_component p); super.new(n,p); endfunction
 
function void build_phase(uvm_phase phase);
super.build_phase(phase);
mon_imp = new("mon_imp", this);
endfunction
 
// write() receives a uvm_object (transaction) at runtime
function void write(apb_txn actual);
apb_txn exp;
if(expected_q.size() == 0) begin
`uvm_error("SCB","No expected transaction available")
return;
end
exp = expected_q.pop_front();
 
if(actual.addr==exp.addr && actual.data==exp.data && actual.write==exp.write) begin
`uvm_info("SCB",$sformatf("PASS: %s",actual.convert2string()),UVM_LOW)
pass_cnt++;
end else begin
`uvm_error("SCB",$sformatf("FAIL: got %s exp %s",
actual.convert2string(), exp.convert2string()))
fail_cnt++;
end
endfunction
 
function void check_phase(uvm_phase phase);
super.check_phase(phase);
$display("\n[SCB] Results: PASS=%0d FAIL=%0d", pass_cnt, fail_cnt);
endfunction
endclass
 
// Key observation:
// - apb_txn (object): 100s created per test, garbage-collected freely
// - apb_scoreboard (component): ONE instance, lives entire simulation
// - The scoreboard receives objects and stores them in a queue
// - Queue grows/shrinks dynamically — objects are born and die
// - Scoreboard never dies — it has a parent and permanent hierarchy position

`include "uvm_macros.svh"
import uvm_pkg::*;
 
class phantom_demo extends uvm_test;
`uvm_component_utils(phantom_demo)
function new(string n, uvm_component p); super.new(n,p); endfunction
 
task run_phase(uvm_phase phase);
phase.raise_objection(this);
 
// ❌ WRONG: Creating a component in run_phase
begin
uvm_component phantom;
phantom = uvm_component::type_id::create("phantom", this);
// phantom EXISTS in the hierarchy
$display("phantom path: %s", phantom.get_full_name());
// BUT its build_phase, connect_phase already ran → NEVER called
// It missed build_phase, connect_phase, start_of_simulation_phase
// It WILL NOT receive run_phase callback either
// uvm_config_db lookups by path WILL FAIL for it
end
 
// ✓ CORRECT: Objects CAN be created anywhere, anytime
begin
uvm_sequence_item item = uvm_sequence_item::type_id::create("item");
$display("item name: %s (no path — it is an object)", item.get_name());
// Objects: no phases, no hierarchy, totally fine to create any time
end
 
#5ns;
phase.drop_objection(this);
endtask
endclass
 
module phantom_top;
initial run_test("phantom_demo");
endmodule
 
// This is why the rule exists:
// COMPONENTS → only in build_phase (receive all phase callbacks)
// OBJECTS    → anywhere, anytime (no phases, no restrictions)

// ❌ WRONG — component created in task (run_phase context)
task run_phase(uvm_phase phase);
my_monitor late_mon;
late_mon = my_monitor::type_id::create("late_mon", this);
// late_mon.build_phase() was NEVER called
// late_mon.vif = null (config_db lookup never happened)
// late_mon.run_phase() will NEVER be called by the framework
// Manually calling: late_mon.run_phase(phase) creates a new uvm_phase context — WRONG
endtask
 
// ✓ CORRECT — component created in build_phase
my_monitor mon;   // class-level handle
 
function void build_phase(uvm_phase phase);
super.build_phase(phase);
mon = my_monitor::type_id::create("mon", this);
// mon.build_phase() called automatically by UVM framework
// mon.connect_phase() called automatically
// mon.run_phase() called automatically — it's a proper component
endfunction

// ❌ WRONG — storing raw handle (alias, not a copy)
apb_txn expected_q[$];
 
function void write_expected(apb_txn txn);
expected_q.push_back(txn);    // ← just stores the reference</    // If the caller randomizes txn again, ALL entries in the queue change
endfunction
 
// ✓ CORRECT — clone the object to get an independent copy
function void write_expected(apb_txn txn);
apb_txn copy;
$cast(copy, txn.clone());    // ← independent deep copy
expected_q.push_back(copy);   // ← now safe to randomize txn again
endfunction
 
// Debug: If your scoreboard always passes regardless of DUT output
// → check whether you're cloning before storing expected transactions
// → print expected_q contents; if all entries are identical → aliasing bug

// ================================================================
// obj_vs_comp_demo.sv — uvm_object vs uvm_component Demonstration
//
// Compile (Questa):
//   vlog -sv -L uvm_1_2 obj_vs_comp_demo.sv
//   vsim -c -L uvm_1_2 obj_vs_comp_demo_top -do "run -all; quit"
//
// Compile (VCS):
//   vcs -sverilog -ntb_opts uvm-1.2 obj_vs_comp_demo.sv && ./simv
//
// Compile (Xcelium):
//   xrun -sv -uvm obj_vs_comp_demo.sv
// ================================================================
 
`include "uvm_macros.svh"
import uvm_pkg::*;
 
// ── OBJECT: data that flows — no hierarchy, no phases ─────────────
class demo_pkt extends uvm_sequence_item;
`uvm_object_utils_begin(demo_pkt)
`uvm_field_int(id,   UVM_ALL_ON)
`uvm_field_int(data, UVM_ALL_ON)
`uvm_object_utils_end
 
rand bit[7:0] id;
rand bit[31:0] data;
 
function new(string n="demo_pkt"); super.new(n); endfunction
 
function string convert2string();
return $sformatf("pkt[id=%0d data=0x%0h]", id, data);
endfunction
endclass
 
// ── COMPONENT: structural, has phases, fixed in hierarchy ──────────
class demo_collector extends uvm_component;
`uvm_component_utils(demo_collector)
 
demo_pkt collected_q[$];
int      received_count;
 
function new(string n, uvm_component p); super.new(n,p); endfunction
 
function void build_phase(uvm_phase phase);
super.build_phase(phase);
$display("  [collector] build_phase @ %0t — I am %s",
$time, get_full_name());
endfunction
 
function void receive(demo_pkt pkt);
demo_pkt stored;
$cast(stored, pkt.clone());  // ← CLONE before storing
collected_q.push_back(stored);
received_count++;
$display("  [collector] Received #%0d: %s",
received_count, stored.convert2string());
endfunction
 
function void check_phase(uvm_phase phase);
super.check_phase(phase);
$display("  [collector] check_phase — %0d packets collected", received_count);
endfunction
endclass
 
// ── TEST: orchestrates objects and components ──────────────────────
class demo_test extends uvm_test;
`uvm_component_utils(demo_test)
 
demo_collector collector;  // component — class member (persists)
 
function new(string n, uvm_component p); super.new(n,p); endfunction
 
function void build_phase(uvm_phase phase);
super.build_phase(phase);
collector = demo_collector::type_id::create("collector", this);
endfunction
 
task run_phase(uvm_phase phase);
demo_pkt pkt;  // object — local variable (created on demand)
phase.raise_objection(this);
 
`uvm_info("TEST", "\n=== Creating and sending 4 packets ===", UVM_NONE)
 
// Each iteration: create a NEW object, use it, pass to collector
repeat(4) begin
pkt = demo_pkt::type_id::create($sformatf("pkt_%0d",
collector.received_count + 1));
void'(pkt.randomize());
collector.receive(pkt);
#5ns;
end
 
`uvm_info("TEST", "\n=== Object count vs Component count ===", UVM_NONE)
$display("  Objects created: 4 (all eligible for GC now)");
$display("  Components: %0d (in hierarchy, permanent)",
get_num_children() + 1);
 
`uvm_info("TEST", "\n=== Topology ===", UVM_NONE)
uvm_root::get().print_topology();
 
phase.drop_objection(this);
endtask
endclass
 
module obj_vs_comp_demo_top;
initial run_test("demo_test");
endmodule
 
// ================================================================
// Expected Output:
//   [collector] build_phase @ 0 — I am uvm_test_top.collector
//
// === Creating and sending 4 packets ===
//   [collector] Received #1: pkt[id=42 data=0xa3f2b1c0]
//   [collector] Received #2: pkt[id=17 data=0x7e920f44]
//   [collector] Received #3: pkt[id=99 data=0x1bc5d830]
//   [collector] Received #4: pkt[id=05 data=0xf04a71e2]
//
// === Object count vs Component count ===
//   Objects created: 4 (all eligible for GC now)
//   Components: 2 (in hierarchy, permanent)
//
// === Topology ===
// uvm_test_top (demo_test)
//   collector (demo_collector)
//
//   [collector] check_phase — 4 packets collected
// ================================================================