Resource Database

// ── set(): create or update a named resource ──────────────────────────
// uvm_resource_db #(T)::set(scope, name, val, accessor)
//   scope    : string — wildcard-matchable pattern for lookup context
//   name     : string — lookup key
//   val      : T     — the value to store
//   accessor : uvm_object (optional) — who is writing, for audit trail
 
uvm_resource_db#(int)::set("uvm_test_top.*", "timeout_cycles", 5000, this);
uvm_resource_db#(bit)::set("*", "inject_errors", 1, null);
 
// ── read_by_name(): get value matching scope+name ─────────────────────
// Returns 1 on success, 0 if not found
int timeout;
if (!uvm_resource_db#(int)::read_by_name("uvm_test_top", "timeout_cycles",
timeout, this))
`uvm_warn("RES", "timeout_cycles not found, using default")
 
// ── write_by_name(): update existing resource value ───────────────────
// Returns 1 on success (resource must already exist)
if (!uvm_resource_db#(int)::write_by_name("uvm_test_top.*", "timeout_cycles",
10000, this))
`uvm_error("RES", "timeout_cycles resource not found to update")
 
// ── read_by_type(): get resource by type alone (no name) ──────────────
bit flag;
uvm_resource_db#(bit)::read_by_type("uvm_test_top", flag, this);
 
// ── get_by_name(): returns the resource object itself ─────────────────
uvm_resource#(int) res;
res = uvm_resource_db#(int)::get_by_name("*", "timeout_cycles", 1);
if (res != null) begin
`uvm_info("RES", $sformatf("Found: %s = %0d  precedence=%0d",
res.get_name(), res.read(), res.precedence), UVM_LOW)
end
 
// ── Directly manipulating uvm_resource objects ────────────────────────
uvm_resource#(int) my_res = new("timeout_cycles", "uvm_test_top.*");
my_res.write(5000, this);           // set value
my_res.set_precedence(3000);         // set custom precedence
uvm_resource_pool::get().set(my_res); // register with the pool
 
int val = my_res.read(this);          // read value
 
// ── dump(): print entire resource database ────────────────────────────
uvm_resource_pool::get().dump();     // shows ALL resources including config_db entries

// ── Test sets the flag once — anyone can read it ──────────────────────
class error_inject_test extends base_test;
`uvm_component_utils(error_inject_test)
 
function void start_of_simulation_phase(uvm_phase phase);
super.start_of_simulation_phase(phase);
// Global scope "*" — readable from anywhere without scope dependency
uvm_resource_db#(bit)::set("*", "inject_errors", 1'b1, this);
uvm_resource_db#(int)::set("*", "error_rate_pct", 10, this);
`uvm_info("TEST","Error injection enabled: rate=10%",UVM_LOW)
endfunction
endclass
 
// ── Driver reads it — no component context needed ─────────────────────
class apb_driver extends uvm_driver#(apb_txn);
`uvm_component_utils(apb_driver)
bit     inject_errors = 0;
int     error_rate    = 0;
 
function void start_of_simulation_phase(uvm_phase phase);
super.start_of_simulation_phase(phase);
// Scope can be anything that matches "*" — use get_full_name() for specificity
void'(uvm_resource_db#(bit)::read_by_name(
get_full_name(), "inject_errors", inject_errors, this));
void'(uvm_resource_db#(int)::read_by_name(
get_full_name(), "error_rate_pct", error_rate, this));
`uvm_info("DRV",$sformatf("inject=%0b rate=%0d%%",inject_errors,error_rate),UVM_LOW)
endfunction
endclass
 
// ── Sequence reads it — no component, no context argument needed ───────
class apb_sequence extends uvm_sequence#(apb_txn);
`uvm_object_utils(apb_sequence)
function new(string n="apb_sequence"); super.new(n); endfunction
 
task body();
bit  inject;
int  rate;
// Sequences are not components — resource_db works, config_db doesn't (needs 'this')
void'(uvm_resource_db#(bit)::read_by_name("*", "inject_errors", inject, null));
void'(uvm_resource_db#(int)::read_by_name("*", "error_rate_pct", rate, null));
`uvm_info("SEQ",$sformatf("Running with inject=%0b rate=%0d",inject,rate),UVM_LOW)
endtask
endclass

// ── Layer 1: Library package sets a rock-bottom default ───────────────
// In apb_agent_pkg.sv — the default that should never prevent overrides
initial begin
uvm_resource#(int) r = new("max_retries", "*");
r.write(3, null);
r.set_precedence(uvm_resource_base::LOW_PRECEDENCE);  // 0 — lowest possible
uvm_resource_pool::get().set(r);
end
 
// ── Layer 2: Environment sets a protocol-appropriate default ──────────
// In my_env.build_phase()
uvm_resource_db#(int)::set("*", "max_retries", 5, this);
// DEFAULT_PRECEDENCE (1000) — wins over library default
 
// ── Layer 3: Stress test needs more retries ───────────────────────────
// In stress_test.start_of_simulation_phase()
begin
uvm_resource#(int) r = new("max_retries", "*");
r.write(20, this);
r.set_precedence(uvm_resource_base::HIGH_PRECEDENCE);  // 2000 — wins over both
uvm_resource_pool::get().set(r);
end
 
// ── Reader gets the right value regardless of lookup scope ────────────
int retries;
uvm_resource_db#(int)::read_by_name("*", "max_retries", retries, this);
// → In stress_test: retries = 20  (HIGH_PRECEDENCE wins)
// → In normal_test: retries = 5   (DEFAULT wins — stress layer not added)
// → In VIP alone:   retries = 3   (LOW_PRECEDENCE — no overrides registered)

// ── Initialize shared counter ─────────────────────────────────────────
// In test.start_of_simulation_phase()
uvm_resource_db#(int)::set("*", "total_errors", 0, this);
 
// ── Monitor 0 increments on protocol error ────────────────────────────
function void report_protocol_error();
int current;
void'(uvm_resource_db#(int)::read_by_name("*", "total_errors", current, this));
uvm_resource_db#(int)::write_by_name("*", "total_errors", current + 1, this);
endfunction
 
// ── Scoreboard reads the global count in check_phase ──────────────────
function void check_phase(uvm_phase phase);
int total;
void'(uvm_resource_db#(int)::read_by_name("*", "total_errors", total, this));
if (total > 0)
`uvm_error("SCB", $sformatf("Test ended with %0d protocol errors", total))
else
`uvm_info("SCB", "No protocol errors recorded ✓", UVM_LOW)
endfunction
 
// NOTE: write_by_name() updates an existing resource value in-place
// The resource must already exist (from a prior set() call)
// If it doesn't exist, write_by_name returns 0 — check the return value

// ── Trigger a full dump of the resource pool ──────────────────────────
function void start_of_simulation_phase(uvm_phase phase);
super.start_of_simulation_phase(phase);
uvm_resource_pool::get().dump();
endfunction
 
// ── What dump() shows (abridged example): ─────────────────────────────
//
// =================================================================
// resources
// =================================================================
// uvm_resource #(int)
//   name:     timeout_cycles
//   scope:    *
//   value:    5000
//   precedence: 1000
//   written by: uvm_test_top.env
//   read by: uvm_test_top.env.apb_agent.drv
//            uvm_test_top.env.apb_agent.mon
//
// uvm_resource #(bit)
//   name:     inject_errors
//   scope:    *
//   value:    1
//   precedence: 1000
//   written by: uvm_test_top
//   read by: (none yet)
//
// uvm_resource #(virtual apb_if)   <-- this is from config_db!
//   name:     __M_uvm_config_db_internal__apb_vif
//   scope:    uvm_test_top.*
//   ...
//
// Note the config_db entries — they appear with internal name prefixes
 
// ── Checking resource accessor history ───────────────────────────────
uvm_resource#(int) r = uvm_resource_db#(int)::get_by_name("*", "timeout_cycles", 1);
if (r != null) begin
// r.m_access_history shows list of {accessor, read/write, timestamp}
// Useful for: "who read this value and when?"
`uvm_info("AUDIT", r.convert2string(), UVM_LOW)
end

// ── Bug 1: Scope mismatch ─────────────────────────────────────────────
// ❌ WRONG — set scope and read scope do not overlap
uvm_resource_db#(int)::set("apb_agent_pkg", "timeout", 5000, null);
// set scope: "apb_agent_pkg"
 
int t;
uvm_resource_db#(int)::read_by_name("uvm_test_top.env.drv", "timeout", t, this);
// query scope: "uvm_test_top.env.drv"
// Match test: does "apb_agent_pkg" match scope "uvm_test_top.env.drv"?
// → NO. Returns 0. t is unchanged.
 
// ✓ CORRECT — use "*" for global resources
uvm_resource_db#(int)::set("*", "timeout", 5000, null);
// set scope: "*" — matches ANY query scope string
uvm_resource_db#(int)::read_by_name(get_full_name(), "timeout", t, this);
// query scope: "uvm_test_top.env.drv"
// Match test: does "*" match "uvm_test_top.env.drv"?
// → YES. Returns 1. t = 5000. ✓
 
// ── Bug 2: write_by_name on non-existent resource ────────────────────
// ❌ WRONG — write_by_name requires resource to already exist
int ok = uvm_resource_db#(int)::write_by_name("*", "not_yet_set", 99, this);
// ok = 0 — resource doesn't exist, nothing written
// t stays at its previous value — silently wrong
 
// ✓ CORRECT — set() first, then write_by_name() can update
uvm_resource_db#(int)::set("*", "counter", 0, null);   // creates it
uvm_resource_db#(int)::write_by_name("*", "counter", 1, this);  // updates it
 
// ── Bug 3: Type mismatch — same name, wrong T parameter ───────────────
uvm_resource_db#(int)::set("*", "flag", 1, null);
bit b;
uvm_resource_db#(bit)::read_by_name("*", "flag", b, this);   // ❌ different type!
// int ≠ bit → resource not found → b stays 0 → silent failure
 
// ✓ CORRECT — type must match exactly
int i;
uvm_resource_db#(int)::read_by_name("*", "flag", i, this);   // int matches int ✓

// resource_db_demo.sv — demonstrates uvm_resource_db fundamentals
// Questa : vlog -sv resource_db_demo.sv && vsim -c resource_db_top -do "run -all; quit"
// VCS    : vcs -sverilog -ntb_opts uvm resource_db_demo.sv && ./simv
// Xcelium: xrun -sv -uvm resource_db_demo.sv -input "run; exit"
 
`include "uvm_macros.svh"
import uvm_pkg::*;
 
class resource_test extends uvm_test;
`uvm_component_utils(resource_test)
function new(string n, uvm_component p); super.new(n,p); endfunction
 
task run_phase(uvm_phase phase);
int     ival;
string  sval;
bit     bval;
int     ok;
phase.raise_objection(this);
 
`uvm_info("TEST","═══ DEMO 1: Basic set and read ═══",UVM_NONE)
uvm_resource_db#(int)::set("*","timeout",5000,this);
void'(uvm_resource_db#(int)::read_by_name("*","timeout",ival,this));
`uvm_info("TEST",$sformatf("timeout = %0d (expect 5000)",ival),UVM_NONE)
 
`uvm_info("TEST","═══ DEMO 2: write_by_name updates existing resource ═══",UVM_NONE)
void'(uvm_resource_db#(int)::write_by_name("*","timeout",10000,this));
void'(uvm_resource_db#(int)::read_by_name("*","timeout",ival,this));
`uvm_info("TEST",$sformatf("timeout after write = %0d (expect 10000)",ival),UVM_NONE)
 
`uvm_info("TEST","═══ DEMO 3: Precedence — high prec wins over default ═══",UVM_NONE)
uvm_resource_db#(int)::set("*","retries",3,null);  // DEFAULT_PRECEDENCE=1000
begin
uvm_resource#(int) r = new("retries","*");
r.write(20,this);
r.set_precedence(2000);  // HIGH — wins
uvm_resource_pool::get().set(r);
end
void'(uvm_resource_db#(int)::read_by_name("*","retries",ival,this));
`uvm_info("TEST",$sformatf("retries = %0d (expect 20 — high prec wins)",ival),UVM_NONE)
 
`uvm_info("TEST","═══ DEMO 4: Type mismatch → not found ═══",UVM_NONE)
uvm_resource_db#(int)::set("*","myval",42,null);
bval = 0;
ok = uvm_resource_db#(bit)::read_by_name("*","myval",bval,this);
`uvm_info("TEST",$sformatf("bit read: ok=%0d bval=%0b (type mismatch→ok=0)",ok,bval),UVM_NONE)
 
`uvm_info("TEST","═══ DEMO 5: write_by_name on non-existent ═══",UVM_NONE)
ok = uvm_resource_db#(int)::write_by_name("*","ghost",999,this);
`uvm_info("TEST",$sformatf("write_by_name on non-existent: ok=%0d (expect 0)",ok),UVM_NONE)
 
`uvm_info("TEST","═══ DEMO 6: dump() — see everything ═══",UVM_NONE)
uvm_resource_pool::get().dump();
 
phase.drop_objection(this);
endtask
endclass
 
module resource_db_top;
initial run_test("resource_test");
endmodule
 
// EXPECTED OUTPUT:
// TEST: ═══ DEMO 1: Basic set and read ═══
// TEST: timeout = 5000 (expect 5000)
// TEST: ═══ DEMO 2: write_by_name updates existing resource ═══
// TEST: timeout after write = 10000 (expect 10000)
// TEST: ═══ DEMO 3: Precedence — high prec wins over default ═══
// TEST: retries = 20 (expect 20 — high prec wins)
// TEST: ═══ DEMO 4: Type mismatch → not found ═══
// TEST: bit read: ok=0 bval=0 (type mismatch→ok=0)
// TEST: ═══ DEMO 5: write_by_name on non-existent ═══
// TEST: write_by_name on non-existent: ok=0 (expect 0)
// TEST: ═══ DEMO 6: dump() — see everything ═══
// [dump output showing all resources including timeout, retries, myval]