MCDF的testcase

```c
class mcdf_data_consistence_basic_virtual_sequence extends mcdf_base_virtual_sequence;
  // UVM 对象实用程序宏
  `uvm_object_utils(mcdf_data_consistence_basic_virtual_sequence)

  // 构造函数
  function new (string name = "mcdf_data_consistence_basic_virtual_sequence");
    super.new(name);
  endfunction

  // 寄存器操作任务
  task do_reg();
    bit[31:0] wr_val, rd_val; // 写入值和读取值
    uvm_status_e status; // 操作状态
    // 配置通道 0：长度 8，优先级 0，使能 1
    wr_val = (1<<3)+(0<<1)+1; 
    rgm.chnl0_ctrl_reg.write(status, wr_val); // 写入寄存器
    rgm.chnl0_ctrl_reg.read(status, rd_val); // 读取寄存器
    void'(this.diff_value(wr_val, rd_val, "SLV0_WR_REG")); // 比较写入值和读取值，并将结果存储在diff_value中

    // 配置通道 1：长度 16，优先级 1，使能 1
    wr_val = (2<<3)+(1<<1)+1;
    rgm.chnl1_ctrl_reg.write(status, wr_val);
    rgm.chnl1_ctrl_reg.read(status, rd_val);
    void'(this.diff_value(wr_val, rd_val, "SLV1_WR_REG"));

    // 配置通道 2：长度 32，优先级 2，使能 1
    wr_val = (3<<3)+(2<<1)+1;
    rgm.chnl2_ctrl_reg.write(status, wr_val);
    rgm.chnl2_ctrl_reg.read(status, rd_val);
    void'(this.diff_value(wr_val, rd_val, "SLV2_WR_REG"));

    // 发送 IDLE 命令
    `uvm_do_on(idle_reg_seq, p_sequencer.reg_sqr) 
  endtask

  // 格式化器配置任务
  task do_formatter();
    // 使用 fmt_config_seq 序列，配置 FIFO 为 LONG_FIFO，带宽为 HIGH_WIDTH
    `uvm_do_on_with(fmt_config_seq, p_sequencer.fmt_sqr, {fifo == LONG_FIFO; bandwidth == HIGH_WIDTH;}) 
  endtask

  // 数据传输任务
  task do_data();
    fork
      // 通道 0：100 个事务，通道 ID 0，数据空闲 0，包空闲 1，数据大小 8
      `uvm_do_on_with(chnl_data_seq, p_sequencer.chnl_sqrs[0], {ntrans==100; ch_id==0; data_nidles==0; pkt_nidles==1; data_size==8; })
      // 通道 1：100 个事务，通道 ID 1，数据空闲 1，包空闲 4，数据大小 16
      `uvm_do_on_with(chnl_data_seq, p_sequencer.chnl_sqrs[1], {ntrans==100; ch_id==1; data_nidles==1; pkt_nidles==4; data_size==16;})
      // 通道 2：100 个事务，通道 ID 2，数据空闲 2，包空闲 8，数据大小 32
      `uvm_do_on_with(chnl_data_seq, p_sequencer.chnl_sqrs[2], {ntrans==100; ch_id==2; data_nidles==2; pkt_nidles==8; data_size==32;})
    join
    #10us; // 等待数据传输完成
  endtask
endclass: mcdf_data_consistence_basic_virtual_sequence

中文注释说明:

这段代码是一个 UVM 虚拟序列，用于验证 MCDF 的数据一致性。它继承自 mcdf_base_virtual_sequence 类。 序列包含三个主要任务：

do_reg(): 这个任务对 MCDF 的三个通道控制寄存器 (chnl0_ctrl_reg, chnl1_ctrl_reg, chnl2_ctrl_reg) 进行写操作，然后读操作，并比较写值和读值是否一致。 每个通道的配置参数（长度、优先级、使能）都不同。 最后发送一个 IDLE 命令。

do_formatter(): 这个任务配置格式化器单元。 它使用 fmt_config_seq 序列，并将 FIFO 类型设置为 LONG_FIFO，带宽设置为 HIGH_WIDTH。

do_data(): 这个任务在三个通道上发送数据。每个通道发送 100 个事务，每个通道的参数（事务数量、通道ID、数据空闲插入数量、包空闲插入数量、数据大小）都不同，模拟不同场景下的数据传输。 最后等待 10us，确保数据传输完成。

diff_value 是一个继承自父类的函数，用于比较写入值和读取值，并记录差异。 idle_reg_seq, fmt_config_seq, chnl_data_seq 都是预定义的序列，用于执行特定的操作。 p_sequencer 是指向 sequencer 的指针。 LONG_FIFO, HIGH_WIDTH 等都是预定义的常量。 这段代码展示了如何使用 UVM 的虚拟序列来驱动事务，并进行数据一致性检查。


```c

```c

```c

```c

```c

```c
class mcdf_data_consistence_basic_test extends mcdf_base_test;

  // UVM 组件实用程序宏
  `uvm_component_utils(mcdf_data_consistence_basic_test)

  // 构造函数
  function new(string name = "mcdf_data_consistence_basic_test", uvm_component parent);
    super.new(name, parent);
  endfunction

  // 运行顶层虚拟序列的任务
  task run_top_virtual_sequence();
    mcdf_data_consistence_basic_virtual_sequence top_seq = new(); // 创建一个新的虚拟序列
    top_seq.start(env.virt_sqr); // 启动虚拟序列
  endtask
endclass: mcdf_data_consistence_basic_test

//  -重置寄存器块
//  -通过 uvm_reg::set() 设置所有 WR 寄存器的值
//  -通过 uvm_reg_block::update() 更新它们
//  -通过 uvm_reg::mirror() 与后门访问比较寄存器值
class mcdf_full_random_virtual_sequence extends mcdf_base_virtual_sequence;
  `uvm_object_utils(mcdf_base_virtual_sequence)
  function new (string name = "mcdf_base_virtual_sequence");
    super.new(name);
  endfunction

  task do_reg();
    bit[31:0] ch0_wr_val; // 通道0写入值
    bit[31:0] ch1_wr_val; // 通道1写入值
    bit[31:0] ch2_wr_val; // 通道2写入值
    uvm_status_e status; // 状态变量

    // 重置寄存器块
    rgm.reset();

    // 通道 0：长度{4,8,16,32}，优先级{0,1,2,3}，使能{0,1}
    ch0_wr_val = ($urandom_range(0,3)<<3)+($urandom_range(0,3)<<1)+$urandom_range(0,1);
    ch1_wr_val = ($urandom_range(0,3)<<3)+($urandom_range(0,3)<<1)+$urandom_range(0,1);
    ch2_wr_val = ($urandom_range(0,3)<<3)+($urandom_range(0,3)<<1)+$urandom_range(0,1);

    // 使用 uvm_reg::set() 设置所有 WR 寄存器的值
    rgm.chnl0_ctrl_reg.set(ch0_wr_val);
    rgm.chnl1_ctrl_reg.set(ch1_wr_val);
    rgm.chnl2_ctrl_reg.set(ch2_wr_val);

    // 使用 uvm_reg_block::update() 更新寄存器
    rgm.update(status);

    // 等待 DUT 中的寄存器更新完成
    #100ns;

    // 使用 uvm_reg::mirror() 与后门访问比较写入值和读取值
    rgm.chnl0_ctrl_reg.mirror(status, UVM_CHECK, UVM_BACKDOOR);
    rgm.chnl1_ctrl_reg.mirror(status, UVM_CHECK, UVM_BACKDOOR);
    rgm.chnl2_ctrl_reg.mirror(status, UVM_CHECK, UVM_BACKDOOR);

    // 发送 IDLE 命令
    `uvm_do_on(idle_reg_seq, p_sequencer.reg_sqr)
  endtask

  task do_formatter();
    // 使用 fmt_config_seq 序列，配置 FIFO 为 SHORT_FIFO 或 ULTRA_FIFO，带宽为 LOW_WIDTH 或 ULTRA_WIDTH
    `uvm_do_on_with(fmt_config_seq, p_sequencer.fmt_sqr, {fifo inside {SHORT_FIFO, ULTRA_FIFO}; bandwidth inside {LOW_WIDTH, ULTRA_WIDTH};})
  endtask

  task do_data();
    fork
      // 通道 0：事务数量在 400 到 600 之间，其他参数随机
      `uvm_do_on_with(chnl_data_seq, p_sequencer.chnl_sqrs[0], 
        {ntrans inside {[400:600]}; ch_id==0; data_nidles inside {[0:3]}; pkt_nidles inside {1,2,4,8}; data_size inside {8,16,32};})
      // 通道 1：事务数量在 400 到 600 之间，其他参数随机
      `uvm_do_on_with(chnl_data_seq, p_sequencer.chnl_sqrs[1], 
        {ntrans inside {[400:600]}; ch_id==0; data_nidles inside {[0:3]}; pkt_nidles inside {1,2,4,8}; data_size inside {8,16,32};})
      // 通道 2：事务数量在 400 到 600 之间，其他参数随机
      `uvm_do_on_with(chnl_data_seq, p_sequencer.chnl_sqrs[2], 
        {ntrans inside {[400:600]}; ch_id==0; data_nidles inside {[0:3]}; pkt_nidles inside {1,2,4,8}; data_size inside {8,16,32};})
    join
    #10us; // 等待数据传输完成
  endtask
endclass: mcdf_full_random_virtual_sequence

class mcdf_full_random_test extends mcdf_base_test;

`uvm_component_utils(mcdf_full_random_test)

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

task run_top_virtual_sequence();
  mcdf_full_random_virtual_sequence top_seq = new();
  top_seq.start(env.virt_sqr);
endtask

endclass: mcdf_full_random_test

中文注释说明:

这段代码包含两个类：

mcdf_data_consistence_basic_test: 这是一个基本的测试类，它继承自 mcdf_base_test，并运行一个名为 mcdf_data_consistence_basic_virtual_sequence 的虚拟序列。这个序列的具体内容在之前的回答中已经解释过。

mcdf_full_random_virtual_sequence: 这是一个更复杂的虚拟序列，用于执行全随机化的寄存器和数据传输测试。 它包含以下步骤：

寄存器操作 (do_reg): 首先重置寄存器块 (rgm.reset)。然后，使用随机值设置三个通道控制寄存器的值 (chnl0_ctrl_reg, chnl1_ctrl_reg, chnl2_ctrl_reg)，并使用 uvm_reg_block::update() 更新寄存器。 之后等待一段时间，确保寄存器值在DUT中更新。最后，使用 uvm_reg::mirror() 与后门访问 (UVM_BACKDOOR) 比较写入值和读取值，验证寄存器值的正确性。

格式化器配置 (do_formatter): 随机配置格式化器的 FIFO 和带宽。

数据传输 (do_data): 在三个通道上发送随机数量的数据，其他参数也随机化。

这个测试类使用 UVM 的寄存器模型 (uvm_reg, uvm_reg_block) 来验证寄存器的值，并使用随机化技术提高测试的覆盖率。 $urandom_range 用于生成随机数，inside 用于约束随机变量的取值范围。 UVM_CHECK 和 UVM_BACKDOOR 是 UVM 中用于指定镜像操作类型的常量。 SHORT_FIFO, ULTRA_FIFO, LOW_WIDTH, ULTRA_WIDTH 等是预定义的常量。 idle_reg_seq, fmt_config_seq, chnl_data_seq 都是预定义的序列。

总而言之，这两个类共同构成一个更全面的 MCDF 数据一致性验证方案，包含了基本测试和随机化测试。


```c

```python

```python

```python

```c
class mcdf_reg_builtin_virtual_sequence extends mcdf_base_virtual_sequence;
  // UVM 对象实用程序宏
  `uvm_object_utils(mcdf_reg_builtin_virtual_sequence)

  // 构造函数
  function new (string name = "mcdf_reg_builtin_virtual_sequence");
    super.new(name);
  endfunction

  // 寄存器操作任务
  task do_reg();
    // 创建内置 UVM 寄存器序列
    uvm_reg_hw_reset_seq reg_rst_seq = new(); // 硬件复位序列
    uvm_reg_bit_bash_seq reg_bit_bash_seq = new(); // 位翻转序列
    uvm_reg_access_seq reg_acc_seq = new(); // 寄存器访问序列

    // 等待复位信号下降沿和上升沿
    @(negedge p_sequencer.intf.rstn); // 等待复位信号下降沿
    @(posedge p_sequencer.intf.rstn); // 等待复位信号上升沿

    `uvm_info("BLTINSEQ", "register reset sequence started", UVM_LOW) // 打印信息：寄存器复位序列开始
    rgm.reset(); // 重置寄存器模型
    reg_rst_seq.model = rgm; // 设置寄存器模型
    reg_rst_seq.start(p_sequencer.reg_sqr); // 启动寄存器复位序列
    `uvm_info("BLTINSEQ", "register reset sequence finished", UVM_LOW) // 打印信息：寄存器复位序列结束

    `uvm_info("BLTINSEQ", "register bit bash sequence started", UVM_LOW) // 打印信息：寄存器位翻转序列开始
    // 复位硬件寄存器和寄存器模型
    p_sequencer.intf.rstn <= 'b0; // 将复位信号置低
    repeat(5) @(posedge p_sequencer.intf.clk); // 等待 5 个时钟周期
    p_sequencer.intf.rstn <= 'b1; // 将复位信号置高
    rgm.reset(); // 重置寄存器模型
    reg_bit_bash_seq.model = rgm; // 设置寄存器模型
    reg_bit_bash_seq.start(p_sequencer.reg_sqr); // 启动寄存器位翻转序列
    `uvm_info("BLTINSEQ", "register bit bash sequence finished", UVM_LOW) // 打印信息：寄存器位翻转序列结束

    `uvm_info("BLTINSEQ", "register access sequence started", UVM_LOW) // 打印信息：寄存器访问序列开始
    // 复位硬件寄存器和寄存器模型
    p_sequencer.intf.rstn <= 'b0; // 将复位信号置低
    repeat(5) @(posedge p_sequencer.intf.clk); // 等待 5 个时钟周期
    p_sequencer.intf.rstn <= 'b1; // 将复位信号置高
    rgm.reset(); // 重置寄存器模型
    reg_acc_seq.model = rgm; // 设置寄存器模型
    reg_acc_seq.start(p_sequencer.reg_sqr); // 启动寄存器访问序列
    `uvm_info("BLTINSEQ", "register access sequence finished", UVM_LOW) // 打印信息：寄存器访问序列结束
  endtask
endclass: mcdf_reg_builtin_virtual_sequence

class mcdf_reg_builtin_test extends mcdf_base_test;

`uvm_component_utils(mcdf_reg_builtin_test)

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

task run_top_virtual_sequence();
  mcdf_reg_builtin_virtual_sequence top_seq = new();
  top_seq.start(env.virt_sqr);
endtask

endclass: mcdf_reg_builtin_test

中文注释说明:

这段代码定义了一个名为 mcdf_reg_builtin_virtual_sequence 的 UVM 虚拟序列，用于执行 UVM 内置的寄存器序列，包括：

硬件复位序列 (uvm_reg_hw_reset_seq): 这个序列模拟硬件复位过程。它首先等待复位信号 (rstn) 的下降沿和上升沿，确保复位操作完成。然后，它重置寄存器模型 (rgm.reset()) 并启动 uvm_reg_hw_reset_seq 序列。

位翻转序列 (uvm_reg_bit_bash_seq): 这个序列对寄存器中的每一位进行翻转，以检测潜在的错误。在执行此序列之前，它会先将复位信号置低，等待一段时间再置高，并重置寄存器模型。

寄存器访问序列 (uvm_reg_access_seq): 这个序列执行一系列的寄存器读写操作，以验证寄存器的功能。与位翻转序列类似，它也会先进行复位操作。

p_sequencer 指向当前的 sequencer 对象，p_sequencer.intf.rstn 和 p_sequencer.intf.clk 分别是复位信号和时钟信号。 rgm 是寄存器模型对象。 每个序列的启动都使用 start() 方法，并传递 sequencer 对象作为参数。 代码中包含了 uvm_info 语句，用于打印序列的开始和结束信息。 这个虚拟序列利用 UVM 内置的寄存器序列功能，提供了一种方便且高效的寄存器验证方法。