config_db Gotchas

// ── set() — stores a value in the type-keyed global database ─────────────
static function bit set(
uvm_component cntxt,       // ① Anchor: cntxt.get_full_name() is the scope PREFIX
//   'this' in a component → scope is that component's path
//   'null' in tb_top/initial → inst_name IS the full pattern
string        inst_name,   // ② Pattern: appended to cntxt's path with a "."
//   Glob wildcards: '*' matches any chars including dots
//   "*.drv" matches any path ending in .drv
//   "" means only the cntxt's own path
string        field_name,  // ③ Key: case-sensitive, byte-for-byte exact string
//   "vif" ≠ "VIF" ≠ "vif " (trailing space!) ≠ "vif\n"
T             value        // ④ Value: stored keyed on {type T, scope, field_name}
//   Type T is part of the key — int ≠ bit[31:0]
);
 
// ── get() — retrieves value; returns 1 (HIT) or 0 (MISS) ────────────────
static function bit get(
uvm_component cntxt,       // ① Who is calling: 'this' in almost all cases
//   get_full_name() forms the base of the lookup path
string        inst_name,   // ② Suffix: usually "" — means search at cntxt's path
//   Non-empty: cntxt.full_name + "." + inst_name
string        field_name,  // ③ Key: must byte-for-byte match the set() field_name
inout T       value        // ④ Output: written ONLY on HIT
//   On MISS: variable is UNTOUCHED — not cleared, not zero
);
// Return value: 1 = HIT  |  0 = MISS.  ALWAYS check this.

// ❌ WRONG — set() AFTER super.build_phase() ─────────────────────────
class my_test extends base_test;
function void build_phase(uvm_phase phase);
super.build_phase(phase);   // ← triggers env→agent→driver build cascade
// driver already ran get("vif") and got MISS — now setting is pointless
uvm_config_db#(virtual apb_if)::set(this, "*.drv", "vif", apb_vif);
endfunction
endclass
// Simulator output: uvm_fatal CFG: "vif not found in config_db"
 
// ✓ CORRECT — set() BEFORE super.build_phase() ────────────────────────
class my_test extends base_test;
function void build_phase(uvm_phase phase);
// ALL set() calls go here — before the cascade
uvm_config_db#(virtual apb_if)::set(this, "*.drv", "vif", apb_vif);
uvm_config_db#(int)::set(this, "*", "num_txns", 200);
 
super.build_phase(phase);   // ← cascade starts — all components find their data
endfunction
endclass

// ── Scenario 1: int vs. bit mismatch ─────────────────────────────────
// tb_top.sv:
uvm_config_db#(int)::set(null, "uvm_test_top.*", "timeout", 1000);
 
// apb_monitor.sv:
bit [31:0] timeout_val;
if (!uvm_config_db#(bit [31:0])::get(this, "", "timeout", timeout_val))
`uvm_fatal("CFG", "timeout not found")
// Fails! config_db #(int) ≠ config_db #(bit[31:0]) — different databases
// Fix: use int in both set() and get(), or cast consistently
 
// ── Scenario 2: virtual interface modport mismatch ────────────────────
// tb_top.sv — stores the full interface:
uvm_config_db#(virtual apb_if)::set(null, "uvm_test_top.*", "vif", apb_vif);
 
// apb_driver.sv — tries to get with modport:
virtual apb_if.master drv_vif;
if (!uvm_config_db#(virtual apb_if.master)::get(this, "", "vif", drv_vif))
`uvm_fatal("CFG", "vif not found")
// Fails! virtual apb_if ≠ virtual apb_if.master — different types
// Fix: store and retrieve as 'virtual apb_if' (no modport), assign modport in driver
 
// ── Correct approach: consistent types, assign modport locally ────────
virtual apb_if vif;
if (!uvm_config_db#(virtual apb_if)::get(this, "", "vif", vif))
`uvm_fatal("CFG", "vif not found")
// Now vif is valid. Access modport implicitly via port directions in the driver.

// ── Case mismatch ─────────────────────────────────────────────────────
uvm_config_db#(virtual apb_if)::set(null, "uvm_test_top.*", "APB_VIF", vif);
uvm_config_db#(virtual apb_if)::get(this, "", "apb_vif", vif);   // MISS — wrong case
 
// ── Trailing space (invisible in code review) ──────────────────────────
uvm_config_db#(int)::set(null, "uvm_test_top.*", "num_txns ", 100);  // note space
uvm_config_db#(int)::get(this, "", "num_txns", n);             // MISS — no space
 
// ── Typo ──────────────────────────────────────────────────────────────
uvm_config_db#(bit)::set(null, "uvm_test_top.*", "is_activee", 1);  // double-e
uvm_config_db#(bit)::get(this, "", "is_active", flag);          // MISS
 
// ── Prevention: use a shared constant string ──────────────────────────
package cfg_keys;
localparam string APB_VIF    = "apb_vif";
localparam string NUM_TXNS   = "num_txns";
localparam string IS_ACTIVE  = "is_active";
endpackage
 
// Both set() and get() reference the same constant — typos caught at compile time
uvm_config_db#(virtual apb_if)::set(null, "uvm_test_top.*", cfg_keys::APB_VIF, vif);
uvm_config_db#(virtual apb_if)::get(this, "", cfg_keys::APB_VIF, vif);

// ── Component renamed — scope no longer matches ───────────────────────
// tb_top sets using old name:
uvm_config_db#(virtual apb_if)::set(null, "uvm_test_top.env.apb_agent.drv", "vif", vif);
 
// Agent was refactored and driver is now named "driver" not "drv":
// create("driver", this)  ←  path is now "uvm_test_top.env.apb_agent.driver"
// "uvm_test_top.env.apb_agent.drv" ≠ "uvm_test_top.env.apb_agent.driver" → MISS
// Fix: use wildcards for component-name-independent patterns
 
uvm_config_db#(virtual apb_if)::set(null, "uvm_test_top.*", "vif", vif);
// "uvm_test_top.*" matches any path starting with "uvm_test_top." → robust
 
// ── Wrong root when cntxt is not null ────────────────────────────────
// Inside my_env (full_name = "uvm_test_top.env"):
uvm_config_db#(int)::set(this, "apb_agent.*", "num_txns", 100);
// Scope = "uvm_test_top.env" + "." + "apb_agent.*"
// = "uvm_test_top.env.apb_agent.*"
// Covers: any component directly under apb_agent
 
// But actual agent is named "apb_agent_0" not "apb_agent" →
// Getter at "uvm_test_top.env.apb_agent_0.drv" → NO MATCH
// Fix: use wildcard in agent name
uvm_config_db#(int)::set(this, "apb_agent_*.*", "num_txns", 100);
// or even broader:
uvm_config_db#(int)::set(this, "*", "num_txns", 100);
// Scope: "uvm_test_top.env.*" — covers all children of env
 
// ── Debug: print the actual getter path ───────────────────────────────
// In the driver's build_phase, before get():
`uvm_info("PATH", $sformatf("My full path: %s", get_full_name()), UVM_LOW)
// Then compare with the inst_name pattern used in set()

// ❌ DANGEROUS — silently proceeds with null vif ───────────────────────
function void build_phase(uvm_phase phase);
super.build_phase(phase);
uvm_config_db#(virtual apb_if)::get(this, "", "vif", vif);
// Return value ignored — vif stays null if miss — crash happens in run_phase
endfunction
 
// ✓ SAFE — fatal on miss (recommended for all critical resources) ──────
function void build_phase(uvm_phase phase);
super.build_phase(phase);
if (!uvm_config_db#(virtual apb_if)::get(this, "", "vif", vif))
`uvm_fatal("CFG", $sformatf(
"vif not found — check tb_top set() call. I am at: %s",
get_full_name()))
// Crash here — at the right place with a clear message
endfunction
 
// ✓ OPTIONAL — warn on miss (for non-critical configuration) ──────────
int num_txns = 100;   // default — used if config_db entry not found
if (!uvm_config_db#(int)::get(this, "", "num_txns", num_txns))
`uvm_info("CFG", "num_txns not in config_db, using default 100", UVM_MEDIUM)
 
// ✓ SILENT — for truly optional parameters (suppress warning) ─────────
void'(uvm_config_db#(int)::get(this, "", "debug_level", debug_level));

## Questa / ModelSim
vsim +UVM_CONFIG_DB_TRACE work.tb_top
 
## VCS
vcs +UVM_CONFIG_DB_TRACE ... && simv +UVM_CONFIG_DB_TRACE
 
## Xcelium
xrun -uvm_config_db_trace work.tb_top
 
## Combined: factory + config_db trace (maximum debug)
vsim +UVM_CONFIG_DB_TRACE +UVM_FACTORY_OVERRIDE_TRACE work.tb_top
 
## Filter output to only see MISS results (grep after the fact):
vsim +UVM_CONFIG_DB_TRACE work.tb_top |& grep -A3 "MISS"

// ── Prevention pattern — use this in every project ────────────────────
 
// 1. Centralise key strings
package cfg_keys_pkg;
localparam string APB_VIF   = "apb_vif";
localparam string NUM_TXNS  = "num_txns";
localparam string AGENT_CFG = "agent_cfg";
endpackage
 
// 2. Set before run_test() or before super.build_phase()
initial begin
uvm_config_db#(virtual apb_if)::set(
null, "uvm_test_top.*", cfg_keys_pkg::APB_VIF, apb_vif);
run_test();
end
 
// 3. Always check return value with uvm_fatal for critical data
virtual apb_if vif;
if (!uvm_config_db#(virtual apb_if)::get(this, "", cfg_keys_pkg::APB_VIF, vif))
`uvm_fatal("CFG", $sformatf(
"%s: apb_vif not found. Full path: %s. Check tb_top set() call.",
get_type_name(), get_full_name()))
 
// 4. Debug command — add when anything is suspicious
// vsim +UVM_CONFIG_DB_TRACE work.tb_top |& grep -B2 -A3 "MISS"

// ── tb_top.sv — THE right place to set virtual interfaces ────────────
module tb_top;
logic clk;
apb_if  apb_vif(clk);    // instance in tb_top
axi_if  axi_vif(clk);
 
initial begin
// Set before run_test() — the only 100% safe position
uvm_config_db#(virtual apb_if)::set(null, "uvm_test_top.*", "apb_vif", apb_vif);
uvm_config_db#(virtual axi_if)::set(null, "uvm_test_top.*", "axi_vif", axi_vif);
run_test();
end
endmodule
 
// ── apb_driver.sv — gets its VIF in build_phase ───────────────────────
class apb_driver extends uvm_driver#(apb_seq_item);
`uvm_component_utils(apb_driver)
virtual apb_if vif;   // null until build_phase
 
function void build_phase(uvm_phase phase);
super.build_phase(phase);
if (!uvm_config_db#(virtual apb_if)::get(this, "", "apb_vif", vif))
`uvm_fatal("VIF", $sformatf(
"%s: apb_vif not found. tb_top set() before run_test()? Path: %s",
get_type_name(), get_full_name()))
endfunction
 
task run_phase(uvm_phase phase);
seq_item_port.get_next_item(req);
// vif is guaranteed valid here — uvm_fatal fired otherwise
vif.paddr  <= req.addr;
vif.pwdata <= req.data;
endtask
endclass

// ── apb_agent_cfg.sv — all agent knobs in one object ─────────────────
class apb_agent_cfg extends uvm_object;
`uvm_object_utils(apb_agent_cfg)
bit         is_active  = 1;
int         num_txns   = 100;
bit         has_checks = 1;
int         baud_rate  = 115200;
endclass
 
// ── base_test.sv — creates and distributes the config ─────────────────
class base_test extends uvm_test;
apb_agent_cfg agent_cfg;
 
function void build_phase(uvm_phase phase);
agent_cfg = apb_agent_cfg::type_id::create("agent_cfg");
agent_cfg.is_active = 1;
 
// Single set() — type is apb_agent_cfg, not int or bit
uvm_config_db#(apb_agent_cfg)::set(this, "env.apb_agent", "cfg", agent_cfg);
super.build_phase(phase);   // ← cascade — agent gets it in its build_phase
endfunction
endclass
 
// ── error_test.sv — overrides specific fields before passing ──────────
class error_test extends base_test;
function void build_phase(uvm_phase phase);
super.build_phase(phase);  // base creates and sets agent_cfg
// Modify AFTER retrieval — but only if this test's scope also sets it
agent_cfg.has_checks = 0;   // override a field — no new set() needed
endfunction
endclass
 
// ── apb_agent.sv — retrieves config object in build_phase ────────────
class apb_agent extends uvm_agent;
apb_agent_cfg cfg;
 
function void build_phase(uvm_phase phase);
super.build_phase(phase);
if (!uvm_config_db#(apb_agent_cfg)::get(this, "", "cfg", cfg))
`uvm_fatal("CFG", "apb_agent_cfg not found in config_db")
// Pass it down to driver and monitor via config_db or direct handle
endfunction
endclass

// ── sb_cfg_keys.sv — shared key constants prevent ALL name errors ─────
package sb_cfg_keys;
localparam string PKT_TIMEOUT  = "pkt_timeout_ns";
localparam string MAX_ERRORS   = "max_errors";
localparam string COV_ENABLE   = "cov_enable";
endpackage
 
// ── test.sv — sets scoreboard knobs ───────────────────────────────────
import sb_cfg_keys::*;
function void build_phase(uvm_phase phase);
uvm_config_db#(int)::set(this, "env.sb", PKT_TIMEOUT, 500);
uvm_config_db#(int)::set(this, "env.sb", MAX_ERRORS,  0);
uvm_config_db#(bit)::set(this, "env.sb", COV_ENABLE,  1);
super.build_phase(phase);
endfunction
 
// ── apb_scoreboard.sv — retrieves with same type ─────────────────────
import sb_cfg_keys::*;
int  pkt_timeout_ns = 200;  // safe defaults
int  max_errors     = 5;
bit  cov_enable     = 0;
 
function void build_phase(uvm_phase phase);
super.build_phase(phase);
void'(uvm_config_db#(int)::get(this, "", PKT_TIMEOUT, pkt_timeout_ns));
void'(uvm_config_db#(int)::get(this, "", MAX_ERRORS,  max_errors));
void'(uvm_config_db#(bit)::get(this, "", COV_ENABLE,  cov_enable));
// void' suppresses lint; defaults are safe so MISS is OK here
endfunction

// ❌ RACE — test sets in run_phase, sequence gets in run_phase body() ──
// apb_test.sv run_phase:
task run_phase(uvm_phase phase);
phase.raise_objection(this);
uvm_config_db#(int)::set(null, "*", "burst_len", 16); // ← run_phase set()
my_seq.start(sequencer);   // sequence starts — but body() may have already begun
phase.drop_objection(this);
endtask
 
// apb_seq.sv body():
task body();
int burst_len = 4;   // default
void'(uvm_config_db#(int)::get(null, "*", "burst_len", burst_len));
// In Questa, start() is blocking — sequence starts after set() — OK.
// But in parallel sequences, this is non-deterministic.
endtask
 
// ✓ SAFE — pass knobs through build_phase, not run_phase ─────────────
function void build_phase(uvm_phase phase);
uvm_config_db#(int)::set(this, "*", "burst_len", 16); // ← build_phase = safe
super.build_phase(phase);
endfunction

// ── broken_test.sv (fails silently) ───────────────────────────────────
class broken_test extends base_test;
`uvm_component_utils(broken_test)
function void build_phase(uvm_phase phase);
super.build_phase(phase);   // ← env→agent→drv build cascade fires HERE
// driver.build_phase() already ran — get("vif") already returned 0
uvm_config_db#(virtual apb_if)::set(this, "*", "vif", vif);
endfunction
endclass
 
// ── correct_test.sv (passes) ───────────────────────────────────────────
class correct_test extends base_test;
`uvm_component_utils(correct_test)
function void build_phase(uvm_phase phase);
// set() before cascade — every component that needs vif will find it
uvm_config_db#(virtual apb_if)::set(this, "*", "vif", vif);
super.build_phase(phase);   // ← cascade starts, driver gets HIT
endfunction
endclass
 
// ── tb_top.sv — safest: set() before run_test() ───────────────────────
module tb_top;
apb_if apb_vif(clk);
initial begin
// set before run_test → arrives before ANY component's build_phase
uvm_config_db#(virtual apb_if)::set(null, "uvm_test_top.*", "vif", apb_vif);
run_test();
end
endmodule

// ── tb_top stores with type 'int' ─────────────────────────────────────
uvm_config_db#(int)::set(null, "uvm_test_top.*", "pkt_count", 500);
 
// ── monitor tries to get with 'bit [31:0]' ────────────────────────────
bit [31:0] pkt_count;
if (!uvm_config_db#(bit [31:0])::get(this, "", "pkt_count", pkt_count))
`uvm_fatal("CFG", "pkt_count not found")  // ← fires, even though set() ran
 
// ── What +UVM_CONFIG_DB_TRACE shows ──────────────────────────────────
//
//  SET uvm_config_db #(int)            by: null
//      context: uvm_test_top.*  field: "pkt_count"
//
//  GET uvm_config_db #(bit[31:0])      ← different type!
//      by: uvm_test_top.env.mon  field: "pkt_count"
//      result: MISS
//
// The #(T) parameter printed by SET and GET are different.
// That is the entire diagnosis. Change get() to use 'int'.
 
// ── Fix: use the same type everywhere ────────────────────────────────
int pkt_count;
if (!uvm_config_db#(int)::get(this, "", "pkt_count", pkt_count))
`uvm_fatal("CFG", "pkt_count not found")
`uvm_info("CFG", $sformatf("pkt_count = %0d", pkt_count), UVM_LOW)

// ── tb_top.sv — two APB interfaces, two agents ────────────────────────
apb_if apb_vif_0(clk);   // agent_0's interface
apb_if apb_vif_1(clk);   // agent_1's interface
 
initial begin
// Scope tied to each agent by name — not wildcard
uvm_config_db#(virtual apb_if)::set(
null, "uvm_test_top.env.agent_0.*", "vif", apb_vif_0);
uvm_config_db#(virtual apb_if)::set(
null, "uvm_test_top.env.agent_1.*", "vif", apb_vif_1);
run_test();
end
 
// ── apb_env.sv — creates two agents ──────────────────────────────────
agent_0 = apb_agent::type_id::create("agent_0", this);
agent_1 = apb_agent::type_id::create("agent_1", this);
 
// ── apb_driver.sv — same get() in both drivers ────────────────────────
virtual apb_if vif;
if (!uvm_config_db#(virtual apb_if)::get(this, "", "vif", vif))
`uvm_fatal("CFG", $sformatf("vif not found at %s", get_full_name()))
// driver inside agent_0 gets apb_vif_0, driver inside agent_1 gets apb_vif_1
// Same get() call — resolved differently by scope match. No index needed.

// ── tb_top.sv ──────────────────────────────────────────────────────────
// Intention: agents globally get 100 txns, but agent_0 gets 200 specifically
uvm_config_db#(int)::set(null, "uvm_test_top.*", "num_txns", 100); // broad
uvm_config_db#(int)::set(null, "uvm_test_top.env.agent_0.*", "num_txns", 200); // specific
 
// What does agent_0's driver get?
// Answer: 200  ← The more specific path was called second, so it overwrites.
// But flip the order:
uvm_config_db#(int)::set(null, "uvm_test_top.env.agent_0.*", "num_txns", 200);
uvm_config_db#(int)::set(null, "uvm_test_top.*", "num_txns", 100); // broad last
 
// Now agent_0's driver gets 100 — the broad wildcard overwrites the specific.
// Rule: there is NO pattern-specificity priority in config_db.
// The last matching set() called BEFORE the component's build_phase wins.
 
// ── Correct pattern: base first, overrides after ──────────────────────
function void build_phase(uvm_phase phase);
// 1. Set defaults broad
uvm_config_db#(int)::set(this, "*", "num_txns", 100);
// 2. Override specific agent — called after, so wins for that scope
uvm_config_db#(int)::set(this, "env.agent_0.*", "num_txns", 200);
super.build_phase(phase);
endfunction

// ❌ BUGGY — only some branches call set() ────────────────────────────
class base_test extends uvm_test;
string mode = "normal";
function void build_phase(uvm_phase phase);
if (mode == "error")
uvm_config_db#(bit)::set(this, "*.drv", "inject_err", 1);
// else: no set() — driver's get("inject_err") returns 0
// driver proceeds with uninitialised inject_err value (0 by default in SV)
// tests pass — but the driver is not explicitly controlled
super.build_phase(phase);
endfunction
endclass
 
// ✓ FIXED — always set(), value depends on mode ────────────────────────
class base_test extends uvm_test;
string mode = "normal";
function void build_phase(uvm_phase phase);
// Always set — value is what changes based on mode
uvm_config_db#(bit)::set(this, "*.drv", "inject_err", (mode == "error") ? 1 : 0);
super.build_phase(phase);
endfunction
endclass
 
// ── In the driver — always use uvm_fatal for bit-controlled behaviour ─
bit inject_err = 0;   // safe default
void'(uvm_config_db#(bit)::get(this, "", "inject_err", inject_err));
// Suppress the return check for optional flags — use default if not set

// ── apb_if.sv ─────────────────────────────────────────────────────────
interface apb_if(input logic clk);
logic [31:0] paddr;
logic        pwrite;
logic [31:0] pwdata;
logic [31:0] prdata;
modport master(output paddr, pwrite, pwdata, input prdata);
modport slave(input paddr, pwrite, pwdata, output prdata);
endinterface
 
// ── tb_top.sv (BUGGY) ─────────────────────────────────────────────────
apb_if apb_vif(clk);
virtual apb_if.master master_vif = apb_vif;   // intermediate assignment
uvm_config_db#(virtual apb_if.master)::set(
null, "uvm_test_top.*", "vif", master_vif); // stored as modport type!
 
// ── apb_driver.sv (BUGGY) ─────────────────────────────────────────────
virtual apb_if vif;       // no modport — different type
if (!uvm_config_db#(virtual apb_if)::get(this, "", "vif", vif))
`uvm_fatal("CFG", "vif not found")   // ← fires, because types differ
 
// ── Fix: ALWAYS store as the full interface type (no modport) ─────────
// tb_top.sv — correct
uvm_config_db#(virtual apb_if)::set(
null, "uvm_test_top.*", "vif", apb_vif);  // full interface, no modport
 
// apb_driver.sv — correct (modport access via direction enforcement)
virtual apb_if vif;   // full interface handle
if (!uvm_config_db#(virtual apb_if)::get(this, "", "vif", vif))
`uvm_fatal("CFG", "vif not found")
// Use vif.paddr (works fine — port direction not enforced at runtime)

// config_db_gotcha_demo.sv
// Demonstrates phase-ordering miss and type-mismatch miss.
// Compile: vlog -sv config_db_gotcha_demo.sv
// Run:     vsim -c work.tb_top_demo +UVM_TESTNAME=gotcha_test +UVM_CONFIG_DB_TRACE -do "run -all; quit"
 
`include "uvm_macros.svh"
import uvm_pkg::*;
 
// ── Simple virtual interface ──────────────────────────────────────────
interface demo_if;
logic [7:0] data;
endinterface
 
// ── Leaf component: tries to retrieve both values ────────────────────
class leaf_comp extends uvm_component;
`uvm_component_utils(leaf_comp)
virtual demo_if vif;
int timeout = -1;
 
function new(string name, uvm_component parent);
super.new(name, parent);
endfunction
 
function void build_phase(uvm_phase phase);
super.build_phase(phase);
 
// Get virtual interface
if (!uvm_config_db#(virtual demo_if)::get(this, "", "vif", vif))
`uvm_fatal("CFG", $sformatf("vif not found at %s", get_full_name()))
else
`uvm_info("CFG", "vif: HIT", UVM_LOW)
 
// Get timeout (set() uses int, get() uses bit[31:0] — type mismatch!)
bit [31:0] timeout_raw;
if (!uvm_config_db#(bit [31:0])::get(this, "", "timeout", timeout_raw))
`uvm_warning("CFG", "timeout: MISS (check +UVM_CONFIG_DB_TRACE)")
else
`uvm_info("CFG", $sformatf("timeout = %0d", timeout_raw), UVM_LOW)
endfunction
endclass
 
// ── Test: shows phase-ordering bug then fix ───────────────────────────
class gotcha_test extends uvm_test;
`uvm_component_utils(gotcha_test)
leaf_comp leaf;
 
function new(string name, uvm_component parent);
super.new(name, parent);
endfunction
 
function void build_phase(uvm_phase phase);
// set() BEFORE super.build_phase → vif arrives in time
// set timeout with int — leaf will try bit[31:0] → MISS
uvm_config_db#(int)::set(this, "*", "timeout", 1000);
 
super.build_phase(phase);
leaf = leaf_comp::type_id::create("leaf", this);
endfunction
endclass
 
// ── tb_top_demo ───────────────────────────────────────────────────────
module tb_top_demo;
demo_if dif();
initial begin
// set vif before run_test — always safe
uvm_config_db#(virtual demo_if)::set(null, "uvm_test_top.*", "vif", dif);
run_test();
end
endmodule
 
// Expected output (with +UVM_CONFIG_DB_TRACE):
//   SET uvm_config_db #(int) ... field: "timeout"
//   SET uvm_config_db #(virtual demo_if) ... field: "vif"
//   GET uvm_config_db #(virtual demo_if) ... result: HIT
//   GET uvm_config_db #(bit[31:0]) ... result: MISS   ← type mismatch visible
//   UVM_WARNING CFG: timeout: MISS (check +UVM_CONFIG_DB_TRACE)
//
// Fix: change leaf's get() to use int instead of bit[31:0].