Object Cloning

// ── clone(): allocate + copy ────────────────────────────────────────
// Returns uvm_object — MUST $cast to your type
apb_txn original, cloned;
original = apb_txn::type_id::create("orig");
void'(original.randomize());
 
// Pattern 1: $cast on a separate line (most readable)
begin
uvm_object tmp;
tmp = original.clone();               // returns uvm_object
if (!$cast(cloned, tmp))               // downcast to apb_txn
`uvm_fatal("CLONE", "Cast failed")
end
 
// Pattern 2: Inline $cast (most common in production code)
$cast(cloned, original.clone());
 
// Pattern 3: With null check (most defensive)
if (!$cast(cloned, original.clone()))
`uvm_fatal("CLONE", "clone() returned wrong type")
 
// ── copy(): no allocation — destination must already exist ──────────
apb_txn dst = apb_txn::type_id::create("dst");
dst.copy(original);   // fields from original → dst; no new object created
 
// ── What clone() does internally (simplified) ───────────────────────
// function uvm_object uvm_object::clone();
//   uvm_object copy = this.create(this.get_name()); // factory-based allocation
//   if (copy == null) begin
//     uvm_fatal("CLONE", "create() returned null")
//   end
//   copy.copy(this);   // calls do_copy() on the new object
//   return copy;
// endfunction
 
// ── Cloning and modifying — they are truly independent ───────────────
cloned.addr = 32'hFFFF_0000;   // does NOT affect original.addr
original.data = 32'h1234_5678; // does NOT affect cloned.data

// ── ❌ WRONG: Single handle reused every iteration ────────────────────
task run_phase(uvm_phase phase);
apb_txn txn = apb_txn::type_id::create("txn");  // created ONCE outside loop
forever begin
@(posedge vif.clk iff (vif.psel && vif.penable && vif.pready));
txn.addr  = vif.paddr;     // ← overwrites previous values
txn.data  = vif.prdata;
txn.write = vif.pwrite;
analysis_port.write(txn);  // all subscribers get the SAME handle
// Next iteration overwrites txn.addr/data/write
// → every stored handle now points to the new values
end
endtask
 
// ── ✓ PATTERN A: New object each iteration (cleanest) ─────────────────
task run_phase(uvm_phase phase);
forever begin
apb_txn txn;    // declared inside loop — new null handle each iteration
@(posedge vif.clk iff (vif.psel && vif.penable && vif.pready));
txn = apb_txn::type_id::create("txn");  // new object each iteration
txn.addr  = vif.paddr;
txn.data  = vif.prdata;
txn.write = vif.pwrite;
analysis_port.write(txn);   // each subscriber gets its own unique object
end
endtask
 
// ── ✓ PATTERN B: Clone before write (useful when construction is expensive) ──
task run_phase(uvm_phase phase);
apb_txn txn = apb_txn::type_id::create("txn");
forever begin
apb_txn snap;
@(posedge vif.clk iff (vif.psel && vif.penable && vif.pready));
txn.addr  = vif.paddr;
txn.data  = vif.prdata;
txn.write = vif.pwrite;
$cast(snap, txn.clone());        // snapshot before potentially overwriting
analysis_port.write(snap);        // safe — snap is independent
end
endtask
 
// ── ✓ PATTERN C: copy() into pre-allocated buffer (high-throughput systems) ──
task run_phase(uvm_phase phase);
apb_txn scratch   = apb_txn::type_id::create("scratch");
apb_txn published = apb_txn::type_id::create("published");
forever begin
@(posedge vif.clk iff (vif.psel && vif.penable && vif.pready));
scratch.addr  = vif.paddr;
scratch.data  = vif.prdata;
scratch.write = vif.pwrite;
published.copy(scratch);     // copy fields into pre-allocated 'published'
analysis_port.write(published);
// NOTE: This still has aliasing if subscribers store 'published' handle!
// Only safe if subscribers immediately consume and discard the write() argument
// Prefer Pattern A or B for storage-safe usage
end
endtask

class apb_scoreboard extends uvm_scoreboard;
`uvm_component_utils(apb_scoreboard)
`uvm_analysis_imp_decl(`REQ)
`uvm_analysis_imp_decl(`RSP)
 
uvm_analysis_imp_REQ#(apb_txn,apb_scoreboard) req_imp;
uvm_analysis_imp_RSP#(apb_txn,apb_scoreboard) rsp_imp;
 
apb_txn expected_q[$];   // stores CLONES — not the original handles
 
function new(string n, uvm_component p); super.new(n,p); endfunction
 
function void build_phase(uvm_phase phase);
super.build_phase(phase);
req_imp = new("req_imp", this);
rsp_imp = new("rsp_imp", this);
endfunction
 
function void write_REQ(apb_txn txn);
apb_txn stored_copy;
// CRITICAL: clone() before pushing — we don't own txn
// The monitor (or whoever called write()) still controls that handle
$cast(stored_copy, txn.clone());
stored_copy.set_name($sformatf("exp_%0d", expected_q.size()));
expected_q.push_back(stored_copy);
`uvm_info("SCB",$sformatf("Stored clone of txn, queue depth=%0d",
expected_q.size()),UVM_HIGH)
endfunction
 
function void write_RSP(apb_txn actual);
apb_txn expected;
if (expected_q.size() == 0) begin
`uvm_error("SCB","Response received but expected queue is empty")
return;
end
expected = expected_q.pop_front();
if (!expected.compare(actual))
`uvm_error("SCB",$sformatf(
"MISMATCH!\nExp: %s\nAct: %s",
expected.sprint(), actual.sprint()))
else
`uvm_info("SCB","Match ✓",UVM_HIGH)
endfunction
endclass

class axi_ref_model extends uvm_component;
`uvm_component_utils(axi_ref_model)
 
uvm_blocking_get_port#(axi_txn) stim_port;
uvm_analysis_port#(axi_txn)     predicted_ap;
 
function new(string n, uvm_component p); super.new(n,p); endfunction
 
function void build_phase(uvm_phase phase);
super.build_phase(phase);
stim_port    = new("stim_port",    this);
predicted_ap = new("predicted_ap", this);
endfunction
 
task run_phase(uvm_phase phase);
axi_txn stim, predicted;
forever begin
stim_port.get(stim);
 
// Clone before mutating — we don't own 'stim'
// The driver or sequence may still reference this object
$cast(predicted, stim.clone());
 
// Apply DUT transformations to the clone — never touch stim
if (predicted.write) begin
predicted.resp = 2'b00;         // OKAY response for writes
end else begin
predicted.rdata = mem_model(predicted.addr);
predicted.resp  = 2'b00;
end
 
// Publish the predicted response — scoreboard compares this to DUT output
predicted_ap.write(predicted);
end
endtask
 
function bit[31:0] mem_model(bit[31:0] addr);
// simplified memory model lookup
return mem[addr];
endfunction
 
bit[31:0] mem[bit[31:0]];  // associative array backing store
endclass

// ── Verify clone() produces independent objects ───────────────────────
apb_txn a, b;
a = apb_txn::type_id::create("a");
void'(a.randomize());
automatic bit[31:0] orig_addr = a.addr;
 
$cast(b, a.clone());
 
// Verify independence: modify a, b should not change
a.addr = 32'hFFFF_FFFF;
`uvm_info("T",$sformatf(
"a.addr=0x%0h  b.addr=0x%0h  same?=%0b",
a.addr, b.addr, (a.addr === b.addr)),UVM_NONE)
// Expected: a.addr=0xFFFFFFFF  b.addr=0x????????  same?=0 ← independent!
 
// ── Verify clone() respects factory override ──────────────────────────
// If test registered: apb_txn → debug_apb_txn
// Then: type_name of the clone should be debug_apb_txn
`uvm_info("T",$sformatf("Clone type: %s", b.get_type_name()),UVM_NONE)
// Without override: "apb_txn"
// With    override: "debug_apb_txn"  ← factory works through clone()

// ── Diagnostic: detect aliasing with address comparison ───────────────
function void write_RSP(apb_txn actual);
apb_txn expected = expected_q.pop_front();
 
// Quick aliasing diagnostic — if addresses are same, we have a bug
`uvm_info("SCB_DBG",$sformatf(
"exp handle=%p  act handle=%p  same=%0b",
expected, actual, (expected === actual)),  // === on handles = pointer compare
UVM_DEBUG)
// If same=1 → ALIASING BUG confirmed
 
if (!expected.compare(actual))
`uvm_error("SCB","Mismatch")
endfunction
 
// ── Bug 2: copy() without a pre-created destination ───────────────────
// ❌ WRONG: null handle — crash at txn_b.copy()
apb_txn txn_b;       // null handle — no object yet
txn_b.copy(txn_a);   // CRASH: null dereference
 
// ✓ CORRECT: create first, then copy
apb_txn txn_b = apb_txn::type_id::create("txn_b");
txn_b.copy(txn_a);   // safe — txn_b already exists
// OR use clone() which handles allocation automatically:
$cast(txn_b, txn_a.clone());   // safer, simpler
 
// ── Bug 3: Forgetting to clone in write() — false coverage closure ────
// ❌ WRONG: coverage stores aliased handle
function void write(apb_txn txn);
cov_queue.push_back(txn);   // ALIASED — later monitor writes corrupt history
endfunction
 
// ✓ CORRECT: clone before storing
function void write(apb_txn txn);
apb_txn snap;
$cast(snap, txn.clone());
cov_queue.push_back(snap);
endfunction

// clone_demo.sv — demonstrates handle aliasing bug and clone() fix
// Questa : vlog -sv clone_demo.sv && vsim -c clone_demo_top -do "run -all; quit"
// VCS    : vcs -sverilog -ntb_opts uvm clone_demo.sv && ./simv
// Xcelium: xrun -sv -uvm clone_demo.sv -input "run; exit"
 
`include "uvm_macros.svh"
import uvm_pkg::*;
 
class pkt extends uvm_sequence_item;
`uvm_object_utils(pkt)
rand bit[7:0] id;
rand bit[31:0] data;
function new(string n="pkt"); super.new(n); endfunction
 
function void do_copy(uvm_object rhs);
pkt r; super.do_copy(rhs); $cast(r,rhs);
id=r.id; data=r.data;
endfunction
endclass
 
class clone_test extends uvm_test;
`uvm_component_utils(clone_test)
function new(string n, uvm_component p); super.new(n,p); endfunction
 
task run_phase(uvm_phase phase);
pkt p, q;
phase.raise_objection(this);
 
`uvm_info("TEST","═══ DEMONSTRATION 1: Handle aliasing bug ═══",UVM_NONE)
p = pkt::type_id::create("p");
p.id=1; p.data=32'hAAAA_BBBB;
q = p;    // handle assignment — ALIASING
`uvm_info("TEST",$sformatf("Before: p.data=0x%0h  q.data=0x%0h",
p.data,q.data),UVM_NONE)
p.data = 32'hCCCC_DDDD;   // modify p
`uvm_info("TEST",$sformatf("After p.data change: p.data=0x%0h  q.data=0x%0h (BOTH CHANGED!)",
p.data,q.data),UVM_NONE)
 
`uvm_info("TEST","═══ DEMONSTRATION 2: clone() independence ═══",UVM_NONE)
p.data = 32'hAAAA_BBBB;
$cast(q, p.clone());  // deep, independent copy
`uvm_info("TEST",$sformatf("Before: p.data=0x%0h  q.data=0x%0h",
p.data,q.data),UVM_NONE)
p.data = 32'hCCCC_DDDD;   // modify p
`uvm_info("TEST",$sformatf("After p.data change: p.data=0x%0h  q.data=0x%0h (q UNCHANGED!)",
p.data,q.data),UVM_NONE)
 
`uvm_info("TEST","═══ DEMONSTRATION 3: copy() requires existing destination ═══",UVM_NONE)
p.data = 32'h1234_5678;
q = pkt::type_id::create("q");  // must exist before copy()
q.copy(p);
`uvm_info("TEST",$sformatf("After copy: p.data=0x%0h  q.data=0x%0h (same? %0b)",
p.data,q.data,(p.data===q.data)),UVM_NONE)
p.data = 32'hFFFF_0000;
`uvm_info("TEST",$sformatf("After p change: p.data=0x%0h  q.data=0x%0h (q independent? %0b)",
p.data,q.data,(p.data!==q.data)),UVM_NONE)
 
`uvm_info("TEST","═══ DEMONSTRATION 4: Monitor loop aliasing vs fix ═══",UVM_NONE)
begin
pkt queue[$];
pkt monitor_txn = pkt::type_id::create("m");
// BUGGY: reuse same handle
for(int i=0;i<3;i++) begin
monitor_txn.id=i; monitor_txn.data=i*100;
queue.push_back(monitor_txn);  // all aliases!
end
`uvm_info("TEST",$sformatf(
"Buggy queue: [0].id=%0d [1].id=%0d [2].id=%0d (all same!)",
queue[0].id,queue[1].id,queue[2].id),UVM_NONE)
queue.delete();
 
// FIXED: clone each iteration
for(int i=0;i<3;i++) begin
pkt snap;
monitor_txn.id=i; monitor_txn.data=i*100;
$cast(snap, monitor_txn.clone());
queue.push_back(snap);   // each is independent
end
`uvm_info("TEST",$sformatf(
"Fixed queue: [0].id=%0d [1].id=%0d [2].id=%0d (each correct!)",
queue[0].id,queue[1].id,queue[2].id),UVM_NONE)
end
 
phase.drop_objection(this);
endtask
endclass
 
module clone_demo_top;
initial run_test("clone_test");
endmodule
 
// EXPECTED OUTPUT:
// TEST: ═══ DEMONSTRATION 1: Handle aliasing bug ═══
// TEST: Before: p.data=0xaaaabbbb  q.data=0xaaaabbbb
// TEST: After p.data change: p.data=0xccccdddd  q.data=0xccccdddd (BOTH CHANGED!)
// TEST: ═══ DEMONSTRATION 2: clone() independence ═══
// TEST: Before: p.data=0xaaaabbbb  q.data=0xaaaabbbb
// TEST: After p.data change: p.data=0xccccdddd  q.data=0xaaaabbbb (q UNCHANGED!)
// TEST: ═══ DEMONSTRATION 3: copy() requires existing destination ═══
// TEST: After copy: p.data=0x12345678  q.data=0x12345678 (same? 1)
// TEST: After p change: p.data=0xffff0000  q.data=0x12345678 (q independent? 1)
// TEST: ═══ DEMONSTRATION 4: Monitor loop aliasing vs fix ═══
// TEST: Buggy queue: [0].id=2 [1].id=2 [2].id=2 (all same!)
// TEST: Fixed queue: [0].id=0 [1].id=1 [2].id=2 (each correct!)