SystemVerilog学习杂记——随机与约束

绿皮书第六章内容常用函数汇总

随机修饰符

class
    rand    bit[31:0] src;     // 随机修饰符   
    randc   bit[7:0]  kind;    // 周期随机修饰符
endclass

        随机变量一般为2值类型变量，随机化只能随机0和1，即使设置为4值类型随机变量，也不会随机到X和Z。

约束

约束

class
    rand    bit[31:0] src;     // 随机修饰符   
    randc   bit[7:0]  kind;    // 周期随机修饰符

    constraint name {    src > 10;
                         src < 15;   }
endclass

函数constraint_mode() 

class test
    rand    bit[31:0] src;     // 随机修饰符   
    randc   bit[7:0]  kind;    // 周期随机修饰符

    constraint name1 {    src > 10;
                         src < 15;   }
    constraint name2 {    src > 30;
                         src < 85;   }
endclass

module
test t;
initial  begin
t = new();

t.name1.constraint_mode(0); //关闭约束name1
t.name1.constraint_mode(1); //开启约束name1

t.name2.constraint_mode(0); //关闭约束name2
t.name2.constraint_mode(1); //开启约束name2

t.constraint_mode(0); //关闭所有约束
t.constraint_mode(1); //开启所有约束

assert(handle.randomize());
end
endmodule

内嵌约束和软约束

class test
    rand    bit[31:0] src;     // 随机修饰符   
    randc   bit[7:0]  kind;    // 周期随机修饰符

    constraint name1 {    src > 10;
                         src < 50;   }

    constraint name2 {       src > 5;
                        soft src < 85;   }  //软约束
endclass

module

test t;

initial  begin

t = new();

assert(t.randomize() with {src >= 20; src < 30} ); //内嵌约束

end

endmodule

固定约束（固定激励值） 

rand_mode()

class test
    rand    bit[31:0] src; 
    constraint name1 {    src > 10;
                         src < 50;   }
endclass

module

test t;

initial  begin

t = new();

assert(t.randomize());

t.src.rand_mode(0);    //设置src为非随机值
t.src = 1;             //固定src为常数
assert(t.randomize()); //再次随机化
end

endmodule

随机化函数 

函数randomize()

handle.randomize();    

assert(handle.randomize());    //常用格式

        常用“assert(handle.randomize());” 格式，随机化成功时handle.randomize()返回1，失败返回0。

个别变量随机化 

class test
    bit               wfg;     //非随机变量
    rand    bit[31:0] src;     // 随机修饰符   
    randc   bit[7:0]  kind;    // 周期随机修饰符

    constraint name {    src > 10;
                         src < 15;   }
endclass


test t；
t = new();
t.randomize(src);  //仅随机src，其他随机变量保持为上一次随机的值（如果有的话）或初始值
t.randomize(kind); //仅随机kind
t.randomize(wfg);  //随机wfg，可以随机非随机变量

函数pre_randomize()和函数post_randomize()

        需要用户自己编写其中内容，可以理解为函数randomize()的回调函数，在执行函数randomize()之前自动先执行pre函数，在执行randomize()之后自动执行post函数。

系统随机化函数

        $random()

        $urandom()

        $urandom_range()

        $dist_exponential()

        $dist_normal()

        $dist_poisson()

        $dist_uniform()

权重分布（修饰符dist，操作符   :=  和 :/   ）

class
    rand    bit[31:0] src;     // 随机修饰符   
    randc   bit[7:0]  kind;    // 周期随机修饰符

    constraint name {    src > 10;
                         src < 15;
                         kind dist  {0:=40,[1:3]:/60};   }
endclass

“：=”表示取值范围内的每个值权值相同 ，都为该操作符右侧的值

“：/”表示取值范围内的每个值的权值为均分该操作符右侧的值

inside运算符和$ 

class
    rand    bit[31:0] src;     // 随机修饰符   
    randc   bit[7:0]  kind;    // 周期随机修饰符

    constraint name {    src inside { [0:20] , [100:$] };    }
endclass

数组的约束 

动态数组大小的约束和数组元素的和的约束

class
    rand    logic [31:0] d[];     //随机动态数组 

    constraint name {   d.size() inside{ [1:10] };    //一定要注意设置数组大小上限
                        d.size() inside{ [50:200] };  //约束数组元素之和
                        foreach(d[i]) d[i] inside {[1:10]}; }  //数组内容约束
endclass

 随机化句柄数组

parameter MAX SIZE = 10;
class Randstuff;
         bit[1:0] value = 1;
    rand bit[1:0] value2;
endclass

class RandArray;
    rand Randstuffarray[] ;

    constraint c {  array.size() inside{[1:MAX SIZE]}; }

    function new() ;//分配最大容量，随机化函数randomize()不会创建对象，必须先创建对象
        array = new[MAX SIZE];
        foreach (array[il)
            array[il = new();
    endfunction;
endclass

RandArray ra;
initial begin // 构造数组和所有对象
    ra = new() ;
    assert(ra.randomize () ) ;// 随机化数组，但可能会减小数组
    foreach (ra.array[il)
        Sdisplay(ra.array[il .value) ;
end

        调用随机化函数对句柄数组Randstuffarray进行随机化时，会随机化数组大小（会变短或不变，不会变大，因为随机化函数不会自己创建对象），然后对每个句柄对应的对象内的随机变量进行随机化（即调用对象的随机化函数）