为何需要随机?

芯片体积增大,复杂度越来越高,定向测试已无法满足验证的需求,而 随机测试的比例逐渐提高

  • 定向测试能找到 认为可能存在 的缺陷,随机测试可以找到 意想不到 的缺陷;
  • 随机测试的环境要求比定向测试复杂,需要 激励、参考模型、在线比较
  • 随机测试相对定向测试可以减少很多代码量,产生的激励较定向测试也更多样。(减少测试用例的代码量,更多的复用,但验证环境的结果增多了)

为何需要约束?

如果没有约束,产生 有效 激励的同时也产生很多 无效和非法 的激励;

  • 随机自由是一种合法的随机,需要限定激励的合法范围;
  • 随机的对象不只是一个数据,而是 有联系的变量集 。通常这些变量被封装在一个数据类中,同时需要在类中声明数据之间的约束关系。因此约束之后要产生随机数据需一个“ 求解器 ”,即在 满足数据本身和数据之间约束关系时的随机数值解
  • 约束不但可以指定数据的 取值范围 ,还可以指定 各个数值的随机权重分布

需要随机什么?

器件配置 :通过 寄存器和系统信号

  • 环境配置 随机化验证环境 ,例如合理的时钟和外部反馈信号;
  • 原始输入数据 :例如MCDF数据包的长度、带宽,数据间的顺序;
  • 延时 握手信号之间的时序关系 ,如valid和ready,req和ack之间的时序关系;
  • 协议异常 :如果反馈信号给出异常,设计是否可以 保持后续数据处理的稳定性

在随机测试中,可以随机化下列哪些要素? 答案:AC
A、 设计的功能配置 ;B、 设计的结构 ;C、输入数据;D、输出数据

设计的结构是 静态的 ,在编译时确定;验证的结构是 动态的 ,发生在仿真阶段。

声明随机变量的类

随机化是为了产生更多可能的驱动,将相关数据有机整理在一个 中,使用 rand 关键词表明变量的随机属性。

  • randc 表示 周期随机性 ,即 所有可能的值都赋过值后随机值才可以重复
  • 随机属性需要配合SV预定义的类随机函数 std::randomize() 使用;
  • 约束 constraint 也同随机变量一起在 中声明。
class Packet;
	//The random variables
	rand bit [31:0] src, dst, data[8];
	randc bit [7:0] kind;
	// Limit the value for src
	constraint c {
                   src > 10;
                   src < 15;
endclass
Packet P;
initial begin
	P = new(); //Create a packet
	assert (Packet.randomize())
		else $fatal(0,"Packet::randomize failed");
	transmit(P);
end  //需要随机的变量有4个,只要其中一个约束有问题,那么所有变量都没有进行随机

什么是约束?

约束表达式的求解由SV的约束求解器完成。

  • 求解器能够选择满足约束的值,这个值是由SV的PRNG(伪随机数发生器)从一个初始值seed产生。只要改变种子的值,就可以改变CRT的行为。
  • SV标准定义了表达式的含义及产生的合法值,但没有规定求解器计算约束的准确顺序,即不同仿真器对同一个约束类和种子值求解的数值可能不相同
  • SV只能随机化二值数据类型,无法随机化出X值和Z值,也无法随机化字符串。
class data;
	rand bit [2:0] month;
	rand bit [4:0] day;
	rand int year;
	constraint c_data {
		month inside {[1:12]};
		day inside {[1:31]};
		year inside {[2010:2030]};
endclass  //注意位数的限制,比如month只有三位只能随机0-7
class Stim;
	const bit [31:0] CONGEST_ADDR = 42; //定义常量
	typedef enum {READ,WRITE,CONTROL} stim_e; //自定义枚举类型,stim_e类型名
	randc stim_e kind;    //Enumerated var
	rand bit [31:0] len,src,dst;  //随机变量
	bit congestion_test; //非随机变量
	constraint c_stim{
		len < 1000;
		len > 0;
		if (congestion_test){
			dst inside {[CONGEST_ADDR + 100 : CONGEST_ADDR - 100]};
			src == CONGEST_ADDR;
		src inside {0,[2:10],[100:107]};
endclass

关键词dist可以在约束中用来产生随机数值的权重分布

  • dist操作符带有一个值的列表以及相应的权重,中间用:=:/分开。值或权重可以是常数或变量
  • 权重不用百分比表示,权重的和也不必是100
  • := 操作符表示值范围内的每一个值得权重是相同的,:/操作符表示权重平均分到值范围内的每一个值。
rand int scr,dst;
constraint c_dist{
	src dist {0:=40,[1:3]:=60};// :=的意思是产生40个0,1-3每个数产生60个,共产生220个数
        //src = 0,weight(权重) = 40/220
        //src = 1,weight(权重) = 60/220
        //src = 2,weight(权重) = 60/220
        //src = 3,weight(权重) = 60/220
	dst dist (0:/40,[1:3]:/60);// :/的意思是0的概率是40%,1-3的概率一共是60%
        //dst = 0,weight(权重) = 40/100
        //dst = 1,weight(权重) = 20/100
        //dst = 2,weight(权重) = 20/100
        //dst = 3,weight(权重) = 20/100
  • inside是常见的约束运算符,表示变量应属于某些值的集合,除非还存在其他约束,否则随机变量在集合里面取值的概率是相等的,集合里面也可使用变量。例如c inside {[low:high]}; //low<=c && c<=high
  • 使用$指定最大值和最小值,例如c inside {[$:4],[20:$]}; //0<=c<=4 || 20<=c<=63(因为rand bit [5:0] c ; // 0<=c<=63)

条件约束:可以通过 “->”或if-else让一个约束表达式在特定时刻有效。

  • 约束块不是自上向下的程序性代码,而是声明性的代码,是并行的,所有的约束表达式同时有效
  • 约束也是双向的,这表示会同时计算所有随机变量的约束,增加或删除任一变量的约束都会直接或间接影响所有相关值的选取。

约束块控制

打开或关闭约束

一个类可包含多个约束块,可以把不同约束块用于不同测试;

  • 各个约束块之间的约束内容是互相协调不违背的;
  • 使用内建的constraint_mode()函数可以根据不同需要打开或关闭约束;
  • p.constraint_mode(0)是关闭约束,p.constraint_mode(1)是打开约束。
class Packet;
	rand int length;
	constraint c_short {length inside {[1:32]};}
	constraint c_long {length inside {[1000:1023]};}
endclass
Packet p;
initial begin
	p = new(); //创建一个long packet通过禁止短约束块
	p.c_short.constraint_mode(0);//关闭short packet,只有long_packet约束有效
	assert (p.randomize());
	transmit(p);
	//创建一个short packet通过禁止所有约束然后只使能短约束块
	p.constraint_mode(0);//long和short的约束都失效
	p.c_short.constraint_mode(1);//打开short的约束
	transmit(p);
//如果随机化该对象时不禁止其中任何一个约束块,那么调用随机函数randomize()后,
//p.length的值为0也会报错,因为约束冲突导致randomize失败有warning返回默认值0。

约束块之间会相互作用,最终产生难以预测的结果,使能和禁止这些约束的代码也会增加测试的复杂性;

  • 约束需要考虑类的开放封闭原则
  • SV允许使用randomize() with增加额外的约束,和在类里增加约束是等效的,但同时要注意内部约束和外部约束之间应协调,如果出现互相违背的情况,那么随机数值求解会失败;
  • 关键字soft是修饰软约束,当与其它外部约束冲突时软约束优先级会更低
class Transaction;
	rand bit [31:0] addr,data;
	constraint c1 {soft addr inside {[0:100],[1000:2000]};}
endclass
Transaction t;
initial begin
	t= new();
	assert(t.randomize() with {addr >= 50; addr <= 1500; data < 10;});
	driveBus(t);
  //force addr to a specific value,data>10
    assert(t.randomize() with {addr == 2000; data > 10;});
    driverBus(t);

如果加上t.randomize() with {addr inside [200:300]; data inside [10:20]; },若没有关键词soft,addr的约束和内嵌矛盾,addr约束不满足,addr和data都会报错。但因为有soft,减低了约束的优先级,使得内嵌约束起作用。

pre_randomize()和post_randomize()函数

  • 两个预定义的void类型函数pre_randomize()和post_randomize()函数,可看作randomize()函数的回调函数。用户可在类中定义这两个函数,分别在其中定义随机化前的行为和随机化后的行为

随机数函数:SV提供一些常用的系统随机函数。这些随机函数可直接调用来返回随机数值(不通过class,直接调用)。

  • $random()平均分布,返回32位符号随机数;
  • $urandom()平均分布,返回32位符号随机数;
  • $urandom_range(A,B)在指定范围内的平均分布。

随机化个别变量

  • 在调用randomize()时可以在括号里定义个别变量;
  • 只有在括号里的变量才会被随机化,其他变量被当做状态变量而不会被随机化;
  • 所有约束仍然保持有效
  • 类里所有被指定或没有指定rand的变量都可作为randomize()的参数而被随机化;
  • randomize的参数若不是之前定义的rand变量,则类的rand变量不会被随机化。
class Rising;
	byte low, //非随机变量,初始值为0
	rand byte med,hi; //随机变量,初始值为0
	constraint up {low < med; med < hi;}
endclass
initial begin
	Rising r;
	r = new();
	r.randomize();//随机化med,hi,但不改变low,此时low=0,假设med=5,hi=9	 
    //先整体的randomize产生合理的low,med和hi值
	r.randomize(med); //只随机化med;此时low=0,hi=9,med可以是1-8,假设med=6
	r.randomize(low);//只随机化low;此时med=6,hi=9,low可以是0-5,假设low=3
//在例化r之后如果先调用r.randomize(low),那么可能产生low=报错,med=0,hi=0;
//因为med和hi不参与randomize,保持为0

在约束随机标量的同时,也可以对随机化数组进行约束。

class dyn_size;
	rand logic[31:0] d[];
	constraint d_size {d.size() inside {[1:10]}; }
endclass

数组的属性约束

数组的大小应该给定范围,防止生成过大体积的数组或空数组;

  • 可在约束中结合数组的各种方法sum()product()and()or()xor()
  • SV可利用foreach对数组的每个元素进行约束,和直接写对固定大小数组的每个元素的约束相比更简洁;
  • 针对动态数组,foreach更适合于对非固定大小数组中每个元素的约束。

如果要产生一个随机数组,其每个元素的值唯一,可使用双循环嵌套
如果直接使用randc数组,那么数组中的每个元素只会独立地随机化,并不会按照本意使得数组中的元素值唯一。

class UniqueSlow;
	rand bit[7:0] ua[64];
	constraint c{
		foreach(ua[i])  //对数组中的每个元素操作
			foreach(ua[j])
				if(i != j) //除了元素自己
					ua[i] != ua[j];  //和其他元素比较
endclass

可使用randc变量辅助生成唯一元素的数组。

class randc8;
	randc bit[7:0] val;
endclass
class LittleUniqueArray;
	bit[7:0] ua[64];
	function void pre_randomize();
		randc8 rc8;
		rc8 = new();  
		//此句若放在foreach里,则不断创建新对象,跟用rand声明val无区别
		foreach(ua[i]) begin
			assert(rc8.randomize());  
			//若调用LittleUniqueArray.randomize(),
			//则只执行该类的pre_randomize(),故ua数组得不到rc8随机化的数值
			ua[i] = rc8.val;
	endfunction
endclass
class packet;
	rand bit [3:0] da[];  
	//该动态数组不需要例化,因为添加了rand
	//后面randomize后会帮助创建、例化、填充这些元素
	constraint da {
			da.size() inside {[3:5]};
			foreach(da[i]) 
				da[i] <= da[i + 1];
endclass
packet p;
initial begin
	p = new();
	p.randomize() with {da.size() inside {3,5};};
//一开始约束size为3-5,后来进行了独立约束size为3或5。
//但foreach(da[i]) da[i] <= da[i + 1];时没有限制i的取值,i=5时,i的范围时[0:4]。
//da[4]<=da[5](对应第六个元素)超出了范围,所以约束有冲突,随机化失败会报错
//解决办法:在foreach(da[i])后加上if(i<=da.size()-2)

随机化句柄数组

  • 随机化句柄数组的功能是在调用其所在类的随机函数时,随机函数会随机化数组的每个句柄所指定的对象。因此随机句柄数组的声明要添加rand表示其随机化的属性,同时在调用随机函数前要保证句柄数组中的每个句柄元素都非悬空,需要在随机化前为每个元素句柄构建对象
  • 如果要产生多个随机对象,则可能需要建立随机句柄数组。需要在随机化前分配所有元素,因为随机求解器不会创建对象。使用动态数组可按需分配最大数量的元素,然后再使用约束减小数组的大小。随机化时,动态句柄数组的大小可保持不变或减小,但不能增加
parameter MAX_SIZE = 10;
class RandStuff;
	bit [1:0] value = 1;
endclass
class RandArray;
	rand RandStuff array[];
	constraint c{
		array.size() inside {[1:MAX_SIZE]};
	function new();
		//分配最大容量
		array = new [MAX_SIZE];
		foreach (array[i])
			array[i] = new(); //每次创建均为RandStuff创建后的值,即为value=1
	endfunction
endclass
RandArray ra;
initial begin
	//构造数组和所有对象
	ra = new();
	//约束数组的数量为两个
	assert(ra.randomize()with {array.size == 2});
	foreach (ra.array[i])
		$display(ra.array[i].value);

随机序列:产生事务序列的另一个方法是使用SV的randsequence结构,这对于随机安排组织原子测试序列很有帮助。

initial begin
	for(int i = 0; i < 15; i++) begin
		randsequence(stream)
			stream: cfg_read := 1 | 		//权重分布
					io_read  := 2 | 
					mem_read := 5;
			cfg_read : {cfg_read_task;} | 
					   {cfg_read_task;} cfg_read;  //1/8
			io_read :  {io_read_task;} | 
					   {io_read_task;}  io_read;  //2/8
			mem_read : {mem_read_task;} | 
					   {mem_read_task;} mem_read;  //5/8
		endsequence

可以使用randcase建立随机决策树,但没有变量可供追踪调试。

initial begin
	int len;
	randcase
		1: len = $urandom_range(0,2);		// 10% : 0,1,2
		8: len = $urandom_range(3,5);		// 80% : 3,4,OR 5
		1: len = $urandom_range(6,7);		// 10% : 6 OR 7
	endcase
	$display("len=%0d", len);

randsequence和randcase是针对轻量级的随机控制的应用,可通过定义随机类取代上述随机控制的功能,且由于类的继承性使得在后期维护代码更方便。randsequence的相关功能在协调激励组件和测试用例时可能会用到,而randcase对应随机约束中的dist权重约束和if-else条件约束的组合

目录随机约束和分布为何需要随机?为何需要约束?需要随机什么?声明随机变量的类什么是约束?权重分布约束块控制打开或关闭约束内嵌约束随机函数数组约束数组的属性约束随机化句柄数组随机控制随机约束和分布为何需要随机?芯片体积增大,复杂度越来越高,定向测试已无法满足验证的需求,而随机测试的比例逐渐提高;定向测试能找到认为可能存在的缺陷,随机测试可以找到意想不到的缺陷;随机测试的环境要求比定向测试复杂,需要激励、参考模型、在线比较;随机测试相对定向测试可以减少很多代码量,产生的激励较定向测试也更多样。
SV学习(8)——随机约束分布1. 随即约束分布1.1. 为什么需要随机?1.2. 要随机做什么?1.3. 声明随机变量的类1.4. 什么是约束1.5. 权重分布1.6. 集合成员和inside运算符1.7. 条件约束1.8. 双向约束2. 约束块控制2.1. 打开或关闭约束2.2. 内嵌约束 1. 随即约束分布 1.1. 为什么需要随机? 芯片体积增大,复杂度日渐提高,传统定向测试已经无法满足验证的需求,而随机测试的比例逐渐提高; 定向测试能找到你认为可能存在缺陷,而随机测试可以找到连你都没想想到
Verible项目的主要任务是为包括开发人员工具在内的各种应用程序解析SystemVerilog(IEEE 1800-2017)(在进行了标准化)。 它源于解析未经预处理的源文件的需要,该文件适用于样式文件和格式设置等单文件应用程序。 这样,它可以适合于解析预处理的源文件,这是真正的编译器和工具链所需要的。 该项目的精神是,没有人应该为自己的应用程序开发SystemVerilog解析器,因为由于语言的语法复杂性,开发符合标准的解析器是一项艰巨的任务。 Verible的解析器也经常针对在不断增长的套件(工具无关)语言一致性测试测试 。 一个较小的(但值得注意的)目标是Verible的与语言无关的组件可用于快速开发其他语言的语言支持工具。 开发人员,欢迎 对于源代码浏览,我们建议使用的完全索引且可搜索的镜像。 如果您想贡献,请查看指南和。 Verible的代码库是用C +
使用SystemVerilog中的rand机制, 经常会用到$urandom_range()这个函数, 得到一个无符号的整型数. 语法:$urandom_range(int unsigned maxval,int unsigned minval = 0);​ 有两个参数,一个上限参数和一个可选的下限参数。 功能:返回一个在maxval和minval之间的无符号整数 example: val = $urandom_range(7,0); //结果是[0,7] val = $urandom_range(0,7)
你可以通过以下几种方式来快速学习SystemVerilog: 1. 阅读SystemVerilog的官方文档和教程,这些文档可以帮助你了解SystemVerilog的基础知识和语法。 2. 参加SystemVerilog的培训课程或研讨会,这些课程可以帮助你深入了解SystemVerilog的应用和实践。 3. 加入SystemVerilog的社区和论坛,与其他SystemVerilog开发者交流经验和技巧。 4. 实践编写SystemVerilog代码,通过实践来加深对SystemVerilog的理解和掌握。 希望这些方法能够帮助你快速学习SystemVerilog