[转]MCDF实验——Lab1

最新推荐文章于 2022-10-26 13:57:31 发布

如筏喻者

最新推荐文章于 2022-10-26 13:57:31 发布

阅读量902

点赞数 2

分类专栏： SystemVerilog学习文章标签：其他

原文链接：https://blog.csdn.net/qq_39794062/article/details/113667354

版权

SystemVerilog学习专栏收录该内容

8 篇文章 14 订阅

订阅专栏

验证结构框架结构图

在这里插入图片描述

时钟信号分别送给chnl0_init、chnl1_init、chnl2_init和MCDT，chnl0_init、chnl1_init、chnl2_init这4个是硬件模块module可以例化，然后跟MCDT之间通过各个线网直接连接。
4个模块的数据来自于4个动态数组。
相比于Lab0来讲，Lab1把chnl_write()、chnl_idle()等一些方法封装到了一个硬件模块initiaor里面，不用通过传id来确定哪个通道进行数据传输，而是通过例化相对应的initiaor来进行。

时钟信号

把时钟信号和复位信号的生成，可以放到单独的task块内，然后通过initial块调用，进而生成所需要的时钟信号和复位信号。

// clock generation
task clk_gen();
  clk <= 0;
  forever begin
    #5 clk<= !clk;
  end
endtask

initial begin
  // generate clk
  clk_gen();
end

// reset trigger
// create task rstn_gen()
task rstn_gen();
  #10 rstn <= 0;
  repeat(10) @(posedge clk);
  rstn <= 1;
endtask

initial begin
  // trigger rstn
  rstn_gen();
end

仿真波形
在这里插入图片描述
这样要注意的是clk_gen()和rstn_gen()不可以放在一个initial块里面，如果放在一个initial块里面，波形如下所示

显然仿真波形里面只产生了clock时钟信号，并没有产生复位信号，这是因为多个initial块是并行的，而把时钟信号和复位信号放在一个initial块里面，在initial块内部的执行顺序是串行的，执行clk_gen()时，forever会一直执行，不断产生时钟信号，导致rstn_gen()方法无法调用执行。

我们还可以通过传参的方式指定时钟周期，代码如下

task clk_gen(int peroid);
  clk <= 0;
  forever begin
    #peroid clk<= !clk;
  end
endtask

initial begin
  // generate clk
  clk_gen(20);
end

仿真波形
在这里插入图片描述
通过传参的方式，使得时钟信号20ns一翻转

数组的使用

如果要对每一个channel发送100个数据或者更多个数据，可以创建动态数组，分别放置要发送给每一个channel的数据

logic [31:0] chnl0_arr[];
logic [31:0] chnl1_arr[];
logic [31:0] chnl2_arr[];

然后每个动态数组要事先生成数据

initial begin
  chnl0_arr = new[100];
  chnl1_arr = new[100];
  chnl2_arr = new[100];
  foreach(chnl0_arr[i]) begin
    chnl0_arr[i] = 'h00C0_00000 + i;
	chnl1_arr[i] = 'h00C1_00000 + i;
	chnl2_arr[i] = 'h00C2_00000 + i;
  end
end

接下来利用数组生成的数据，读取数据并发送给每一个channel

initial begin 
  @(posedge rstn);
  repeat(5) @(posedge clk);
  // channel 0 test
  // TODO use chnl0_arr to send all data
  foreach(chnl0_arr[i]) chnl_write(0, chnl0_arr[i]);

  // channel 1 test
  // TODO use chnl1_arr to send all data
  foreach(chnl1_arr[i]) chnl_write(1, chnl1_arr[i]);

  // channel 2 test
  // TODO use chnl2_arr to send all data
  foreach(chnl2_arr[i]) chnl_write(2, chnl2_arr[i]);

end

验证结构

为了实现清晰的验证结构，我们将DUT和激励发生器stimulator之间划分。可以将激励方法chnl_write()封装在新的模块chnl_initator中。模块可以例化，chnl0_init、chnl1_init、chnl2_init分别扮演每个channel通道对应的stimulator，发送激励，因此在其模块chnl_initator中定义了三个方法set_name()、chnl_write()、chnl_idle()

chnl_idle()：要实现一个时钟周期的空闲，在该周期中，ch_valid应为低，ch_data应为0。
chnl_write()：要实现一次有效的写数据，并随后调用chnl_idle()，实现一个空闲周期。在实现有效写数据时，只有当valid为高且ready为高时，数据写入才算成功，如果此时ready为低，那么则应该保持数据和valid信号，知道ready信号拉高时，数据写入才算成功。
set_name()：设置实例的名称，在发送各个channel数据前，设置各个channel_initiator的实例名称，方法打印信息，调试程序。

代码如下

module chnl_initiator(
  input               clk,
  input               rstn,
  output logic [31:0] ch_data,
  output logic        ch_valid,
  input               ch_ready,
  input        [ 5:0] ch_margin
);

string name;

function void set_name(string s);
  name = s;
endfunction

task chnl_write(input logic[31:0] data);
  // USER TODO
  // drive valid data
  // ...
  @(posedge clk);
  ch_valid <= 1;
  ch_data <= data;
  @(negedge clk);
  wait(ch_ready === 'b1);
  $display("%t channel initial [%s] sent data %x", $time, name, data);
  chnl_idle();
endtask

task chnl_idle();
  // USER TODO
  // drive idle data
  // ...
  @(posedge clk);
  ch_valid <= 0;
  ch_data <= 0;
endtask

endmodule

这个例化的channel_initiator可以并行的同时发送数据，使得发送的数据更加紧凑。

优化验证结构代码

`timescale 1ns/1ps


module chnl_initiator(
  input               clk,
  input               rstn,
  output logic [31:0] ch_data,
  output logic        ch_valid,
  input               ch_ready,
  input        [ 5:0] ch_margin
);

string name;

function void set_name(string s);
  name = s;
endfunction

task chnl_write(input logic[31:0] data);
  // USER TODO
  // drive valid data
  // ...
  @(posedge clk);
  ch_valid <= 1;
  ch_data <= data;
  @(negedge clk);
  wait(ch_ready === 'b1);
  $display("%t channel initial [%s] sent data %x", $time, name, data);
  chnl_idle();
endtask

task chnl_idle();
  // USER TODO
  // drive idle data
  // ...
  @(posedge clk);
  ch_valid <= 0;
  ch_data <= 0;
endtask

endmodule

module tb4_ref;
logic         clk;
logic         rstn;
logic [31:0]  ch0_data;
logic         ch0_valid;
logic         ch0_ready;
logic [ 5:0]  ch0_margin;
logic [31:0]  ch1_data;
logic         ch1_valid;
logic         ch1_ready;
logic [ 5:0]  ch1_margin;
logic [31:0]  ch2_data;
logic         ch2_valid;
logic         ch2_ready;
logic [ 5:0]  ch2_margin;
logic [31:0]  mcdt_data;
logic         mcdt_val;
logic [ 1:0]  mcdt_id;

mcdt dut(
   .clk_i(clk)
  ,.rstn_i(rstn)
  ,.ch0_data_i(ch0_data)
  ,.ch0_valid_i(ch0_valid)
  ,.ch0_ready_o(ch0_ready)
  ,.ch0_margin_o(ch0_margin)
  ,.ch1_data_i(ch1_data)
  ,.ch1_valid_i(ch1_valid)
  ,.ch1_ready_o(ch1_ready)
  ,.ch1_margin_o(ch1_margin)
  ,.ch2_data_i(ch2_data)
  ,.ch2_valid_i(ch2_valid)
  ,.ch2_ready_o(ch2_ready)
  ,.ch2_margin_o(ch2_margin)
  ,.mcdt_data_o(mcdt_data)
  ,.mcdt_val_o(mcdt_val)
  ,.mcdt_id_o(mcdt_id)
);

// clock generation
initial begin 
  clk <= 0;
  forever begin
    #5 clk <= !clk;
  end
end

// reset trigger
initial begin 
  #10 rstn <= 0;
  repeat(10) @(posedge clk);
  rstn <= 1;
end

logic [31:0] chnl0_arr[];
logic [31:0] chnl1_arr[];
logic [31:0] chnl2_arr[];
// USER TODO
// generate 100 data for each dynamic array
initial begin
  chnl0_arr = new[100];
  chnl1_arr = new[100];
  chnl2_arr = new[100];
  foreach(chnl0_arr[i]) begin
    chnl0_arr[i] = 'h00C0_00000 + i;
	chnl1_arr[i] = 'h00C1_00000 + i;
	chnl2_arr[i] = 'h00C2_00000 + i;
  end
end

// USER TODO
// use the dynamic array, user would send all of data
// data test
initial begin 
  @(posedge rstn);
  repeat(5) @(posedge clk);
  // USER TODO
  // Give unique names to each channel initiator
  // ...
  chnl0_init.set_name("chnl0_init");
  chnl1_init.set_name("chnl0_init");
  chnl2_init.set_name("chnl0_init");
  
  // channel 0 test
  // TODO use chnl0_arr to send all data
  foreach(chnl0_arr[i]) chnl0_init.chnl_write(chnl0_arr[i]);

  // channel 1 test
  // TODO use chnl1_arr to send all data
  foreach(chnl1_arr[i]) chnl1_init.chnl_write(chnl1_arr[i]);

  // channel 2 test
  // TODO use chnl2_arr to send all data
  foreach(chnl2_arr[i]) chnl2_init.chnl_write(chnl2_arr[i]);
end


chnl_initiator chnl0_init(
  .clk      (clk),
  .rstn     (rstn),
  .ch_data  (ch0_data),
  .ch_valid (ch0_valid),
  .ch_ready (ch0_ready),
  .ch_margin(ch0_margin) 
);

chnl_initiator chnl1_init(
  .clk      (clk),
  .rstn     (rstn),
  .ch_data  (ch1_data),
  .ch_valid (ch1_valid),
  .ch_ready (ch1_ready),
  .ch_margin(ch1_margin) 
);

chnl_initiator chnl2_init(
  .clk      (clk),
  .rstn     (rstn),
  .ch_data  (ch2_data),
  .ch_valid (ch2_valid),
  .ch_ready (ch2_ready),
  .ch_margin(ch2_margin) 
);

endmodule

---------------------
作者：煎丶包
来源：CSDN
原文：https://blog.csdn.net/qq_39794062/article/details/113667354
版权声明：本文为作者原创文章，转载请附上博文链接！
内容解析By：CSDN,CNBLOG博客文章一键转载插件

如筏喻者

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
1
评论
[转]MCDF实验——Lab1

验证结构框架结构图时钟信号分别送给chnl0_init、chnl1_init、chnl2_init和MCDT，chnl0_init、chnl1_init、chnl2_init这4个是硬件模块module可以例化，然后跟MCDT之间通过各个线网直接连接。4个模块的数据来自于4个动态数组。相比于Lab0来讲，Lab1把chnl_write()、chnl_idle()等一些方法封装到了一个硬件模块initiaor里面，不用通过传id来确定哪个通道进行数据传输，而是通过例化相对应的initiaor来进行。
复制链接

扫一扫