Uvvm Verification

UVM 验证方法论技能

当用户需要开发 UVM 验证平台时，启用此技能。遵循 IEEE 标准 UVM，一步一步完成验证开发，从验证计划到功能覆盖率。

When to Activate

• 开发新的 UVM 验证平台
• 优化现有 UVM 验证平台结构
• 调试 UVM 验证平台问题
• 从 legacy 验证方法迁移到 UVM
• 代码审查 UVM 验证平台

行业经验数值

覆盖率目标

验证时间估算

回归测试周期

Bug 密度参考

故障诊断框架

症状1：覆盖率不收敛

诊断步骤：

1. 分析覆盖率报告
2. 识别未覆盖的代码/功能
3. 检查测试用例
4. 检查约束

判断标准：

根本原因定位：

症状2：仿真挂起

诊断步骤：

1. 检查仿真时间
2. 查看波形
3. 检查 UVM phase
4. 检查 objection

根本原因定位：

症状3：功能错误多

诊断步骤：

1. 分析错误日志
2. 分类错误类型
3. 定位错误模块
4. 分析错误原因

根本原因定位：

症状4：仿真速度慢

诊断步骤：

1. 分析仿真时间分布
2. 检查日志输出
3. 检查覆盖率收集
4. 检查波形转储

根本原因定位：

第一步：制定验证计划

验证开始前必须制定验证计划，明确验证范围和目标。

验证计划内容

功能点枚举示例

对于一个异步 FIFO，功能点包括：

• 空状态读写正确
• 满状态读写正确
• 半满状态读写正确
• 异步复位正确
• 不同时钟频率工作正确
• X 传播正确

覆盖率目标

代码覆盖率：
  - 行覆盖率 >= 90%
  - 条件覆盖率 >= 80%
  - 翻转覆盖率 >= 85%
  - FSM 覆盖率 = 100%

功能覆盖率：
  - 所有功能点 100% 覆盖

第二步：制定验证方案

根据验证计划制定验证方案。

验证平台架构

标准 UVM 验证平台结构：

testbench/
├── tb_top.sv           # 测试平台顶层（例化DUT和接口）
├── interfaces/          # DUT接口定义
│   └── bus_if.sv
├── agents/             # agent (driver + monitor + sequencer)
│   ├── driver.sv
│   ├── monitor.sv
│   ├── sequencer.sv
│   └── agent.sv
├── sequences/          # 激励序列
│   ├── base_seq.sv
│   ├── read_seq.sv
│   ├── write_seq.sv
│   └── stress_seq.sv
├── models/             # 参考模型
│   └── ref_model.sv
├── scoreboards/        # 结果比较
│   └── scoreboard.sv
├── coverage/           # 功能覆盖率收集
│   └── coverage.sv
├── tests/              # 测试用例
│   ├── base_test.sv
│   ├── sanity_test.sv
│   └── stress_test.sv
└── env.sv              # 环境顶层

这个结构分工清晰，方便复用。

验证策略

• 定向测试：验证特定功能点，适合边界情况
• 约束随机测试：随机生成激励，覆盖更多 corner case
• 覆盖率驱动：根据覆盖率添加缺失测试
• 断言补充：接口属性断言，自动检查

第三步：测试点撰写

每个功能点对应一个测试点，明确测试什么，怎么测试。

测试点模板

测试点 ID: TP-001
测试点名称: 异步FIFO满状态测试
测试点描述: 当FIFO满了，写请求应该被忽略，满信号应该正确输出
测试方法: 连续写直到满，检查满信号，检查数据正确
优先级: P1
覆盖分组: 边界条件

测试点优先级

• P1：必须测试，核心功能
• P2：应该测试，非核心功能
• P3：可选测试，覆盖盲区

功能覆盖率覆盖点

每个测试点对应功能覆盖率覆盖点：

covergroup fifo_cg {
  option.per_instance = 1;
  empty: coverpoint fifo_empty {
    bins empty = {1};
    bins not_empty = {0};
  }
  full: coverpoint fifo_full {
    bins full = {1};
    bins not_full = {0};
  }
  half_full: coverpoint fifo_counter {
    bins low[] = {[0:DEPTH/2-1], [DEPTH/2+1:DEPTH-1]};
    bins mid = {DEPTH/2};
  }
}

步骤 4：验证环境搭建

验证环境搭建需要按顺序完成：接口 → 事务 → Driver → Monitor → Agent → Env → Test。

4.1 接口编写

做什么： 定义 DUT 与验证环境的连接接口。

接口编写模板：

interface dut_if #(
    parameter DATA_WIDTH = 32,
    parameter ADDR_WIDTH = 32
)(
    input  wire clk,
    input  wire rst_n
);
    // 时钟和复位
    logic        clk;
    logic        rst_n;

    // 输入信号
    logic [ADDR_WIDTH-1:0] addr;
    logic [DATA_WIDTH-1:0] wdata;
    logic                  wr_en;
    logic                  rd_en;

    // 输出信号
    logic [DATA_WIDTH-1:0] rdata;
    logic                  ready;
    logic                  error;

    // 时钟块（用于同步）
    clocking cb @(posedge clk);
        default input #1ns output #1ns;
        output addr, wdata, wr_en, rd_en;
        input  rdata, ready, error;
    endclocking

    // modport for DUT
    modport dut (
        input  clk, rst_n, addr, wdata, wr_en, rd_en,
        output rdata, ready, error
    );

    // modport for Driver
    modport driver (
        clocking cb,
        output  rst_n
    );

    // modport for Monitor
    modport monitor (
        clocking cb
    );

endinterface

接口编写检查清单：

• 所有 DUT 信号都已定义
• 信号位宽正确
• 添加了 clocking block（同步）
• 定义了 modport（DUT/Driver/Monitor）
• 参数化设计（位宽可配置）

4.2 事务编写

做什么： 定义验证环境中传递的数据结构。

事务编写模板：

class dut_trans extends uvm_sequence_item;
    `uvm_object_utils(dut_trans)

    // 随机化字段
    rand bit [31:0] addr;
    rand bit [31:0] data;
    rand bit        wr_en;
    rand bit        rd_en;

    // 约束
    constraint c_addr_align {
        addr[1:0] == 2'b00;  // 4字节对齐
    }

    constraint c_valid_trans {
        wr_en != rd_en;  // 读写互斥
    }

    // 覆盖点
    covergroup trans_cg;
        cp_addr: coverpoint addr {
            bins low  = {[0:32'h0000FFFF]};
            bins mid  = {[32'h00010000:32'hFFFF0000]};
            bins high = {[32'hFFFF0001:32'hFFFFFFFF]};
        }
        cp_wr: coverpoint wr_en;
        cp_rd: coverpoint rd_en;
    endgroup

    function new(string name = "dut_trans");
        super.new(name);
        trans_cg = new();
    endfunction

    function void post_randomize();
        trans_cg.sample();
    endfunction

    // 复制、比较、打印方法
    virtual function void do_copy(uvm_object rhs);
        dut_trans rhs_;
        super.do_copy(rhs);
        $cast(rhs_, rhs);
        addr  = rhs_.addr;
        data  = rhs_.data;
        wr_en = rhs_.wr_en;
        rd_en = rhs_.rd_en;
    endfunction

    virtual function bit do_compare(uvm_object rhs, uvm_comparer comparer);
        dut_trans rhs_;
        bit same = super.do_compare(rhs, comparer);
        $cast(rhs_, rhs);
        same = (addr == rhs_.addr) &&
               (data == rhs_.data) &&
               (wr_en == rhs_.wr_en) &&
               (rd_en == rhs_.rd_en);
        return same;
    endfunction

    virtual function string convert2string();
        return $sformatf("addr=0x%8h, data=0x%8h, wr=%b, rd=%b",
                         addr, data, wr_en, rd_en);
    endfunction

endclass

事务编写检查清单：

• 所有传输数据字段都已定义
• 关键字段添加了随机约束
• 添加了功能覆盖点
• 实现了 do_copy、do_compare、convert2string
• 使用 `uvm_object_utils 注册

4.3 Driver 编写

做什么： 将事务转换为 DUT 接口信号。

Driver 编写模板：

class dut_driver extends uvm_driver #(dut_trans);
    `uvm_component_utils(dut_driver)

    virtual dut_if vif;

    function new(string name, uvm_component parent);
        super.new(name, parent);
    endfunction

    virtual function void build_phase(uvm_phase phase);
        super.build_phase(phase);
        if (!uvm_config_db#(virtual dut_if)::get(this, "", "vif", vif)) begin
            `uvm_fatal("build_phase", "Failed to get vif")
        end
    endfunction

    virtual task run_phase(uvm_phase phase);
        forever begin
            seq_item_port.get_next_item(req);
            drive_trans(req);
            seq_item_port.item_done();
        end
    endtask

    virtual task drive_trans(dut_trans trans);
        // 等待时钟沿
        @(vif.cb);

        // 驱动信号
        vif.cb.addr  <= trans.addr;
        vif.cb.data  <= trans.data;
        vif.cb.wr_en <= trans.wr_en;
        vif.cb.rd_en <= trans.rd_en;

        // 等待响应
        wait(vif.cb.ready);

        `uvm_info("drive_trans", trans.convert2string(), UVM_HIGH)
    endtask

endclass

Driver 编写检查清单：

• 从 config_db 获取 virtual interface
• 实现 run_phase 的 forever 循环
• 使用 seq_item_port 与 sequencer 通信
• 正确使用 clocking block 同步
• 添加日志信息（UVM_HIGH 级别）

4.4 Monitor 编写

做什么： 观察接口信号，转换为事务。

Monitor 编写模板：

class dut_monitor extends uvm_monitor;
    `uvm_component_utils(dut_monitor)

    virtual dut_if vif;
    uvm_analysis_port #(dut_trans) ap;

    function new(string name, uvm_component parent);
        super.new(name, parent);
        ap = new("ap", this);
    endfunction

    virtual function void build_phase(uvm_phase phase);
        super.build_phase(phase);
        if (!uvm_config_db#(virtual dut_if)::get(this, "", "vif", vif)) begin
            `uvm_fatal("build_phase", "Failed to get vif")
        end
    endfunction

    virtual task run_phase(uvm_phase phase);
        forever begin
            collect_trans();
        end
    endtask

    virtual task collect_trans();
        dut_trans trans;

        // 等待有效信号
        wait(vif.cb.ready);

        // 采样信号
        trans = dut_trans::type_id::create("trans");
        trans.addr  = vif.cb.addr;
        trans.data  = vif.cb.data;
        trans.wr_en = vif.cb.wr_en;
        trans.rd_en = vif.cb.rd_en;

        // 发送到 analysis port
        ap.write(trans);

        `uvm_info("collect_trans", trans.convert2string(), UVM_HIGH)
    endtask

endclass

Monitor 编写检查清单：

• 创建 uvm_analysis_port
• 正确采样接口信号
• 将观察到的事务发送到 analysis port
• 不修改 DUT 信号（只观察）

4.5 Agent 编写

做什么： 封装 Driver、Monitor、Sequencer。

Agent 编写模板：

class dut_agent extends uvm_agent;
    `uvm_component_utils(dut_agent)

    dut_driver    driver;
    dut_sequencer sequencer;
    dut_monitor   monitor;
    virtual dut_if vif;

    // 配置：ACTIVE 或 PASSIVE
    uvm_active_passive_enum is_active = UVM_ACTIVE;

    function new(string name, uvm_component parent);
        super.new(name, parent);
    endfunction

    virtual function void build_phase(uvm_phase phase);
        super.build_phase(phase);

        // 获取配置
        if (!uvm_config_db#(virtual dut_if)::get(this, "", "vif", vif)) begin
            `uvm_fatal("build_phase", "Failed to get vif")
        end

        // 创建 Monitor（总是创建）
        monitor = dut_monitor::type_id::create("monitor", this);
        uvm_config_db#(virtual dut_if)::set(this, "monitor", "vif", vif);

        // 根据 is_active 决定是否创建 Driver 和 Sequencer
        if (is_active == UVM_ACTIVE) begin
            driver    = dut_driver::type_id::create("driver", this);
            sequencer = dut_sequencer::type_id::create("sequencer", this);
            uvm_config_db#(virtual dut_if)::set(this, "driver", "vif", vif);
        end
    endfunction

    virtual function void connect_phase(uvm_phase phase);
        super.connect_phase(phase);
        // 连接 Driver 和 Sequencer
        if (is_active == UVM_ACTIVE) begin
            driver.seq_item_port.connect(sequencer.seq_item_export);
        end
    endfunction

endclass

Agent 编写检查清单：

• 支持 ACTIVE/PASSIVE 模式
• 正确创建和连接组件
• 通过 config_db 传递 interface
• Monitor 总是创建
• Driver/Sequencer 只在 ACTIVE 模式创建

4.6 Environment 编写

做什么： 组装所有组件。

Environment 编写模板：

class dut_env extends uvm_env;
    `uvm_component_utils(dut_env)

    dut_agent     agent;
    dut_scoreboard scoreboard;
    dut_coverage  coverage;

    function new(string name, uvm_component parent);
        super.new(name, parent);
    endfunction

    virtual function void build_phase(uvm_phase phase);
        super.build_phase(phase);

        agent     = dut_agent::type_id::create("agent", this);
        scoreboard = dut_scoreboard::type_id::create("scoreboard", this);
        coverage  = dut_coverage::type_id::create("coverage", this);
    endfunction

    virtual function void connect_phase(uvm_phase phase);
        super.connect_phase(phase);

        // Monitor → Scoreboard
        agent.monitor.ap.connect(scoreboard.analysis_export);

        // Monitor → Coverage
        agent.monitor.ap.connect(coverage.analysis_export);
    endfunction

endclass

Environment 编写检查清单：

• 创建所有需要的组件
• 正确连接 TLM 端口
• 通过 config_db 传递配置

4.7 Test 编写

做什么： 定义测试场景，配置验证环境。

Test 编写模板：

class dut_base_test extends uvm_test;
    `uvm_component_utils(dut_base_test)

    dut_env env;

    function new(string name, uvm_component parent);
        super.new(name, parent);
    endfunction

    virtual function void build_phase(uvm_phase phase);
        super.build_phase(phase);
        env = dut_env::type_id::create("env", this);

        // 配置
        uvm_config_db#(uvm_active_passive_enum)::set(
            this, "env.agent", "is_active", UVM_ACTIVE
        );
    endfunction

    virtual function void end_of_elaboration_phase(uvm_phase phase);
        super.end_of_elaboration_phase(phase);
        // 打印拓扑
        uvm_top.print_topology();
    endfunction

    virtual task run_phase(uvm_phase phase);
        dut_default_seq seq;

        phase.raise_objection(this, "Starting test");

        seq = dut_default_seq::type_id::create("seq");
        seq.start(env.agent.sequencer);

        phase.drop_objection(this, "Test finished");
    endtask

endclass

Test 编写检查清单：

• 创建 environment
• 配置所有组件
• 在 run_phase 中启动 sequence
• 正确使用 objection
• 打印拓扑验证连接

第五步：功能覆盖率收集

功能覆盖率定义

在 coverage 组件收集：

class fifo_coverage extends uvm_component;
  `uvm_component_utils(fifio_coverage)

  uvm_analysis_export #(fifo_trans) analysis_export;
  covergroup fifo_function_cg;
    // 所有功能点覆盖
  endgroup

  function new(string name, uvm_component parent);
    super.new(name, parent);
    analysis_export = new("analysis_export", this);
    fifo_function_cg = new();
  endfunction

  function void write(fifo_trans t);
    fifo_function_cg.sample();
  endfunction

endclass

覆盖率收敛

• 每次仿真收集覆盖率
• 合并所有测试的覆盖率
• 找出未覆盖的功能点
• 添加对应测试覆盖
• 达到 100% 功能覆盖率才算收敛

UVM 编码准则

工厂注册

所有组件和事务都必须工厂注册：

// 组件注册
`uvm_component_utils(my_agent)

// 事务注册
`uvm_object_utils(my_transaction)
`uvm_object_utils_begin(my_transaction)
  `uvm_field_int(addr, UVM_ALL_ON)
  `uvm_field_int(data, UVM_ALL_ON)
`uvm_object_utils_end

phase 机制

遵循 UVM phase 顺序：

✅ 永远：每个 phase 必须调用 super.phase()

virtual function void build_phase(uvm_phase phase);
  super.build_phase(phase);  // 必须调用父类
  // 你的代码...
endfunction

配置数据库

使用 uvm_config_db 传递配置，不要全局变量：

// 发送配置：在 test
uvm_config_db#(virtual fifo_if)::set(this, "*env.agent*", "fifo_vif", fifo_if);

// 获取配置：在 agent
if (!uvm_config_db#(virtual fifo_if)::get(this, "", "fifo_vif", vif)) begin
  `uvm_fatal(get_full_name(), "Failed to get fifo_vif from config db");
end

检查清单

验证平台完成检查：

• 所有功能点都对应测试点
• 验证平台结构符合标准
• 所有组件正确工厂注册
• 每个 phase 调用 super.phase()
• 正确使用 objection 控制仿真结束
• 配置通过 uvm_config_db 传递
• 没有全局变量
• sequence 只产生激励，不做结果检查
• 所有功能覆盖点都已定义
• 覆盖率目标明确

步骤 6：验证环境调试

验证环境搭建完成后，需要进行调试确保正确性。

6.1 编译调试

常见编译错误：

6.2 连接调试

检查连接正确性：

// 在 end_of_elaboration_phase 打印拓扑
virtual function void end_of_elaboration_phase(uvm_phase phase);
    super.end_of_elaboration_phase(phase);
    uvm_top.print_topology();
endfunction

检查项：

• 所有组件都创建成功
• 所有 TLM 端口都连接
• config_db 传递正确
• virtual interface 获取成功

6.3 功能调试

调试方法：

1. 使用 UVM 日志

// 设置日志级别
set_report_verbosity_level_hier(UVM_HIGH);

// 设置特定组件日志
env.agent.driver.set_report_verbosity_level(UVM_DEBUG);

2. 使用波形调试

# VCS
fsdbDumpfile("wave.fsdb");
fsdbDumpvars(0, tb_top);

# Xcelium
probe -create tb_top -depth all

3. 检查 Objection

// 检查 objection 状态
virtual function void phase_ready_to_end(uvm_phase phase);
    if (phase.get_name() == "run") begin
        `uvm_info("objection", "Run phase ending", UVM_LOW)
    end
endfunction

6.4 常见问题诊断

步骤 7：回归测试

7.1 回归测试策略

7.2 测试用例管理

测试用例分类：

// 使用 UVM test 进行分类
class smoke_test extends dut_base_test;
    // 快速冒烟测试
endclass

class feature_test extends dut_base_test;
    // 功能测试
endclass

class regression_test extends dut_base_test;
    // 回归测试
endclass

class stress_test extends dut_base_test;
    // 压力测试
endclass

运行命令：

# VCS
vcs -sverilog -ntb_opts uvm \
    +UVM_TESTNAME=smoke_test \
    +UVM_VERBOSITY=UVM_HIGH \
    -l run.log

# Xcelium
xrun -sv -uvm \
    +UVM_TESTNAME=feature_test \
    +UVM_VERBOSITY=UVM_MEDIUM \
    -log run.log

7.3 覆盖率合并

合并多个测试的覆盖率：

# VCS
urg -dir simv.vdb -dir test1.vdb -dir test2.vdb \
    -report coverage_report

# Xcelium
imc -exec coverage_merge.tcl

覆盖率合并脚本示例：

# coverage_merge.tcl
open_database test1.ucd
merge_database test2.ucd test3.ucd test4.ucd
report_coverage -totals -by_instance
exit

步骤 8：验证收敛判断

8.1 收敛标准

验证完成条件（全部满足才算收敛）：

8.2 覆盖率分析

覆盖率缺口分析：

1. 运行所有测试用例
2. 合并覆盖率报告
3. 识别未覆盖代码/功能
4. 分析原因
5. 添加测试用例覆盖缺口

覆盖率缺口原因分析：

8.3 Bug 趋势追踪

Bug 趋势指标：

Bug 趋势图：

Bug 数量
    ^
    |     新发现 Bug
    |        *
    |      *   *
    |    *       *
    |  *           *    ← 期望趋势
    |*               *
    +-------------------> 时间

8.4 验证签收清单

签收前检查：

• 所有测试用例通过
• 覆盖率达标
• 功能覆盖率 100%
• 所有断言通过
• 无 open Bug
• 回归测试稳定
• 验证报告完成
• 代码审查通过
• 文档更新完成

常见错误

工具支持

• Synopsys VCS → 完全支持
• Cadence Xcelium → 完全支持
• Siemens Questa → 完全支持
• 开源：Verilator → 支持基本 UVM

反模式（要避免）

❌ 上帝 sequence：一个 sequence 做完所有事情包括结果检查 → 拆分 sequence 和 scoreboard ❌ 硬编码配置 → 不能配置不同位宽 → 参数化配置 ❌ 嵌套太深 → 超过 5 层嵌套，调试困难 → 合理分层 ❌ 不收集覆盖率 → 认为测试通过就是完成 → 必须达到覆盖率目标 ❌ 日志太多 → 日志文件几 G，打不开 → 合理控制日志级别

代理协作

• 使用 verification-engineer 代理进行验证开发
• 使用 code-reviewer 代理进行代码审查
• 断言验证配合使用 assertion-based-verification 技能