devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【IC验证】一文速通多通道数据整型器(MCDF)

作者：从前慢现在也慢 | 2024-06-03 08:58:28

赞

踩

【IC验证】一文速通多通道数据整型器(MCDF)

目录

01 README

02 MCDF设计结构

2.1 功能描述

2.2 设计结构

2.3 接口与时序

2.3.1 系统信号接口

2.3.2 通道从端接口

2.3.3 整形器接口

2.3.4 控制寄存器接口

2.3.4.1 接口时序图

2.3.4.2 各数据位信息

03 验证框图

3.1 reg_pkg

3.1.1 reg_trans

3.1.2 reg_driver

3.1.3 reg_generator

3.1.4 reg_monitor

3.1.5 reg_agent

3.2 fmt_pkg

3.2.1 fmt_trans

3.2.2 fmt_driver

3.2.3 fmt_generator

3.2.4 fmt_monitor

3.2.5 fmt_agent

3.3 mcdf_pkg

3.3.1 mcdf_refmod

3.3.2 mcdf_checker

3.3.3 mcdf_env

3.3.4 mcdf_base_test

3.3.5 mcdf_reg_write_read_test

3.3.6 mcdf_reg_illegal_access_tets

3.3.7 mcdf_arbiter_priority_test

3.3.8 mcdf_channel_disbale_test

3.3.9 mcdf_coverage

04 覆盖率收集

01 README

        最最开始系统地学习芯片领域相关只是大概追溯到23年12月初，此前只是有一些Verilog和数电基础，做过两个小的设计项目。整个12月和1月几乎都在学习FPGA的相关课程，仍记得在跨年夜在宿舍敲UART串口通信那篇文章@UART串口通信_uart串口通讯-CSDN博客，但同时也感受到在国外没有开发板的情况下确实很难把这些东西学好。因此年后转而开始学习更偏向于软件的数字IC验证。期间也是断断续续，国内学校的事情太多了，因此总是不能全身心投入，加上自己软件基础并不好，C＋＋，python这些语言学的都不好。大概花了3个月的时间基本学完了SV的语法，验证的基本流程和熟悉验证软件的使用，但也不敢说能够熟练掌握。目前算是进入了下一个时间节点，开始学习UVM验证环境。因此基于MCDF项目对此前学习进行一个总结。大佬们轻喷。

02 MCDF设计结构

2.1 功能描述

        设计模块的全称叫做multi-channel data formatter，他可以将上行多个数据通道的数据通过内部的SLAVE, FIFO给到仲裁器Arbiter, Arbiter选择从不同的FIFO中读取数据，给到下端的Formatter, 对数据进行整形，以数据包的形式送给下行的数据接收端。整个设计通过Register接受外部命令，对MCDF的功能进行修改。

2.2 设计结构

2.3 接口与时序

2.3.1 系统信号接口

clk(0)  :时钟信号
rstn(0):复位信号

2.3.2 通道从端接口

CHx_DATA(31:0)：通道数据输入。

CHx_VALID(0)：通道数据有效标志信号，高位有效。

CHx_READY(0)：通道数据接收信号，高位表示接收成功

当valid为高时，表示要写入数据。如果该时钟周期ready为高，则表示已经将数据写入；如果该时钟周期ready为低，则需要等到ready为高的时钟周期才可以将数据写入。

2.3.3 整形器接口

FMT_CHID(1:0)：整形数据包的通道ID号。
FMT_LENGTH(4:0)：整形数据包长度信号。
FMT_REQ(0)：整形数据包发送请求。
FMT_GRANT(0)：整形数据包被允许发送的接受标示。
FMT_DATA(31:0)：数据输出端口。
FMT_START(0)：数据包起始标示。
FMT_END(0)：数据包结束标示。

  • 整形器的作用是对数据进行打包，以数据包的形式向下行数据接收端传递数据，可以选择的数据包长度为4，8，16，32，这是由FMT_LENGTH信号来进行控制。
  • 在发送数据包时，首先应该将FMT_REQ置为高，同时等待接收端的FMT_GRANT拉高，此时表示接收端可以进行数据接受。当FMT_GRANT变为高时，应该在下一个周期将FMT_REQ置为低。FMT_START也必须在接收到FMT_GRANT高有效的下一个时钟被置为高，且需要维持一个时钟周期。在FMT_START被置为高有效的同一个周期，数据也开始传送，数据之间不允许有空闲周期，即应该连续发送数据，直到发送完最后一个数据时，FMT_END也应当被置为高并保持一个时钟周期。在数据包传输过程中FMT_CHID和FMT_LENGTH应该保持不变，直到数据包发送完毕。
  • 相邻的数据包之间应该至少有一个时钟周期的空闲，即FMT_END从高位被拉低以后，至少需要经过一个时钟周期，FMT_REQ才可以被再次置为高。

2.3.4 控制寄存器接口

CMD(1:0)：寄存器读写命令。

CMD_ADDR(7:0)：寄存器地址。

CMD_DATA_IN(31:0)：寄存器写入数据。

CMD_DATA_OUT(31:0)：寄存器读出数据。

2.3.4.1 接口时序图

当cmd为写指令时，需要把数据cmd_data_in写入到cmd_addr对应的寄存器中；当cmd为读指令时，即需要从cmd_addr对应的寄存器中读取数据，并在下一个周期，将数据驱动至cmd_data_out接口。

2.3.4.2 各数据位信息
  • 地址0x00 通道控制寄存器 32bits 读写寄存器

bit(0)：通道使能信号。1为打开，0位关闭。复位值为1。

bit(2:1)：优先级。0为最高，3为最低。复位值为3。
bit(5:3)：数据包长度，解码对应表为， 0对应长度4，1对应长度8，2对应长度16，3对应长度32，其它数值（4-7）均暂时对应长度32。复位值为0。
bit(31:6)：保留位，无法写入。复位值为0。

  • 地址0x10 通道状态寄存器 32bits 只读寄存器

bit(7:0)：上行数据从端FIFO的可写余量，同FIFO的数据余量保持同步变化。复位值为FIFO的深度数。
bit(31:8)：保留位，复位值为0。

03 验证框图

一共分为chnl_pkg, reg_pkg, fmt_pkg和mcdf_pkg, 各个包之间通过interface进行连接

3.1 reg_pkg

3.1.1 reg_trans

寄存器传输类，包含地址、命令、数据和响应字段

  1. class reg_trans;
  2. 		rand bit[7:0]  addr;
  3. 		rand bit[1:0]  cmd ;
  4. 		rand bit[31:0] data;
  5. 		bit rsp;
  6. 	
  7. 		constraint cstr{
  8. 			soft cmd  inside{'WRITE, 'READ, 'IDLE};
  9. 			soft addr inside{'SLV0_RW_ADDR, 'SLV1_RW_ADDR, 'SLV2_RW_ADDR, 'SLV0_R_ADDR, 'SLV1_R_ADDR, 'SLV2_R_ADDR};
  10. 			addr[7:4] ==0 && cmd == 'WRITE -> soft data [31:6] == 0;//读写寄存器要求高26位为0
  11. 			soft addr [7:5] == 0;
  12. 			addr[4] == 1 -> soft cmd == 'READ;//地址为0x10,0x14,0x18的是通道1，2，3的只读存储器
  13. 		};
  14. 		
  15. 		function reg_trans clone() ;
  16. 			reg_trans c = new()    ;
  17. 			c.addr      = this.addr;
  18. 			c.cmd       = this.cmd ;
  19. 			c.data      = this.data;
  20. 			c.rsp       = this.rsp ;
  21. 			return c               ;
  22. 		endfunction
  23. 		
  24. 		function string sprint();
  25. 			string s ;
  26. 			s = {s, $sformatf("========================n")};
  27. 			s = {s, $sformatf("reg_trans object content is as below:\n")};
  28. 			s = {s, $sformatf("addr =  %2x:\n", this.addr)};//两位16进制数
  29. 			s = {s, $sformatf("cmd  =  %2b:\n", this.cmd )};//2位2进制数
  30. 			s = {s, $sformatf("data =  %8x:\n", this.data)};//8位16进制数
  31. 			s = {s, $sformatf("rsp  =  %0d:\n", this.rsp )};//10进制数，无字符宽度
  32. 			s = {s, $sformatf("=======================\n")};
  33. 			return s;
  34. 		endfunction
  35. 	endclass

3.1.2 reg_driver

寄存器驱动器，用于生成寄存器传输事务并将其发送到接口。
该类包括了一个 do_drive 任务来驱动事务的发送，一个 do_reset 任务来处理复位信号，以及一个 reg_write 任务来处理寄存器的读写操作。

  1. 	class reg_driver;
  2. 		local string name;
  3. 		local virtual reg_intf intf;
  4. 		mailbox #(reg_trans) reg_mb;
  5. 		mailbox #(reg_trans) rsp_mb;
  6. 		
  7. 		function new(string name = "reg_driver");
  8. 			this.name = name;
  9. 		endfunction
  10. 		
  11. 		function void set_interface (virtual reg_intf intf);
  12. 			if(intf == null)
  13. 				$error("interface is null");
  14. 			else
  15. 				this.intf == intf;
  16. 		endfunction
  17. 		
  18. 		task run();
  19. 			fork
  20. 				this.do_drive();
  21. 				this.do_reset();
  22. 			join
  23. 		endtask
  24. 		
  25. 		task do_reset();
  26. 			forever begin
  27. 				@(negedge intf.rstn);
  28. 				intf.cmd_addr     <= 0    ;
  29. 				intf.cmd          <= 'IDLE;
  30. 				intf.cmd_data_m2s <= 0    ;
  31. 			end
  32. 			
  33. 		task do_drive();
  34. 			reg_trans req, rsp;
  35. 			@(posedge intf.rstn);
  36. 			forever begin
  37. 				this.req_mb.get(req);
  38. 				this.reg_write(req);
  39. 				rsp = req.clone();
  40. 				rsp.rsp = 1;
  41. 				this.rsp_mb.put(rsp);
  42. 			end
  43. 		endtask
  44. 		
  45. 		task reg_write (reg_trans t);
  46. 			@posedge (intf.clk iff intf.rstn);//这是一个复合条件，iff 表示 "if and only if"，即当且仅当。
  47. 											  //所以整个条件表示：只有当 intf.rstn 为逻辑真时，才触发在 intf.clk 的上升沿执行操作。
  48. 			case(t.cmd)
  49. 				'WRITE:begin
  50. 						intf.drv_ck.cmd_addr <= t.addr;
  51. 						intf.drv_ck.cmd <= t.cmd;
  52. 						intf.drv.cmd_data_m2s <= t.data;						
  53. 						end
  54. 				'READ :begin
  55. 						intf.drv_ck.cmd_addr <= t.addr;
  56. 						intf.drv_ck.cmd <= t.cmd;
  57. 						repeat(2) @(negedge intf.clk);//为何要等两个下降沿？
  58. 						t.data = intf.cmd_data_s2m;
  59. 						end
  60. 				'IDLE :begin
  61. 						this.reg_idle();
  62. 						end
  63. 				default: $error("command %b is illegal", t.cmd);
  64. 			endcase 
  65. 			$display("%0t reg driver [%s] sent addr %2x,cmd %2b,data %8x",$time,name,t.addr,t.cmd,t.data);
  66. 		endtask
  67. 		
  68. 		task reg_idle();
  69. 			@(posedge intf.clk);
  70. 			intf.drv_ck.cmd_addr <= 0    ;
  71. 			intf.drv_ck.cmd_addr <= 0    ;
  72. 			intf.drv_ck.cmd      <= 'IDLE;
  73. 		endtask
  74. 	endclass

3.1.3 reg_generator

生成寄存器传输事务，并提供一个 send_trans 任务来发送事务并处理响应。

  1. 	class reg_generator;
  2. 		rand bit [7:0] addr = -1;
  3. 		rand bit [1:0] cmd  = -1;
  4. 		rand bit [31:0]data = -1;
  5. 		
  6. 		mailbox #(reg_trans) req_mb;
  7. 		mailbox #(reg_trans) rsp_mb;
  8. 		
  9. 		reg_trans reg_req[$];
  10. 		
  11. 		constraint cstr{
  12. 			soft addr == -1;
  13. 			soft cmd  == -1;
  14. 			soft data == -1;
  15. 		}
  16. 		
  17. 		function new();
  18. 			this.req_mb = new();
  19. 			this.rsp_mb = new();
  20. 		endfunction
  21. 		
  22. 		task start();
  23. 			send_trans();
  24. 		endtask
  25. 		
  26. 		//generate transaction and put into local mailbox
  27. 		task send_trans();
  28. 			reg_tans req,rsp;
  29. 			req = new();
  30. 			assert(req.randomize with{local::addr >= 0 -> addr == local::addr;
  31. 									  local::cmd  >= 0 -> cmd  == local::cmd;
  32. 									  local::data >= 0 -> data == local::data;
  33. 										})
  34. 			else 
  35. 				$fatal("register packet randomization fail");
  36. 			$display(req.sprint());
  37. 			this.req_mb.put(req);
  38. 			this.rsp_mb.get(rsp);
  39. 			$display(rsp.sprint());
  40. 			if(req.cmd == 'READ)
  41. 				this.data = rsp.data;
  42. 			assert(rsp.rsp)//确保收到的响应中包含有效的响应标志。如果响应标志无效，则通过 $error 报错。
  43. 				else $error("[RSPERR] 0%t error response received!", $time);
  44. 		endtask
  45. 		
  46. 		function string sprint();
  47. 			string s ;
  48. 			s = {s, $sformatf("========================n")};
  49. 			s = {s, $sformatf("reg_trans object content is as below:\n")};
  50. 			s = {s, $sformatf("addr =  %2x:\n", this.addr)};//两位16进制数
  51. 			s = {s, $sformatf("cmd  =  %2b:\n", this.cmd )};//2位2进制数
  52. 			s = {s, $sformatf("data =  %8x:\n", this.data)};//8位16进制数
  53. 			s = {s, $sformatf("rsp  =  %0d:\n", this.rsp )};//10进制数，无字符宽度
  54. 			s = {s, $sformatf("=======================\n")};
  55. 			return s;
  56. 		endfunction
  57. 		
  58. 		//用于在随机化后显示对象的内容。
  59. 		function void post_randomize();
  60. 			string s;
  61. 			s = {"AFTER RANDOMIZE \n",this.sprint()};
  62. 			$display (s);
  63. 		endfunction
  64. 	endclass

3.1.4 reg_monitor

寄存器监视器，用于监视寄存器传输事务并将其存储到邮箱中。

  1. 	class reg_monitor;
  2. 		local string name;
  3. 		local virtual reg_intf intf;
  4. 		mailbox #(reg_trans) mon_mb;
  5. 		
  6. 		function new(string name = "reg_monitor");
  7. 		this.name = name;
  8. 		endfunction
  9. 		
  10. 		function void set_interface(virtual reg_intf intf);
  11. 			if(intf == null)
  12. 				$error("interface handle is null");
  13. 			else
  14. 				this.intf = intf;
  15. 		endfunction 
  16. 		
  17. 		task run();
  18. 			this.mon_trans();
  19. 		endtask
  20. 		
  21. 		//其功能是监视寄存器接口的传输事务，并将监视到的信息存储到邮箱 mon_mb 中
  22. 		task mon_trans();
  23. 			reg_trans m;
  24. 			forever begin
  25. 				@(posedge intf.clk iff(intf.rstn && intf.mon_ck.cmd != 'IDLE));
  26. 				m = new();
  27. 				m.addr = intf.mon_ck.cmd_addr;
  28. 				m.cmd  = intf.mon_ck.cmd;
  29. 				if(intf.mon_ck.cmd == 'READ)begin
  30. 					@(posedge intf.clk);
  31. 					m.data = intf.mon_ck.cmd_data_s2m;
  32. 				end
  33. 				mon_mb.put(m);
  34. 				$display("%0t reg driver [%s] sent addr %2x,cmd %2b,data %8x",$time,this.name,m.addr,m.cmd,m.data);
  35. 			end
  36. 		endtask
  37. 	endclass

3.1.5 reg_agent

组合 reg_driver 和 reg_monitor，并提供了一个 run 任务来同时运行驱动器和监视器。

  1. 	class reg_agent;
  2. 		local string name;
  3. 		reg_driver driver;
  4. 		reg_monitor monitor;
  5. 		local virtual reg_intf vif;
  6. 		function new(string name = "reg_agent");
  7. 			this.name = name;
  8. 			this.driver = new({name,".driver"});
  9. 			this.monitor = new({name,".monitor"});
  10. 		endfunction
  11. 		
  12. 		function void set_interface(virtual reg_intf vif);
  13. 			this.vif = vif;
  14. 			driver.set_interface(vif);
  15. 			monitor.set_interface(vif);
  16. 		endfunction
  17. 		
  18. 		task run();
  19. 			fork
  20. 				driver.run();
  21. 				monitor.run();
  22. 			join
  23. 		endtask
  24. 	endclass

3.2 fmt_pkg

  1. 	import rpt_pkg::*;
  2. 	
  3. 	typedef enum {SHORT_FIFO, MED_FIFO, LONG_FIOF, ULTRA_FIFO} fmt_fifo_t;
  4. 	typedef enum {LOW_WIDTH, MED_WIDTH, HIGH_WIDTH, ULTRA_WIDTH} fmt_bandwidth_t;
  5. 	typedef enum bit[2:0]{
  6. 		FMT_REQ = 3'b000
  7. 		,FMT_WIDTH_GRANT = 3'b001
  8. 		,FMT_START       = 3'b011
  9. 		,FMT_SEND        = 3'b010
  10. 		,FMT_END         = 3'b110
  11. 		,FMT_IDLE        = 3'b111
  12. 	} fmt_state_t;

3.2.1 fmt_trans

模拟数据的比较和打印

  1. 	class fmt_trans;
  2. 		rand fmt_fifo_t fifo;
  3. 		rand fmt_bandwidth_t bandwidth;
  4. 		bit [9:0] length;
  5. 		bit [31:0]data[];
  6. 		bit [1:0] ch_id;
  7. 		bit rsp;
  8. 		constraint cstr{
  9. 			soft fifo      == MED_FIFO ;
  10. 			soft bandwidth == MED_WIDTH;
  11. 		};
  12. 		
  13. 		function fmt_trans clone();
  14. 			fmt_trans c = new();
  15. 			c.fifo      = this.fifo;
  16. 			c.bandwidth = this.bandwidth;
  17. 			c.length    = this.length;
  18. 			c.data      = this.data;
  19. 			c.ch_id     = this.ch_id;
  20. 			c.rsp       = this.rsp;
  21. 			return c;
  22. 		endfunction
  23. 		
  24. 		function string sprint();
  25. 			string s ;
  26. 			s = {s, $sformatf("========================\n")};
  27. 			s = {s, $sformatf("fmt_trans object content is as below:\n")};
  28. 			s = {s, $sformatf("fifo =  %s:\n", this.fifo)};
  29. 			s = {s, $sformatf("bandwidth  =  %s:\n", this.bandwidth )};
  30. 			s = {s, $sformatf("length =  %s:\n", this.length)};
  31. 			s = {s, $sformatf("rsp  =  %0d:\n", this.rsp )};
  32. 			foreach (data[i]) s = {s,$sformatf("data[%0d] = %8x \n", i, this.data[i])};
  33. 			s = {s, $sformatf("ch_id =  %0d:\n", this.ch_id)};
  34. 			s = {s, $sformatf("rsp  =  %0d:\n", this.rsp )};			
  35. 			s = {s, $sformatf("=======================\n")};
  36. 			return s;
  37. 		endfunction
  38. 		
  39. 		
  40. //??为啥要做这两个比较呢,fmt_trans例化后的内容不应该就和fmt_trans中的一样吗		
  41. //当你创建一个类（如 fmt_trans）的实例（对象）时，每个实例通常拥有自己的一套成员变量。
  42. //这意味着，即使两个对象是相同类的不同实例，它们的成员变量也可能拥有不同的值。
  43. //检查它们是否具有相同的长度和通道ID，并且它们的数据数组是否相同		
  44. 		function bit compare(fmt_trans t);
  45. 			string s;
  46. 			compare = 1;//假设对象最初是相等的。
  47. 			s = "\n============================\n";
  48. 			s = {s,$sformatf("COMPARING fmt_trans object at time %0d \n", $time)};
  49. 			if(this.length != t.length)begin//this.lengh指的是18行的length
  50. 				compare = 0;
  51. 				s = {s, $sformatf("sobj length %0d != tobj length %0d \n", this.length, t.length)};
  52. 			end
  53. 			if(thi.ch_id != t.ch_id)begin
  54. 				compare = 0;
  55. 				s = {s, $sformatf("sobj ch_id %0d != tobj ch_id %0d \n", this.ch_id, t.ch_id)};
  56. 			end
  57. 			foreach(this.data[i])begin
  58. 				if(this.data[i] != t.data[i])begin
  59. 					compare = 0;
  60. 					s = {s, $sformatf("sobj data[%0d] %8x != tobj data[%0d] %8x \n",i,  this.data[i], i, t.data[i])};
  61. 				end
  62. 			end
  63. 			if(compare == 1) s = {s, "COMPARED SUCCESS!\n"};
  64. 			else s = {s, "COMPARED FAILURED! \n "};
  65. 			rpt_pkg::rpt_msg("[CMPOBJ]", s, rpt_pkg::INFO, rpt_pkg::MEDIUM);
  66. 		endfunction
  67. 	endclass

3.2.2 fmt_driver

模拟数据发送和接受行为

  1. 	class fmt_driver;
  2. 		local string name;
  3. 		local virtual fmt_intf intf;
  4. 		mailbox #(fmt_trans) req_mb;
  5. 		mailbox #(fmt_trans) rsp_mb;//与generator通信 
  6. 		
  7. 		local mailbox #(logical[31:0]) fifo;//模拟formatter的下行数据
  8. 		local int fifo_bound; //模拟的下行通道最多能接受多少数据
  9. 		local int data_consum_period;// 反应下行数据输出的快慢。反比
  10. 		
  11. 		function new(string name = "fmt_driver");
  12. 			this.name = name;
  13. 			this.fifo = new();
  14. 			this.fifo_bound = 4096;
  15. 			this.data_consum_period = 1;
  16. 		endfunction
  17. 		
  18. 		function void set_interface(virtual fmt_intf intf);
  19. 			if(intf == null)
  20. 				$error("interface handle is null");
  21. 			else
  22. 				this.intf = intf;
  23. 		endfunction
  24. 		
  25. 		task run();
  26. 			fork
  27. 				this.do_receive();
  28. 				this.do_consume();
  29. 				this.do_config();
  30. 				this.do_reset();
  31. 			join
  32. 			
  33. 		//配置driver	
  34. 		task do_config();
  35. 			fmt_trans req, rsp;
  36. 			forever begin
  37. 				this.req_mb.get(req);
  38. 				case(req.fifo)
  39. 					SHORT_FIFO  : this.fifo_bound          = 64  ;
  40. 					MED_FIFO    : this.fifo_bound          = 256 ;
  41. 					LONG_FIOF   : this.fifo_bound          = 512 ;
  42. 					ULTRA_FIFO  : this.fifo_bound          = 2048;
  43. 				endcase
  44. 				this.fifo = new(this.fifo_bound);
  45. 				case(req.bandwidth) //为啥位宽低data_consum_period大呢？
  46. 									//可能是因为在低带宽条件下，数据传输速率较慢，
  47. 									//因此需要更长的周期来消费数据，以匹配数据的传输速率。
  48. 					LOW_WIDTH   : this.data_consum_period  = 8   ;
  49. 					MED_WIDTH   : this.data_consum_period  = 4   ;
  50. 					HIGH_WIDTH  : this.data_consum_period  = 2   ;
  51. 					ULTRA_WIDTH : this.data_consum_period  = 1   ;
  52. 				endcase
  53. 				rsp = req.clone();
  54. 				rsp.rsp = 1;//这里的 rsp 成员变量是一个标志位，用于表示某种状态或响应的有效性。
  55. 				this.rsp_mb.put(rsp);
  56. 			end                                                   
  57. 		endtask
  58. 		
  59. 		task do_reset();
  60. 			forever begin
  61. 				@(negedge intf.rstn)
  62. 				intf.fmt_grant <= 0;
  63. 			end
  64. 		endtask
  65. 		
  66. //模拟具有随机延迟的数据消费场景。按照随机的时间间隔取出数据
  67. 		task do_consume();
  68. 			logic[31:0] data;
  69. 			forever begin
  70. 				void'(this.fifo.try_get(data));// 使用 try_get 方法尝试从FIFO中取出一个数据项并赋值给 data 变量
  71. 				//void'() 是SystemVerilog中的一个特性，它用来忽略 try_get 方法返回的状态值
  72. 				repeat($urandom_range(1, this.data_consum_period)) @(posedge intf.clk);//这里反应消耗数据的快慢
  73. 				//等待intf.clk的上升沿，repeat重复一次
  74. 			end
  75. 		endtask 
  76. 	endclass
  77. 	
  78. 	//当数据接受的请求信号fmt_req拉高时，且FIFO深度足够时，fmt_grant拉高，表示接收方准备好接受数据了
  79. //
  80.  
  81. 		task do_receive();//模拟接受数据
  82. 			forever begin
  83. 				@(posedge intf.fmt_req);
  84. 				forever begin
  85. 					@(posedge intf.clk);
  86. 					if((this.fifo_bound-this.fifo.num()) >= intf.fmt_length)
  87. 					//fifo_bound是选择的fifo的总深度
  88. 					//检查当前FIFO的剩余空间是否足够存放即将到来的数据。
  89. 					//如果剩余空间大于或等于 intf.fmt_length 指定的长度，则跳出内部循环。
  90. 						break;//只跳出内部的这个forever。当fifo余量足够时，拉高grant
  91. 				end
  92. 				intf.drv_ck.fmt_grant <= 1;//表示接收方准备好接受数据了
  93. 				@(posedge intf.fmt_start);//等待 intf.fmt_start 信号的下一个上升沿，
  94. 										 //这表示发送方已经准备好发送数据。
  95. 				fork 
  96. 					begin
  97. 						@(posedge intf.clk);
  98. 						intf.drv_ck.fmt_grant <= 0;//维持一拍后就拉低，不再授权数据传输
  99. 					end
  100. 				join_none
  101. 				repeat(intf.fmt_length)begin
  102. 					@(nedge intf.clk);
  103. 					this.fifo.put(intf.fmt_data);//连续放入数据
  104. 				end
  105. 			end
  106. 		endtask

3.2.3 fmt_generator

创建、随机化、发送和接收 fmt_trans 类型的数据事务

  1. 	class fmt_generator;
  2. 		rand fmt_fifo_t fifo = MED_FIFO;
  3. 		rand fmt_bandwidth_t bandwidth = MED_WIDTH;
  4. 		
  5. 		mailbox #(fmt_trans) req_mb;//在 fmt_generator 类中，req_mb 用于发送 fmt_trans 类型的请求事务，
  6. 									//而 rsp_mb 用于接收响应事务。这种方式使得 fmt_generator 可以作为一个独立的组件，
  7. 									//模拟发送请求并等待响应，而不依赖于特定的通信协议实现细节。
  8. 		mailbox #(fmt_trans) rsp_mb;
  9. 		
  10. 		constraint cstr{
  11. 			soft fifo == MED_FIFO;
  12. 			soft bandwidth == MED_WIDTH;
  13. 		}
  14. 		
  15. 		function new();
  16. 			this.req.mb = new();
  17. 			this.rsp.mb = new();
  18. 		endfunction
  19. 		
  20. 		task start();
  21. 			send_trans();
  22. 		endtask
  23. 		
  24. 		//产生事务并放到本地信箱
  25. 		task send_trans();
  26. 			fmt_trans req, rsp;
  27. 			req = new();//为何这里是MED_FIFO呢，不等于就随机化失败？什么道理
  28. 						//因为192行就是这样给的
  29. 			assert (req.randomize with {local::fifo != MED_FIFO -> fifo == local::fifo
  30. 										local::bandwidth != MED_WIDTH -> bandwidth == local::bandwidth;
  31. 									   })
  32. 				else $fatal("[RNDFALL] formatter packet randomize failure!");
  33. 			$display(req.sprint());
  34. 			this.req_mb.put(req);//放入请求
  35. 			this.rsp_mb.get(rsp);//取出响应
  36. 			$display(rsp.sprint());
  37. 			assert(rsp.rsp)//检查响应是否有效
  38. 				else $error("[RSPERR] %0t error response received!", $time);
  39. 		endtask
  40. 		
  41. 		function string sprint();
  42. 			string s;
  43. 			s = {s, $sformatf("========================\n")};
  44. 			s = {s, $sformatf("fmt_generator object content is as below:\n")};
  45. 			s = {s, $sformatf("fifo =  %s:\n", this.fifo)};
  46. 			s = {s, $sformatf("bandwidth  =  %s:\n", this.bandwidth )};
  47. 			s = {s, $sformatf("=======================\n" )};
  48. 			return s;
  49. 		endfunction
  50. 		
  51. 		function void post_randomize();
  52. 			string s;
  53. 			s = {"AFTER RANDOMIZE \n", this.sprint()};
  54. 			$display(s);
  55. 		endfunction
  56. 		
  57. 	endclass

3.2.4 fmt_monitor

用于观察和记录通过接口 fmt_intf 传输的数据事务

  1. 	class fmt_monitor;
  2. 		local string name;
  3. 		local virtual fmt_intf intf;
  4. 		mailbox #(fmt_trans) mon_mb;//用于存储监视到的 fmt_trans 类型的事务。
  5. 		function new(string name = "fmt_generator");
  6. 			this.name = name;
  7. 		endfunction
  8. 		
  9. 		function void set_interface(virtual fmt_intf intf);
  10. 			if(intf == null)
  11. 				$error("interface handle is null")
  12. 			else 
  13. 				this.intf = intf;
  14. 		endfunction//设置监视器要监视的接口
  15. 		
  16. 		task run();
  17. 			this.mon_trans();
  18. 		endtask
  19. 		
  20. 		task mon_trans();
  21. 			fmt_trans m;
  22. 			string s;
  23. 			forever begin
  24. 				@(posedge intf.mon_ck.fmt_start);//等待 intf.mon_ck.fmt_start 信号的上升沿，表示一个新事务的开始。
  25. 				m = new();
  26. 				m.length = intf.mon_ck.fmt_length;
  27. 				m.ch_id  = intf.mon_ck.fmt_chid;
  28. 				m.data   = new[m.length];//接口中获取事务的长度、通道ID和数据，并将它们赋值给 m 对象。
  29. 				foreach(m.data[i])begin
  30. 					@(posedge intf.clk);//在每个时钟上升沿从接口中获取数据，并将其存储在 m.data 数组中。
  31. 					m.data[i] = intf.mon_ck.fmt_data;
  32. 				end
  33. 				mon_mb.put(m);
  34. 				s = {s, $sformatf("========================\n")};
  35. 				s = {s, $sformatf("%0t %s monitored a packet:\n", $time, this.name)};
  36. 				s = {s, $sformatf("length =  %0d:\n", m.length)};
  37. 				s = {s, $sformatf("chid  =  %0d:\n", m.ch_id )};
  38. 				foreach (m.data[i] s = {s,$sformatf("data[%0d] = %8x \n", i, m.data[i])};	
  39. 				s = {s, $sformatf("=======================\n" )};
  40. 				$display(s);
  41. 			end
  42. 		endtask
  43. 	endclass
  44.

3.2.5 fmt_agent

组合驱动器（fmt_driver）和监视器（fmt_monitor）组件

  1. 	class fmt_agent;
  2. 		local string name;
  3. 		fmt_driver driver;
  4. 		fmt_monitor monitor;
  5. 		local virtual fmt_intf vif;
  6. 		
  7. 		function new(string name = "fmt_agent");
  8. 			this.name   = name;
  9. 			this.driver = new({name, ".driver"});
  10. 			this.monitor= new({name, ".monitor"});
  11. 		endfunction
  12. 		
  13. 		function void set_interface(virtual fmt_intf vif);
  14. 			this.vif = vif;
  15. 			driver.set_interface(vif);
  16. 			monitor.set_interface(vif);
  17. 		endfunction
  18. 		
  19. 		task run();
  20. 			fork
  21. 				driver.run();
  22. 				monitor.run();
  23. 			join
  24. 		endtask 
  25. 	endclass

3.3 mcdf_pkg

  1. 	import chnl_pkg::*;
  2. 	import reg_pkg ::*;
  3. 	import arb_pkg ::*;
  4. 	import fmt_pkg ::*;
  5. 	import rpt_pkg ::*;
  6. 	
  7. 	typedef struct packed{
  8. 		bit[2:0] lenl ;//后面用来规定各寄存器通道的数据包长度，优先级，使能信号，可写余量 
  9. 		bit[1:0] prio ;
  10. 		bit      en   ;
  11. 		bit[7:0] avail;
  12. 	}mcdf_reg_t
  13. 	
  14. 	typedef  enum{RW_LEN, RW_PRIO, RW_EN, RD_AVAIL}mcdf_field_t;//寄存器的不同比特位代表不同的功能，详见蓝皮书376页

3.3.1 mcdf_refmod

用于测试或模拟MCDF模块的寄存器行为，形成一个参考模型

  1. 	class mcdf_refmod;
  2. 		local virtual mcdf_intf intf;
  3. 		local string  name;
  4. 		mcdf_reg_t regs[3];
  5. 		mailbox #(reg_trans)  reg_mb;
  6. 		mailbox #(mon_data_t) in_mbs [3];
  7. 		mailbox #(fmt_trans)  out_mbs[3];
  8. 		
  9. 		function new(string name = "mcdf_refmod");
  10. 			this.name = name;
  11. 			foreach (this.out_mbs[i]) this.out_mbs[i] = new();
  12. 		endfunction
  13. 		
  14. 		task run();
  15. 			fork
  16. 				do_reset();
  17. 				this.do_reg_update();
  18. 				do_packet(0);
  19. 				do_packet(1);
  20. 				do_packet(2);				
  21. 			join
  22. 		endtask
  23. 		
  24. 		task do_reg_update();
  25. 			reg_trans t;
  26. 			forever begin
  27. 				this.reg_mb.get(t);
  28. 				if(t.addr[31 :4] == 0 && t.cmd == 'WRITE)begin
  29. 					this.regs[t.addr[3:2]].en   = t.data[0]   ;
  30. 					this.regs[t.addr[3:2]].prio = t.data[2:1] ;
  31. 					this.regs[t.addr[3:2]].len  = t.data[5:3] ;
  32. 				end
  33. 				else if(t.addr[7:4] == 1 && t.cmd == 'READ)begin
  34. 					this.regs[t.addr[3:2]].avail = t.data[7:0];
  35. 				end
  36. 			end
  37. 		endtask
  38. 		
  39. //处理数据包
  40. 		task do_packet(int id);
  41. 			fmt_trans  ot;
  42. 			mon_data_t it;
  43. 			bit[2:0] len;
  44. 			forever begin
  45. 				this.in_mbs[id].peek(it);
  46. 				ot = new();
  47. 				len = this.get_field_value(id, RW_LEN);
  48. 				ot.length = len > 3 ? 32:4 << len;//根据len的值计算数据包的长度。
  49. 				//为什么数据包长度这样定义        //如果len大于3，则长度为32，否则长度len左移4位。
  50. 				//因为第50行规定第4到6位存放数据包长度
  51. 				ot.data = new[ot.length];//根据计算出的长度，动态分配一个整型数组给ot.data，
  52. 										 //用于存储数据包的数据。
  53. 				ot.ch_id = id;
  54. 				foreach(ot.data[i])begin
  55. 					this.in_mbs[id].get(it);//从信箱中取数据，给到it
  56. 					ot.data[i] = it.data;
  57. 				end
  58. 				this.out_mbs[id].put(ot);//将格式化后的事务ot放入到输出mailbox（out_mbs）中
  59. 			end
  60. 		endtask 
  61. 		
  62. 		function int get_field_value(int id, mcdf_field_t f);//mcdf_field_t是18行的枚举类型
  63. 			case(f)
  64. 				RW_LEN  : return regs[id].len  ;//这四个case分别代表什么？
  65. 				RW_PRIO : return regs[id].prio ;
  66. 				RW_EN   : return regs[id].en   ;
  67. 				RD_AVAIL: return regs[id].avail;
  68. 			endcase
  69. 		endfunction
  70. 		
  71. 		task do_reset();
  72. 			forever begin
  73. 				@(negedge intf.rstn);
  74. 				foreach(regs[i])begin
  75. 					regs[i].len  = 'h0;
  76. 					regs[i].prio = 'h3;
  77. 					regs[i].en   = 'h1;//为什么复位信号要给这些值？
  78. 					regs[i].avail= 'h20;//应该还是和task do_reg_update有关
  79. 				end
  80. 			end
  81. 		endtask
  82. 		
  83. 		function void set_interface(virtual mcdf_intf intf);
  84. 			if(intf == null)
  85. 				$error("interface handle is null");
  86. 			else
  87. 				this.intf = intf;
  88. 		endfunction
  89.  
  90. 	endclass

3.3.2 mcdf_checker

将refmod的数据与fmt的数据进行对比

  1. 	class mcdf_checker;
  2. 		local string name;
  3. 		local int err_count;
  4. 		local int total_count;
  5. 		local int chl_count[3];
  6. 		local virtual mcdf_intf intf;
  7. 		local refmod mcdf_refmod;
  8. 		
  9. 		mailbox #(mon_data_t) chnl_mbs[3];
  10. 		mailbox #(fmt_trans) fmt_mb;
  11. 		mailbox #(reg_trans) reg_mb;
  12. 		mailbox #(fmt_trans) exp_mbs[3];
  13. 		
  14. 		function new(string name = "mcdf_checker");
  15. 			this.name = name;
  16. 			foreach(this.chnl_mbs[i]) this.chnl_mbs[i] = new();
  17. 			this.fmt_mb = new();
  18. 			this.reg_mb = new();
  19. 			this.refmod = new();
  20. 			foreach (this.refomd.in_mbs[i])begin
  21. 				this.refmod.in_mbs[i] = this.chnl_mbs[i];
  22. 				this.exp_mbs[i] = this.refmod.out_mbs[i];
  23. 			end
  24. 			this.refmod.reg_mb = this.reg_mb;
  25. 			this.err_count = 0;
  26. 			this.total_count = 0;
  27. 			foreach(this.chnl_count[i]) this.chnl_count[i] = 0;
  28. 		endfunction
  29.  
  30. 		function void set_interface (virtual mcdf_intf intf);
  31. 			if(intf == null)
  32. 				$error("interface handle is null");
  33. 			else
  34. 				this.intf = intf;
  35. 				this.refmod.set_interface(intf);
  36. 		endfunction
  37. 		
  38. 		task run();
  39. 			fork
  40. 				this.do_compare();
  41. 				this.refmod.run();
  42. 			join
  43. 		endtask
  44. 		
  45. 	//比较收集到的数据是否和参考数据一样	
  46. 		task do_compare();
  47. 			fmt_trans expt, mont;
  48. 			bit cmp;
  49. 			forever begin
  50. 				this.fmt_mb.get(mont);//formatter中的数据
  51. 				this.exp_mbs[mont.ch_id].get(expt);//期望的数据
  52. 				cmp = mont.compare(expt);//调用的是fmt_pkg里面的compare函数
  53. 				this.total_count++;//是拿来计数什么的？
  54. 				this.chnl_count[mont.ch_id]++;//是拿来计数什么的？
  55. 				if(cmp == 0)begin//不相等
  56. 					this.err_count++;
  57. 					rpt_pkg::rpt_msg("[CMP FAIL]", $sformatf("%0t %0dth times comparing but failed!MCDF monitored output packet is different with reference model output", $time, this.total_count),
  58. 					rpt_pkg::ERROR,
  59. 					rpt_pkg::TOP,
  60. 					rpt_pkg::LOG);
  61. 				end
  62. 				else begin
  63. 					rpt_pkg::rpt_msg("[CMP SUCD]", $sformatf("%0t %0dth times comparing and succeeded! MCDF monitored output packet is different with reference model output", $time, this.total_count),
  64. 					rpt_pkg::INFO,
  65. 					rpt_pkg::HIGH,
  66. 				end
  67. 			end
  68. 		endtask
  69. 		
  70. 		function void do_report();
  71. 			string s;
  72. 			s = "\n--------------------------------------------\n";
  73. 			s = {s, " CHECKER SUMMARY \n"};
  74. 			s = {s, $sformatf("total comparison count: %0d \n", this.total_count)};
  75. 			foreach (this.chnl_count[i]) begin
  76. 				if(this.chnl_mbs[i].num() != 0 )//判断是否把数据比较完
  77. 				s = {s, $sformatf("WARNING:: chnl_mbs[%0d] is not empty! size = %0d \n", i, this.chnl_mbs[i].num())};	
  78. 			end
  79. 			if(this.fmt_mb.num() != 0)
  80. 				s = {s, $sformatf("WARNING:: fmt_mb is not empty! size = %0d \n", this.fmt_mb.num())};
  81. 			s = "\n--------------------------------------------\n";
  82. 			rpt_pkg::rpt_msg($sformatf("[%s]",this.name), s, rpt_pkg::INFO, rpt_pkg::TOP);
  83. 		endfunction
  84. 	endclass

3.3.3 mcdf_env

用于构建和运行MCDF模块的测试环境

  1. 	class mcdf_env;
  2. 		chnl_agent chnl_agts[3];
  3. 		reg_agent reg_agt;
  4. 		fmt_agent fmt_agt;
  5. 		mcdf_checker chker;
  6. 		mcdf_coverage cvrg;
  7. 		protected string name;
  8. 		
  9. 		function new(string name = "mcdf_env");
  10. 			this.name  = name;
  11. 			this.chker = new();
  12. 			foreach(chnl_agts[i])begin
  13. 				this.chnl_agts[i] = new($sformatf("chnl_agts[%0d]", i));
  14. 				this.chnl_agts[i].monitor.mon_mb = this.chker.chnl_mbs[i];
  15. 			end
  16. 			this.reg_agt = new("reg_agt");
  17. 			this.reg_agt.monitor.mon_mb = this.chker_reg_mb;
  18. 			this.fmt_agt = new("fmt_agt");		
  19. 			this.fmt_agt.monitor.mon_mb = this.chker.fmt.mb;
  20. 			this.cvrg = new();
  21. 			$display("%s instantiated and connected objects", this.name);
  22. 		endfunction
  23. 		
  24. 		virtual task run();
  25. 			$display($sformatf("*****************%s started***********", this.name));
  26. 			this.do_config();
  27. 			fork
  28. 				this.chnl_agts[0].run)();
  29. 				this.chnl_agts[1].run)();
  30. 				this.chnl_agts[2].run)();		
  31. 				this.reg_agt.run)();	
  32. 				this.fmt_agt.run)();
  33. 				this.chker.run();
  34. 				this.cvrg.run();
  35. 			join
  36. 		endtask
  37. 		
  38. 		virtual function void do_config();//之前式用do_config来配置generator。但是
  39. 		endfunction                       //现在将其移植到mcdf_base_test中来进行配置了
  40. 		
  41. 		virtual function void do_report();
  42. 		this.chker.do_report();
  43. 		this.cvrg.do_reporet();
  44. 		endfunction
  45. 	endclass

3.3.4 mcdf_base_test

测试模板

  1. 	class mcdf_base_test;
  2. 		chnl_generator chnl_gens[3];
  3. 		reg_generator reg_gen;
  4. 		fmt_generator fmt_gen;
  5. 		mcdf_env env;
  6. 		protected string name;
  7. 		
  8. 		function new(string name = "mcdf_base_test");
  9. 			this.name = name;
  10. 			this.env = new(env);
  11. 			
  12. 			//将每个gens给到env进行代理
  13. 			foreach(this.chnl_gens[i])begin
  14. 				this.chnl_gens[i] = new();
  15. 				this.env.chnl_agts[i].driver.req_mb = this.chnl_gens[i].req_mb;
  16. 				this.env.chnl_agts[i].driver.rsq_mb = this.chnl_gens[i].rsq_mb;
  17. 			end
  18. 			
  19. 			this.reg_gen = new();
  20. 			this.env.reg_agt.driver.req_mb = this.reg_gen.req_mb;
  21. 			this.env.reg_agt.driver.rsp_mb = this.reg_gen.rsp_mb;
  22. 			
  23. 			this.fmt_gen = new();
  24. 			this.env.fmt_agt.driver.req_mb = this.fmt_gen.req_mb;
  25. 			this.env.fmt_agt.driver.rsp_mb = this.fmt_gen.rsp_mb;
  26. 			
  27. 			$display("%s instantiated and connected objects", this.name);
  28. 		endfunction
  29. 		
  30. 		virtual task run();
  31. 			fork 
  32. 				env.run();
  33. 			join_none
  34. 			rpt_pkg::rpt_msg("[TEST]",
  35. 				$sformatf("===========%s AT TIME 0%t STARTED=======", this.name,$time),
  36. 				rpt_pkg::INFO;
  37. 				rpt_pkg::HIGH);
  38. 			this.do_reg();
  39. 			this.do_formatter();
  40. 			this.do_data();
  41. 			rpt_pkg::rpt_msg("[TEST]",
  42. 				$sformatf("===========%s AT TIME 0%t FINISHED=======", this.name,$time),
  43. 				rpt_pkg::INFO;
  44. 				rpt_pkg::HIGH);
  45. 			this.do_report();
  46. 			$finish();
  47. 		endtask
  48. 		
  49. 		//do register configuration
  50. 		virtual task do_reg();
  51. 		endtask
  52. 		
  53. 		//do external formatter down stream slave configuration
  54. 		virtual task do_formatter();
  55. 		endtask
  56. 		
  57. 		//do data transition from 3 channel slaves
  58. 		virtual task do_data();
  59. 		endtask
  60. 		
  61. 		//do simulation SUMMARY
  62. 		virtual function void do_report();
  63. 			this.env.do_report();
  64. 			rpt_pkg::do_report();
  65. 		endfunction
  66. 		
  67. 		virtual function void set_interface( virtual chnl_intf ch0_vif
  68. 											,virtual chnl_agent ch1_vif
  69. 											,virtual chnl_agent ch2_vif
  70. 											,virtual reg_intf reg_vif
  71. 											,virtual fmt_intf fmt_vif
  72. 											,virtual mcdf_intf mcdf_vif);
  73. 			this.env.chnl_agts[0].set_interface(ch0_vif);
  74. 			this.env.chnl_agts[1].set_interface(ch1_vif);
  75. 			this.env.chnl_agts[2].set_interface(ch2_vif);		
  76. 			this.env.reg_agt.set_interface(reg_vif);
  77. 			this.env.fmt_agt.set_interface(fmt_vif);
  78. 			this.env.chker.set_interface(mcdf_vif);	
  79. 			this.env.cvrg.set_interface('{ch0_vif, ch1_vif, ch2_vif,}, reg_vif, arb_vif, fmt_vif, mcdf_vif);
  80. 		endfunction
  81. 		
  82. 		virtual function bit diff_value(int val1, int val2, string id ="value_compare");
  83. 			if(val1 != val2)begin
  84. 				rpt_pkg::rpt_msg("[CMP ERR]",
  85. 				$sformatf("ERROR! %s val1 %8x != val2 %8x", id, val1, val2),
  86. 				rpt_pkg::ERROR;
  87. 				rpt_pkg::TOP);
  88. 				return 0;
  89. 			end
  90. 			else begin
  91. 				rpt_pkg::rpt_msg("[CMP SUC]",
  92. 				$sformatf("SUCCESS! %s val1 %8x == val2 %8x", id, val1, val2),
  93. 				rpt_pkg::INFO;
  94. 				rpt_pkg::HIGH);
  95. 				return 1;
  96. 			end
  97. 		endfunction
  98. 		
  99. 		virtual task idle_reg();
  100. 			void'(reg_gen.randomize() with {cmd == 'IDLE; addr == 0; data == 0;});
  101. 			reg_gen.start();
  102. 		endtask
  103. 		
  104. 		virtual task write_reg(bit[7:0]addr, bit[31:0] data);
  105. 			void'(reg_gen.randomize() with {cmd == 'WRITE; addr == local::addr; data == local::data;});	
  106. 			reg_gen.start();	
  107. 		endtask			
  108. 			
  109. 		virtual task read_reg(bit[7:0]addr, output bit[31:0] data);
  110. 			void'(reg_gen.randomize() with {cmd == 'READ; addr == local::addr;});	
  111. 			reg_gen.start();	
  112. 			data = reg_gen.data;
  113. 		endtask			
  114. 	endclass

3.3.5 mcdf_data_consistence_basic_test

读写数据一致性检测，检查寄存器读进去和写出来的数据是否一致

  1. 	class mcdf_data_consistence_basic_test extends mcdf_base_test;
  2. 		function new(string name = "mcdf_data_consistence_basic_test");
  3. 			super.new(name);
  4. 		endfunction
  5. 		
  6. 		//检查读写是否一致
  7. 		task do_reg();
  8. 			bit[31:0] wr_val, rd_val;
  9. 			//slv0 with len=8,prior=0,en=1
  10. 			wr_val = (1<<3)+(0<<1)+1;//为什么要这样设置呢
  11. 			this.wrtie_reg('SLV0_RW_ADDR, wr_val);//写进去
  12. 			this.read_reg('SLV0_RW_ADDR, rd_val);//读回来
  13. 			void'(this.diff_value(wr_val, rd_val, "SLV0_WR_REG"));//把写进去的值和读回来的值做一个比较
  14. 																  //看看写进去的值是否合法
  15. 			//slv1 with len=16,prior=1,en=1
  16. 			wr_val = (2<<3)+(1<<1)+1;
  17. 			this.wrtie_reg('SLV1_RW_ADDR, wr_val);
  18. 			this.read_reg('SLV1_RW_ADDR, rd_val);
  19. 			void'(this.diff_value(wr_val, rd_val, "SLV1_WR_REG"));	
  20.  
  21. 			//slv2 with len=32,prior=2,en=1
  22. 			wr_val = (3<<3)+(2<<1)+1;
  23. 			this.wrtie_reg('SLV2_RW_ADDR, wr_val);
  24. 			this.read_reg('SLV2_RW_ADDR, rd_val);
  25. 			void'(this.diff_value(wr_val, rd_val, "SLV2_WR_REG"));
  27. 			//send IDLE command
  28. 			this.idle_reg();
  29. 		endtask 
  30. 		
  31. 		//配置格式化器（fmt_gen）的随机值，包括 FIFO 大小和带宽。
  32. 		task do_formatter();
  33. 			void'(fmt_gen.randomize()with{fifo == LONG_FIFO; bandwidth == HIGH_WIDTH;});
  34. 			fmt_gen.start();
  35. 		endtask
  36. 		
  37. 		//生成数据
  38. 		task do_data();
  39. 			void'(chnl_gens[0].randomize() with {ntrans == 100; ch_id == 0; data_nidles == 0; pkt_nidles == 1; data_size ==  8;});
  40. 			void'(chnl_gens[1].randomize() with {ntrans == 100; ch_id == 1; data_nidles == 1; pkt_nidles == 1; data_size == 16;});
  41. 			void'(chnl_gens[2].randomize() with {ntrans == 100; ch_id == 2; data_nidles == 2; pkt_nidles == 1; data_size == 32;});	
  42. 			fork
  43. 				chnl_gens[0].start();
  44. 				chnl_gens[1].start();
  45. 				chnl_gens[2].start();
  46. 			join
  47. 			#10us;//wait until all data haven been transfered through MCDF
  48. 		endtask
  49. 	endclass

3.3.5 mcdf_reg_write_read_test

寄存器读写测试，包括对控制读写寄存器和状态只读寄存器的测试

  1. 	class mcdf_reg_write_read_test extends mcdf_base_test;
  2. 	
  3. 	
  4. 		function new (string name = "mcdf_reg_write_read_test");
  5. 			super.new(name);
  6. 		endfunction
  7. 		
  8. 		virtual task do_reg();
  9. 			bit [31:0]wr_val, rd_val;
  10. 			bit [7:0] chnl_rw_addrs[] = '{'SLV0_RW_ADDR, 'SLV1_RW_ADDR, 'SLV2_RW_ADDR};//读写寄存器
  11. 			bit [7:0] chnl_ro_addrs[] = '{'SLV0_R_ADDR, 'SLV1_R_ADDR, 'SLV2_R_ADDR};//只读寄存器
  12. 			int pwidth = 'PAC_LEN_WIDTH + 'PRIO_WIDTH + 1;//PAC_LEN_WIDTH是定义在param_def中的常数
  13. 			bit[31:0] check_pattern[] = '{32'h0000_FFC0, 32'hFFFF_0000};//类似于地址检查库
  14. 		
  15. 			foreach (chnl_rw_addrs[i])begin
  16. 				foreach(check_pattern[j])begin
  17. 					wr_val = check_pattern[j];
  18. 					this.write_reg(chnl_rw_addrs[i], wr_val);
  19. 					this.read_reg(chnl_rw_addr[i], rd_val);
  20. 					void'((this.diff_value(wr_val & ((1<<pwidth)-1), rd_val));//为什么,(1<<pwidth)-1=31
  21. 				end//按位与操作。这种掩码结果的二进制形式会有pwidth个低位是1。即保留wr_val的低pwidth位，其余位清零
  22. 			end//如果wr_val是32'h0000_FFC0，且pwidth是5，那么结果是32'h0000_0010。
  23. 			//仅比较有效位（低pwidth位），忽略无关的高位。这在寄存器操作中非常重要，
  24. 			//因为某些寄存器的高位可能是未定义或保留位，比较时应避免这些位的影响。
  25. 			
  26. 			foreach(chnl_ro_addrs[i])begin
  27. 				wr_val = 32'hFFFF_FF00;//由于是只读寄存器，因此写进入的值是确定的
  28. 				this.write_reg(chnl_ro_addrs[i],wr_val);
  29. 				this.read_reg(chnl_ro_addrs[1], rd_val);
  30. 				void'(this.diff_value(0, rd_val & wr_val));//这用于将函数调用的返回值转换为 void，实际上是忽略函数的返回值。
  31. 			end//对于只读寄存器，我们期望写入操作不会改变寄存器的值。
  32. 			//因此，我们预期从只读寄存器读取到的值应该是0（这就是为什么第一个参数是0）。
  33.  
  34. 			
  35. 			this.idle_reg();
  36. 		endtask 
  37. 	endclass

3.3.6 mcdf_reg_illegal_access_tets

寄存器稳定性测试。

  1. 	class mcdf_reg_illegal_access_tets extends mcdf_base_test;
  2. 		function new(string name = "mcdf_reg_illegal_access_tets");
  3. 			super.new(name);
  4. 		endfunction
  5. 		
  6. 		task do_reg();
  7. 			bit [31:0]wr_val, rd_val;
  8. 			bit [7:0] chnl_rw_addrs[] = '{'SLV0_RW_ADDR, 'SLV1_RW_ADDR, 'SLV2_RW_ADDR};
  9. 			bit [7:0] chnl_ro_addrs[] = '{'SLV0_R_ADDR, 'SLV1_R_ADDR, 'SLV2_R_ADDR};
  10. 			int pwidth = 'PAC_LEN_WIDTH + 'PRIO_WIDTH + 1;
  11. 			bit[31:0] check_pattern[] = '{((1<<pwidth)-1), 0, ((1<<pwidth)-1)};	
  12. 			
  13. 			foreach (chnl_rw_addrs[i])begin
  14. 				foreach(check_pattern[j])begin
  15. 					wr_val = check_pattern[j];
  16. 					this.write_reg(chnl_rw_addrs[i],wr_val);
  17. 					this.read_reg(chnl_rw_addrs[i],rd_val);
  18. 					void'(this.diff_value(wr_val, rd_val));
  19. 				end
  20. 			end
  21. 			
  22. 			foreach(chnl_ro_addrs[i])begin
  23. 					this.read_reg(chnl_ro_addrs[i],rd_val);			
  24. 			end
  25. 			
  26. 			this.idle_reg();
  27. 		endtask
  28. 	endclass

3.3.7 mcdf_arbiter_priority_test

arbiter优先级测试

如果各数据通道优先级相同，那么arbiter应该采取轮询机制从各个通道接受数据，如果优先级不同，先从高优先级的通道接收数据

  1. 	class mcdf_arbiter_priority_test extends mcdf_base_test;
  2. 		function new (string name  = "mcdf_arbiter_priority_test");
  3. 			super.new(name) 
  4. 		endfunction 
  5. 		
  6. 		task do_arbiter_priority_check();
  7. 			int id;
  8. 			forever begin
  9. 				@(posedge this.arb_vif.clk iff (this.arb_vif.rstn && this.arb_vif.mon_ck.f2a_id_req===1));
  10. 				id = this.get_slave_id_with_prio();//得到三个slave的最高优先级
  11. 				if(id >= 0) begin
  12. 				@(posedge this.arb_vif.clk);
  13. 				if(this.arb_vif.mon_ck.a2s_acks[id] !== 1)//acks【i】是设计的硬件信号的slvae通道选择
  14. 					rpt_pkg::rpt_msg("[CHKERR]",
  15. 					$sformatf("ERROR! %0t arbiter received f2a_id_req===1 and channel[%0d] raising request with high priority, but is not granted by arbiter", $time, id),
  16. 					rpt_pkg::ERROR,
  17. 					rpt_pkg::TOP);
  18. 				end
  19. 			end
  20. 		endtask
  21. 		
  22. //模拟arbiter仲裁逻辑
  23. 		function int get_slave_id_with_prio();
  24. 			int id=-1;
  25. 			int prio=999;
  26. 			//寻找最高优先级
  27. 			foreach(this.arb_vif.mon_ck.slv_prios[i]) begin
  28. 				if(this.arb_vif.mon_ck.slv_prios[i] < prio && this.arb_vif.mon_ck.slv_reqs[i]===1) begin
  29. 				id = i;
  30. 				prio = this.arb_vif.mon_ck.slv_prios[i];
  31. 				end
  32. 			end
  33. 			return id;
  34. 		endfunction
  35.  
  36.  
  37. 	endclass

3.3.8 mcdf_channel_disbale_test

数据通道开关检测

在数据通道关闭的情况下检测数据写入是否通过

  1. 	class mcdf_channel_disbale_test extends mcdf_base_tese;
  2. 		function new (string name  = "mcdf_channel_disbale_test");
  3. 			super.new(name) 
  4. 		endfunction 		
  5. 	
  6. 		task do_mcdf_channel_disable_test (int id)
  7. 			forever begin 
  8. 				@(posedge this.mcdf_vif.clk iff(this.mcdf_vif.rstn && this.mcdf_vif.mon_ck.chnl_en[id] == 0));
  9. 				if (this.chnl_vifs[id].mon_ck.ch_valid == 1 && this.chnl_vifs[id].mon_ck.ch_ready == 1)
  10. 					rpt_pkg::rpt_msg("[CHECKER]",
  11. 									$sformatf("ERROR! %0t whern channel disabled, ready signal raised while valid signal is high"， $time),
  12. 									rpt_pkg::ERROR,
  13. 									rpt_pkg::TOP);
  14. 			end
  15. 		endtask 
  16. 	
  17. 	endclass

3.3.9 mcdf_coverage

覆盖率收集

  1. 	class mcdf_coverage;
  2. 		local virtual chnl_intf chnl_vifs[3];	
  3. 		local virtual arb_intf arb_vif;
  4. 		local virtual mcdf_intf mcdf_vif;
  5. 		local virtual reg_intf reg_vif;
  6. 		local virtual fmt_intf reg_vif;
  7. 		local string  name;
  8. 		local int     delay_req_to_grant;
  9. 		
  10. 		//对所有控制、状态寄存器的读写进行测试。
  11. 		covergroup cg_mcdf_reg_write_read;
  12. 			addr: coverpoint reg_vif.mon_ck.cmd_addr{
  13. 				type_option.weight = 0;//权重设置为0，表示不关心此coverpoint的覆盖率，否则cross以后会出现很多的bin
  14. 				bins slv0_rw_addr = {'SLV0_RW_ADDR};
  15. 				bins slv1_rw_addr = {'SLV1_RW_ADDR};				
  16. 				bins slv2_rw_addr = {'SLV2_RW_ADDR};				
  17. 				bins slv0_r_addr  = {'SLV0_R_ADDR };				
  18. 				bins slv1_r_addr  = {'SLV1_R_ADDR };				
  19. 				bins slv2_r_addr  = {'SLV2_R_ADDR };				
  20. 			}//8bit地址实际上会生成256个bin，256-6=250会被平均分配到这6个bin中，
  21.              //但默认max为64个bin，所以剩下的250要分配到64-6=58个bin里面
  22. 			//建议如果要做cross，那需要被cross的这些功能点都weight=0，然后在cross中重新bin
  23. 			cmd: coverpoint reg_vif.mon_ck.cmd{
  24. 				type_option.weight = 0;
  25. 				bins write = {'WRITE};
  26. 				bins read  = {'READ};
  27. 				bins idle  = {'IDLE};
  28. 			}//cmd是2bit的，所以还有一个默认的bin
  29. 			
  30. 			cmdXaddr: cross cmd, addr{
  31. 				bins slv0_rw_addr       = binsof (addr.slv0_rw_addr);
  32. 				bins slv1_rw_addr       = binsof (addr.slv1_rw_addr);				
  33. 				bins slv2_rw_addr       = binsof (addr.slv2_rw_addr);				
  34. 				bins slv0_r_addr        = binsof (addr.slv0_r_addr );				
  35. 				bins slv1_r_addr        = binsof (addr.slv1_r_addr );					
  36. 				bins slv2_r_addr        = binsof (addr.slv2_r_addr );					
  37. 				bins write              = (cmd.write);				
  38. 				bins read               = (cmd.read );				
  39. 				bins idle               = (cmd.idle );			
  40. 				//因为之前设置权重为0，所以需要再一次的声明，这样可以只关心所需要的bin即可，不会生成没用的bin				
  41. 				bins write_slv0_rw_addr = binsof (cmd.write) && binsof (addr.slv0_rw_addr);		  	
  42. 				bins write_slv1_rw_addr = binsof (cmd.write) && binsof (addr.slv1_rw_addr);			
  43. 				bins write_slv2_rw_addr = binsof (cmd.write) && binsof (addr.slv2_rw_addr);			
  44. 				bins read_slv0_rw_addr  = binsof (cmd.read ) && binsof (addr.slv0_rw_addr);				
  45. 				bins read_slv1_rw_addr  = binsof (cmd.read ) && binsof (addr.slv1_rw_addr);				
  46. 				bins read_slv2_rw_addr  = binsof (cmd.read ) && binsof (addr.slv2_rw_addr);			
  47. 				bins read_slv0_r_addr   = binsof (cmd.read ) && binsof (addr.slv0_r_addr );				
  48. 				bins read_slv1_r_addr   = binsof (cmd.read ) && binsof (addr.slv1_r_addr );				
  49. 				bins read_slv2_r_addr   = binsof (cmd.read ) && binsof (addr.slv2_r_addr );				
  50. 			}
  51. 		endgroup
  53. 		//对非法地址进行读写测试，对控制寄存器的保留域进行读写测试，对状态寄存器进行写操作测试。
  54. 		covergroup cg_mcdf_reg_illegal_access;
  55. 			addr: coverpoint reg_vif.mon_ck.cmd_addr {
  56. 				type_option.weight = 0;
  57. 				bins legal_rw = {`SLV0_RW_ADDR, `SLV1_RW_ADDR, `SLV2_RW_ADDR};//合法读写寄存器地址
  58. 				bins legal_r  = {`SLV0_R_ADDR, `SLV1_R_ADDR, `SLV2_R_ADDR};   //合法读地址范围
  59. 				/*这里做了一些简化，这里对任意一个通道的读写寄存器进行了操作就满足覆盖率要求*/
  60. 				/**但是实际上如果要对每一个通道的寄存器都进行覆盖率检测，那应该写为数组形式*/
  61. 				/*bins legal_rw[] = {`SLV0_RW_ADDR, `SLV1_RW_ADDR, `SLV2_RW_ADDR};
  62. 				  bins legal_r[]  = {`SLV0_R_ADDR, `SLV1_R_ADDR, `SLV2_R_ADDR};   */			
  63. 				bins illegal  = {[8'h20:$], 8'hC, 8'h1C};				      //非法地址范围
  64. 			}
  65. 			cmd: coverpoint reg_vif.mon_ck.cmd {
  66. 				type_option.weight = 0;
  67. 				bins write = {`WRITE};
  68. 				bins read  = {`READ};
  69. 			}
  70. 			//写数据覆盖点
  71. 			wdata: coverpoint reg_vif.mon_ck.cmd_data_m2s {
  72. 				type_option.weight = 0;
  73. 				//数据合法范围，0~111111，即bit(0)使能信号、bit(2:1)优先级、bit(5:3)数据包长度都可以写
  74. 				bins legal = {[0:'h3F]};
  75. 				//数据非法范围，bit(31:6)保留位，无法写入
  76. 				bins illegal = {['h40:$]};
  77. 			}
  78. 			//读数据覆盖点
  79. 			rdata: coverpoint reg_vif.mon_ck.cmd_data_s2m {
  80. 				type_option.weight = 0;
  81. 				//读数据合法范围，0~11111111，即bit(7:0)上行数据从端FIFO的可写余量
  82. 				bins legal = {[0:'hFF]};
  83. 				illegal_bins illegal = default;
  84. 			}
  85. 			//交叉覆盖
  86. 			cmdXaddrXdata: cross cmd, addr, wdata, rdata {
  87. 				bins addr_legal_rw         = binsof(addr.legal_rw);
  88. 				bins addr_legal_r          = binsof(addr.legal_r);
  89. 				bins addr_illegal          = binsof(addr.illegal);
  90. 				bins cmd_write             = binsof(cmd.write);
  91. 				bins cmd_read              = binsof(cmd.read);
  92. 				bins wdata_legal           = binsof(wdata.legal);
  93. 				bins wdata_illegal         = binsof(wdata.illegal);
  94. 				bins rdata_legal           = binsof(rdata.legal);
  95. 				bins write_illegal_addr    = binsof(cmd.write) && binsof(addr.illegal);//对非法地址进行写操作
  96. 				bins read_illegal_addr     = binsof(cmd.read)  && binsof(addr.illegal);//对非法地址进行写操作
  97. 				bins write_illegal_rw_data = binsof(cmd.write) && binsof(addr.legal_rw) && binsof(wdata.illegal);//对读写寄存器合法地址写入非法数据
  98. 				bins write_illegal_r_data  = binsof(cmd.write) && binsof(addr.legal_r)  && binsof(wdata.illegal);//对只读寄存器合法地址写入非法数据
  99. 			}
  100. 		endgroup
  101. 		
  102. 	    //对每一个数据通道对应的控制寄存器域en配置为0，在关闭状态下测试数据写入是否通过。
  103. 		covergroup cg_channel_disable;
  104. 			ch0_en: coverpoint mcdf_vif.mon_ck.chnl_en[0] {
  105. 				type_option.weight = 0;
  106. 				wildcard bins en  = {1'b1};//这里为什么要用wildcard来修饰
  107. 				wildcard bins dis = {1'b0};
  108. 				//wildcard修饰符用于位宽不定的信号，它使得值的匹配忽略位数上的差异。
  109. 				//具体来说，wildcard可以用来简化匹配条件，特别是在信号中有不关心的位时
  110. 				//wildcard可以让表达式中的任何x、z或?被当作0或1的通配符
  111. 			}
  112. 			ch1_en: coverpoint mcdf_vif.mon_ck.chnl_en[1] {
  113. 				type_option.weight = 0;
  114. 				wildcard bins en  = {1'b1};//对应使能
  115. 				wildcard bins dis = {1'b0};//对于禁用
  116. 			}
  117. 			ch2_en: coverpoint mcdf_vif.mon_ck.chnl_en[2] {
  118. 				type_option.weight = 0;
  119. 				wildcard bins en  = {1'b1};
  120. 				wildcard bins dis = {1'b0};
  121. 			}
  122. 			ch0_vld: coverpoint chnl_vifs[0].mon_ck.ch_valid {
  123. 				type_option.weight = 0;
  124. 				bins hi = {1'b1};
  125. 				bins lo = {1'b0};
  126. 			}
  127. 			ch1_vld: coverpoint chnl_vifs[1].mon_ck.ch_valid {
  128. 				type_option.weight = 0;
  129. 				bins hi = {1'b1};
  130. 				bins lo = {1'b0};
  131. 			}
  132. 			ch2_vld: coverpoint chnl_vifs[2].mon_ck.ch_valid {
  133. 				type_option.weight = 0;
  134. 				bins hi = {1'b1};
  135. 				bins lo = {1'b0};
  136. 			}
  137. 			//采集当valid拉高时，代表要进行写操作，en拉低代表数据通道关闭
  138. 			chenXchvld: cross ch0_en, ch1_en, ch2_en, ch0_vld, ch1_vld, ch2_vld {
  139. 				bins ch0_en      = binsof(ch0_en.en );
  140. 				bins ch0_dis     = binsof(ch0_en.dis);
  141. 				bins ch1_en      = binsof(ch1_en.en );
  142. 				bins ch1_dis     = binsof(ch1_en.dis);
  143. 				bins ch2_en      = binsof(ch2_en.en );
  144. 				bins ch2_dis     = binsof(ch2_en.dis);
  145. 				bins ch0_hi      = binsof(ch0_vld.hi);
  146. 				bins ch0_lo      = binsof(ch0_vld.lo);
  147. 				bins ch1_hi      = binsof(ch1_vld.hi);
  148. 				bins ch1_lo      = binsof(ch1_vld.lo);
  149. 				bins ch2_hi      = binsof(ch2_vld.hi);
  150. 				bins ch2_lo      = binsof(ch2_vld.lo);
  151. 				bins ch0_en_vld  = binsof(ch0_en.en ) && binsof(ch0_vld.hi);
  152. 				bins ch0_dis_vld = binsof(ch0_en.dis) && binsof(ch0_vld.hi);
  153. 				bins ch1_en_vld  = binsof(ch1_en.en ) && binsof(ch1_vld.hi);
  154. 				bins ch1_dis_vld = binsof(ch1_en.dis) && binsof(ch1_vld.hi);
  155. 				bins ch2_en_vld  = binsof(ch2_en.en ) && binsof(ch2_vld.hi);
  156. 				bins ch2_dis_vld = binsof(ch2_en.dis) && binsof(ch2_vld.hi);
  157. 			}
  158. 		endgroup
  159. 		
  160. 		//将不同数据通道配置为相同或者不同的优先级，在数据通道使能的情况下进行测试。
  161. 		covergroup cg_arbiter_priority;
  162. 			ch0_prio: coverpoint arb_vif.mon_ck.slv_prios[0] {
  163. 				bins ch_prio0 = {0}; 
  164. 				bins ch_prio1 = {1}; 
  165. 				bins ch_prio2 = {2}; 
  166. 				bins ch_prio3 = {3}; //为什么会有4个优先级呢
  167. 			}
  168. 			ch1_prio: coverpoint arb_vif.mon_ck.slv_prios[1] {
  169. 				bins ch_prio0 = {0}; 
  170. 				bins ch_prio1 = {1}; 
  171. 				bins ch_prio2 = {2}; 
  172. 				bins ch_prio3 = {3}; 
  173. 			}
  174. 			ch2_prio: coverpoint arb_vif.mon_ck.slv_prios[2] {
  175. 				bins ch_prio0 = {0}; 
  176. 				bins ch_prio1 = {1}; 
  177. 				bins ch_prio2 = {2}; 
  178. 				bins ch_prio3 = {3}; 
  179. 			}
  180. 			endgroup
  181. 		
  182. 		//测试从formatter发送出来的数据包长度是否同对应通道寄存器的配置一致
  183. 		covergroup cg_formatter_length;
  184. 			id: coverpoint fmt_vif.mon_ck.fmt_chid {
  185. 				bins ch0 = {0};
  186. 				bins ch1 = {1};
  187. 				bins ch2 = {2};
  188. 				illegal_bins illegal = default; 
  189. 			}
  190. 			length: coverpoint fmt_vif.mon_ck.fmt_length {
  191. 				bins len4  = {4};
  192. 				bins len8  = {8};
  193. 				bins len16 = {16};
  194. 				bins len32 = {32};
  195. 				illegal_bins illegal = default;
  196. 			}
  197. 		endgroup
  198. 	
  199. 		//在req拉高以后，grant至少应该在2个时钟周期后拉高，以此来模拟下行从端数据余量不足的情况
  200. 		covergroup cg_formatter_grant();
  201. 			delay_req_to_grant: coverpoint this.delay_req_to_grant {
  202. 				bins delay1 = {1};// delay_req_to_grant是一个自定义的软件信号，在task do_formater_sample()中被定义
  203. 				bins delay2 = {2};//数字代表req与grant信号之间延迟的拍数字
  204. 				bins delay3_or_more = {[3:10]};
  205. 				illegal_bins illegal = {0};//req与grant信号之间没有延迟则非法
  206. 			}
  207. 			endgroup
  208. 		
  209. 		function new(string name="mcdf_coverage");
  210. 			this.name = name;
  211. 			this.cg_mcdf_reg_write_read     = new();
  212. 			this.cg_mcdf_reg_illegal_access = new();
  213. 			this.cg_channel_disable         = new();
  214. 			this.cg_arbiter_priority        = new();
  215. 			this.cg_formatter_length        = new();
  216. 			this.cg_formatter_grant         = new();
  217. 		endfunction
  218. 		
  219. 		task run();
  220. 			fork 
  221. 				this.do_reg_sample();
  222. 				this.do_channel_sample();
  223. 				this.do_arbiter_sample();
  224. 				this.do_formater_sample();
  225. 			join
  226. 		endtask
  227. 		
  228. 		//寄存器采样
  229. 		task do_reg_sample();
  230. 			forever begin
  231. 				@(posedge reg_vif.clk iff reg_vif.rstn);
  232. 				this.cg_mcdf_reg_write_read.sample();
  233. 				this.cg_mcdf_reg_illegal_access.sample();
  234. 			end
  235. 		endtask
  236. 		
  237. 		//数据通道采样
  238. 		task do_channel_sample();
  239. 			forever begin对于每一个时钟上升沿，至少有一个channel的valid信号为1时，即有数据发送进来时，才对disable做采样
  240. 				@(posedge mcdf_vif.clk iff mcdf_vif.rstn);
  241. 				if(chnl_vifs[0].mon_ck.ch_valid===1
  242. 				|| chnl_vifs[1].mon_ck.ch_valid===1
  243. 				|| chnl_vifs[2].mon_ck.ch_valid===1)
  244. 				this.cg_channel_disable.sample();
  245. 			end
  246. 		endtask
  247. 		
  248. 		//对优先级做采样
  249. 		task do_arbiter_sample();
  250. 			forever begin对于每一个时钟的上升沿，至少有一个channel的req为1，即至少有一个channel要发送数据了，才对其优先级做采样
  251. 				@(posedge arb_vif.clk iff arb_vif.rstn);
  252. 				if(arb_vif.slv_reqs[0]!==0 || arb_vif.slv_reqs[1]!==0 || arb_vif.slv_reqs[2]!==0)
  253. 				this.cg_arbiter_priority.sample();
  254. 			end
  255. 		endtask
  256. 		
  257. 		//对grant信号做采样
  258. 		task do_formater_sample();
  259. 			fork
  260. 				forever begin//对于每一个时钟上升沿，当req为1时，对数据的长度做采样
  261. 					@(posedge fmt_vif.clk iff fmt_vif.rstn);
  262. 					if(fmt_vif.mon_ck.fmt_req === 1)
  263. 						this.cg_formatter_length.sample();
  264. 				end
  265. 				forever begin
  266. 				//当req拉高时，要通过变量delay_req_to_grant来计算延迟，对grant做采样
  267. 					@(posedge fmt_vif.mon_ck.fmt_req);
  268. 					this.delay_req_to_grant = 0;/*req信号与grant信号之间的延迟*/
  269. 					forever begin//只有grant拉高时，才对grant做采样，进而通过delay_req_to_grant的值得到延迟
  270. 						if(fmt_vif.fmt_grant === 1) begin
  271. 							this.cg_formatter_grant.sample();
  272. 							break;/*当fmt_vif.mon_ck.fmt_req信号和fmt_vif.fmt_grant信号都被拉高时，delay_req_to_grant为0，此时为非法状态，被采样*/
  273. 						end
  274. 						else begin
  275. 							@(posedge fmt_vif.clk);
  276. 							this.delay_req_to_grant++;/*每经过一拍，delay_req_to_grant加1*/
  277. 						end
  278. 					end
  279. 				end
  280. 			join
  281. 		endtask
  282. 	
  283. 		function void do_report();
  284. 			string s;
  285. 			s = "\n---------------------------------------------------------------\n";
  286. 			s = {s, "COVERAGE SUMMARY \n"}; 
  287. 			s = {s, $sformatf("  total coverage: %.1f \n", $get_coverage())}; //$get_coverage可以得到总体的全局覆盖率
  288. 			s = {s, $sformatf("  cg_mcdf_reg_write_read coverage: %.1f \n"    , this.cg_mcdf_reg_write_read.get_coverage())}; //get_coverage获取单个covergroup实例的覆盖率
  289. 			s = {s, $sformatf("  cg_mcdf_reg_illegal_access coverage: %.1f \n", this.cg_mcdf_reg_illegal_access.get_coverage())}; 
  290. 			s = {s, $sformatf("  cg_channel_disable_test coverage: %.1f \n"   , this.cg_channel_disable.get_coverage())}; 
  291. 			s = {s, $sformatf("  cg_arbiter_priority_test coverage: %.1f \n"  , this.cg_arbiter_priority.get_coverage())}; 
  292. 			s = {s, $sformatf("  cg_formatter_length_test coverage: %.1f \n"  , this.cg_formatter_length.get_coverage())}; 
  293. 			s = {s, $sformatf("  cg_formatter_grant_test coverage: %.1f \n"   , this.cg_formatter_grant.get_coverage())}; 
  294. 			s = {s, "---------------------------------------------------------------\n"};
  295. 			rpt_pkg::rpt_msg($sformatf("[%s]",this.name), s, rpt_pkg::INFO, rpt_pkg::TOP);
  296. 		endfunction
  297. 	
  298. 		virtual function void set_interface(virtual chnl_intf ch_vifs[3] 
  299. 											,virtual reg_intf reg_vif
  300. 											,virtual arb_intf arb_vif
  301. 											,virtual fmt_intf fmt_vif
  302. 											,virtual mcdf_intf mcdf_vif
  303. 										);
  304. 			this.chnl_vifs  = ch_vifs;
  305. 			this.arb_vif    = arb_vif;
  306. 			this.reg_vif    = reg_vif;
  307. 			this.fmt_vif    = fmt_vif;
  308. 			this.mcdf_vif   = mcdf_vif;
  309. 			if(chnl_vifs[0] == null || chnl_vifs[1] == null || chnl_vifs[2] == null)
  310. 				$error("chnl interface handle is NULL, please check if target interface has been intantiated");
  311. 			if(arb_vif == null)
  312. 				$error("arb interface handle is NULL, please check if target interface has been intantiated");
  313. 			if(reg_vif == null)
  314. 				$error("reg interface handle is NULL, please check if target interface has been intantiated");
  315. 			if(fmt_vif == null)
  316. 				$error("fmt interface handle is NULL, please check if target interface has been intantiated");
  317. 			if(mcdf_vif == null)
  318. 				$error("mcdf interface handle is NULL, please check if target interface has been intantiated");
  319. 		endfunction
  320. 	endclass

04 覆盖率收集

运行完这几个test之后，得到覆盖率收集表如下

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/666548
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号