SV 虚类工厂模式:纯 SystemVerilog 手写注册表加 create 的可替换对象构造
更新时间:2026-09-28。前面 SystemVerilog OOP:类继承与多态 讲了虚方法带来的运行时多态——句柄声明为基类、行为落在派生类。但多态只解决「调用哪个方法」,没解决「构造哪个类型」:
new后面跟的类名是编译期写死的。这一篇用纯 SystemVerilog(不碰 UVM 库)手写一个工厂:virtual class 抽象基类 + 一张类型注册表 + 统一create入口,把「造什么类型的对象」推迟到运行期决定。这正是 UVM factory 的前身,看懂它再看 UVM factory 与 env 派生 会顺很多。
本文要回答的问题
- 为什么
new写死类型会让 testbench 失去可替换性?多态为什么救不了构造这一步? - 虚类(virtual class)在工厂里扮演什么角色?它和抽象方法、纯虚约束的关系是什么?
- 手写工厂的最小骨架长什么样:注册表用什么数据结构、create 怎么查表、override 怎么实现?
- 这套手写工厂与 UVM factory 相比缺了什么,什么时候手写版反而更合适?
一、问题的起点:多态能换行为,换不了类型
假设一个总线验证环境,transaction 基类和两个派生类:
class bus_txn;
rand bit [31:0] addr;
rand bit [31:0] data;
virtual function void display();
$display("BASE txn addr=%h", addr);
endfunction
endclass
class rd_txn extends bus_txn;
virtual function void display();
$display("RD txn addr=%h", addr);
endfunction
endclass
class err_txn extends bus_txn; // 错误注入事务
rand bit inject_parity_err;
virtual function void display();
$display("ERR txn addr=%h err=%0b", addr, inject_parity_err);
endfunction
endclassdriver 里想按 testcase 造不同事务。多态允许你把 rd_txn 句柄塞进 bus_txn 变量、调 display() 落到派生类版本——但「造」的那一行仍然是:
task gen_stimulus();
bus_txn t;
t = new(); // 编译期钉死:永远是 bus_txn
// 想要 err_txn?只能改这里重新编译,或写一堆 if-else
endtasknew 是 SystemVerilog 里少数没有多态性的操作之一:它后面必须是具体类名,不能是句柄、不能是字符串、不能是参数传进来的类型。想换类型,常见歪路有两条:
| 歪路 | 做法 | 代价 |
|---|---|---|
| 宏切换 | `ifdef ERR_TEST 包两种 new | 每个组合一份编译产物,回归要编 N 次 |
| if-else 分支 | if (kind == ERR) t = new_err... | 每加一个派生类改一遍所有构造点,漏一处就出哑 bug |
两条路都把「选哪个类型」这个运行期决策硬塞回了编译期。工厂模式要干的事,就是把类型选择变成一个可以在运行期查表、替换、覆盖的动作。思路一句话:既然 new 不能多态,那就给每个类型配一个「会 new 它的小对象」,构造时查表找到这个小对象,让它去 new——多态作用在「小对象」上,间接实现了类型的多态构造。
二、虚类:工厂的契约层
虚类(virtual class)是不能被 new 的类,只能被继承;里面的 pure virtual 方法强制派生类实现。它在工厂里承担契约角色:定义「所有可构造产品长什么样」和「所有能造产品的工具长什么样」两个接口,自己不产生任何实例。

读图抓结构:左边是产品继承树(bus_txn 一族),右边是包装器继承树(txn_wrapper 一族),两棵树平行生长、通过 create_object() 一一挂钩。基类都声明为 virtual——它们只是契约,任何人 new bus_txn() 基类或 new txn_wrapper() 都该被编译器拦下,这正是虚类比裸 class 强的地方:把「抽象不可实例化」从口头约定变成编译错误。
为什么需要包装器这一层,而不是直接用「类句柄」(class handle)?因为 SystemVerilog 没有第一类(first-class)的类型对象——你不能把 rd_txn 这个类型本身塞进变量传参。包装器实例就是类型的「替身」:它轻量(通常无字段)、可多态、能注册进表。UVM 里的 uvm_object_wrapper 和 type_id 正是这个角色的工业化版本,名字都没换。
三、手写工厂的最小骨架:注册表 + create
骨架三块:一张关联数组当注册表、一个注册函数、一个统一 create 入口。全部用纯 SV 写,不依赖任何库:
// ---- 契约层 ----
virtual class txn_wrapper;
pure virtual function bus_txn create_object(string name = "");
pure virtual function string get_type_name();
endclass
// ---- 注册表(单例) ----
class txn_factory;
static txn_wrapper table[string]; // 类型名 -> 包装器
static function void register(string key, txn_wrapper w);
if (table.exists(key))
$display("[FACTORY] override: %s 被替换", key);
table[key] = w;
endfunction
static function bus_txn create(string key, string name = "");
if (!table.exists(key)) begin
$fatal(1, "[FACTORY] 未注册的类型: %s", key);
end
return table[key].create_object(name);
endfunction
endclass
// ---- 每个产品类配一个包装器 ----
class rd_wrapper extends txn_wrapper;
virtual function bus_txn create_object(string name = "");
rd_txn t = new();
return t;
endfunction
virtual function string get_type_name(); return "rd_txn"; endfunction
endclass使用时先注册、后构造:
module tb;
initial begin
rd_txn::register_me(); // 或显式:txn_factory::register("rd", new rd_wrapper);
// testcase 顶层按需求覆盖注册:
// txn_factory::register("rd", new err_wrapper); // 把 rd 换成 err!
bus_txn t = txn_factory::create("rd", "t0");
t.randomize();
t.display();
end
endmodule注册表的结构一图看清:

图上那条「同 key 重新 register 后注册者胜出」就是 override 的全部秘密——没有魔法,就是关联数组的覆盖写。testcase 想注入错误事务,不需要改 driver 一行代码,只要在构造发生之前把 table["rd"] 换成 err_wrapper。之后 driver 里所有 create("rd") 都会拿到 err_txn,而 driver 对此毫无感知。
这就是 UVM clone 与 create 区别 里强调的「override 只作用于 create 路径」的裸机版本:clone 不查表所以不可替换,create 查表所以可替换,原理在这张关联数组里一览无余。
四、让注册自动化:每类一行样板
手写 register 调用散落在各 initial 块里容易漏,工程上让每个产品类自己带一个静态注册入口,环境初始化时统一触发:
class rd_txn extends bus_txn;
virtual function void display();
$display("RD txn addr=%h", addr);
endfunction
// 样板三行:本类的包装器类型 + 注册函数
typedef rd_wrapper this_wrapper_t;
static function void register_me();
txn_factory::register("rd", new this_wrapper_t);
endfunction
endclassbase test 里集中登记全类型表,派生 test 只写「替换谁」:
class base_test;
virtual function void register_all();
rd_txn::register_me();
wr_txn::register_me();
endfunction
endclass
class err_inject_test extends base_test;
virtual function void register_all();
super.register_all(); // 默认表
txn_factory::register("rd", new err_wrapper); // 本条用例的 override
endfunction
endclass这个「基类登记默认、派生类追加覆盖」的结构,就是 UVM 里 uvm_component_utils 宏注册 + set_type_override_by_type 的手写版。UVM 把包装器类、register_me 样板、table[string] 全部收进宏和 uvm_factory 单例里,你看到的只剩一行 `uvm_object_utils,底层动作一模一样。对照表:
| 机制 | 手写版 | UVM 对应物 |
|---|---|---|
| 产品契约 | virtual class bus_txn | uvm_object / uvm_component |
| 包装器 | txn_wrapper 派生类 | uvm_object_wrapper(宏生成) |
| 注册表 | static txn_wrapper table[string] | uvm_factory 内部 m_type_names |
| 注册动作 | register_me() 静态函数 | `uvm_object_utils 宏展开 |
| 类型覆盖 | 同 key 重复 register | set_type_override_by_type |
| 实例覆盖 | 无(需自行加路径 key) | set_inst_override_by_type |
| 统一构造 | txn_factory::create(key) | type_id::create(name, parent) |
| 未注册保护 | $fatal | uvm_fatal + 打印注册表 |
五、手写版缺什么:从能用到好用之间的距离
手写工厂能跑,但和 UVM factory 比还缺几块,知道缺口才知道 UVM 那些「繁琐设计」在补什么:
实例级 override。 手写版 key 是全局类型名,「只把 env 里 agent1 的 driver 换掉、agent0 不动」做不到。UVM 的解法是 create 时传入父组件路径,注册表再叠一层按实例通配符匹配(细节见 UVM config_db 通配符与作用域 的同源查找逻辑)。手写要支持,得把 key 从 "rd" 扩展成 "env.agent1.*:rd" 并做模式匹配,复杂度立马上来。
调试可见性。 UVM 的 print_override_info / factory.print() 能列出注册表全貌和命中过程。手写版至少要补一个 dump 函数:
static function void dump();
$display("---- factory registry ----");
foreach (table[k])
$display(" %-12s -> %s", k, table[k].get_type_name());
endfunction回归挂在对不上的类型上时,先 dump 一眼比单步快得多。这和 SystemVerilog 报告严重级别 里的思路一致:可观测性基础设施越早建,后面省的时间越多。
类型安全检查。 手写版 create_object 返回基类句柄,如果 err_wrapper 错写成返回非 bus_txn 子类,编译能过、运行期 $cast 才炸。UVM 用参数化 type_id 把类型绑进包装器,错位在编译期就暴露。参数化类的玩法参见 参数化类验证环境。
创建回调。 UVM create 之后会走 create_ 钩子链和 component 的 parent 挂载,手写版组件树要自己维护。层级化 env 的结构设计见 testbench 分层架构与复用。
那什么时候手写版反而合适?三种场景:一是教学和理解——几十行代码把工厂机制讲透,比对着 UVM 源码啃宏高效;二是非 UVM 的轻量环境(模块级 testbench、形式验证的抽象模型),引整个 UVM 库不值当;三是 UVM 环境之外的辅助对象池,比如 SV callback 钩子 的回调对象族,用手写工厂管理比塞进 uvm_factory 更干净。
六、完整可跑的小例子
把前面碎片拼成一个能直接扔给仿真器的最小环境:
module factory_demo;
// (契约层、factory、产品类定义如上,此处略)
task run(string kind);
bus_txn t;
t = txn_factory::create(kind, "t");
if (t == null) $fatal(1, "create failed");
void'(t.randomize());
t.display();
endtask
initial begin
// 默认注册
txn_factory::register("rd", new rd_wrapper);
txn_factory::register("err", new err_wrapper);
txn_factory::dump();
run("rd"); // RD txn addr=...
// 运行期 override:rd 位被 err 顶替
txn_factory::register("rd", new err_wrapper);
run("rd"); // ERR txn addr=... err=...
run("wr"); // [FACTORY] 未注册的类型: wr -> $fatal
end
endmodule输出依次是:第一次 run("rd") 拿到真 rd_txn;override 后同一个 run("rd") 调用点、同一行 create("rd"),出来的却是 err_txn——调用点零改动,行为被顶层替换,这就是工厂模式交付的核心价值。最后 run("wr") 演示未注册保护直接 fatal,避免返回 null 句柄流到下游才报一个莫名其妙的空指针。
整个机制收拢成一张数据流图:

五步闭环:顶层改表、构造方查表、包装器代办 new、多态句柄回流。所有可替换性都压缩在第①步,其余四步对任何 testcase 恒定不变——「变」与「不变」被干净地切开,这就是设计模式存在的意义。
这一篇在知识体系里的位置
本篇是「纯 SV 机制」到「UVM 工业化机制」之间的桥。向前,多态与继承的地基在 SystemVerilog OOP:类继承与多态,封装边界在 SV local/protected 封装;向后,UVM 把同一套思路扩展成带实例覆盖、回调和层级挂载的完整体系,见 UVM factory 与 env 派生 和 UVM clone 与 create 区别。工厂造出的对象要在分层环境里流动,配套读 testbench 分层架构与复用。
总结
SV 虚类工厂模式的本质是用 virtual class 定契约、给每个产品类配一个「会 new 它的包装器」、用一张字符串到包装器的注册表把类型选择推迟到运行期——create 查表、override 就是同 key 覆盖写,几十行纯 SV 即可实现,而它正是 UVM factory 脱下宏外衣之后的本来面目。