sv零星知识点

Posted 2020-11-21

=====================================
并未打算完全学习完sv的语法，只是为了更好的
使用关于sv的平台验证的能力，使得每次综合后
的结果不会因为综合工具的变化而改变。
鉴于目前国内的关于sv的入门书籍极少
还是请各位查看相应的官方的编程语言手册

 博主是先前学习过verilog，过渡到sv较为简单

====================================

systemverilog 以.sv文件结尾
sv中的操作符：
== ！= ： 这两种表示逻辑符合与逻辑不符 ， 如若其中存在有x或者z，那么得到的结果 则是z
=== ！== ： 严格匹配x与z，但此条语句不可综合。
==？ ！=？ ： 在其中x与z为无关项，若右操作数为常数，则可综合。

加入延迟：
#（n timedelay_uint) 加入延迟事件
#（min：typical：max，min：typical：max，min：typical：max） 加入上升延迟与下降延迟，还有截止延迟

编写的技巧：
使用parameter语句添加参数，使模块参数化，，使得模块可以重复使用。实现代码复用。

关于sv的testbench的一个发现：

module TestAnd2；
wire  a , b , c ;

And g1(c,a,b);

intial begin
    a = ‘0;
    b = ‘0;
    #100ps  a = ‘1;
    #50ps   b = ‘1;
end

endmodule

testbench中的wire变量类型可以直接通过赋值语句赋值了，而不再需要写成  output  reg 的类型了。
实在是一大惊奇的发现！！！
同时sv可以使得延迟的事件带有时间单位，并且在实例化一个module时，若其端口名与链接名是一致的，
那么则可使用module_name(.*)的简写方式

sv的数据类型：
char：一个两态的有符号变量，它与C语言中的char数据类型相同，可以是一个8位整数（ASCII）或short int（Unicode）；
int：一个两态的有符号变量，它与C语言中的int数据类型相似，但被精确地定义成32位；
shortint：一个两态的有符号变量，被精确地定义成16位；
longint：一个两态的有符号变量，它与C语言中的long数据类型相似，但被精确地定义成64位；
byte：一个两态的有符号变量，被精确地定义成8位；
bit：一个两态的可以具有任意向量宽度的无符号数据类型，可以用来替代Verilog的reg数据类型；
logic：一个四态的可以具有任意向量宽度的无符号数据类型，可以用来替代Verilog的线网或reg数据类型，但具有某些限制；
shortreal：一个两态的单精度浮点变量，与C语言的float类型相同；
void：表示没有值，可以定义成一个函数的返回值，与C语言中的含义相同。

Combine Logic：
always_comb 语句描述：组合逻辑专用的描述方式，通过延迟赋值语句来使用。
同时verilog支持int型的自动转换，使得结果，但需要注意这可能会带来一些错误。所以尽量不要使用这种特性。

casez与casex：   casez忽略z，将其看为？；而casex忽略x，z，将其看为？ 
/*******************************************************************
    作为一个严谨的电子工程师，需要坚决不用casex，casez
    避免仿真前后不一致的可能！！！！！！！！！！！！！
*******************************************************************/
在描述组合逻辑的情况下，使用casez可能会引来overlap的问题。 所以需要使用unique语句来比避免重复。
另外与其相近的的语句是priority，它一般结合if，elseif，else使用，
确保至少分支有一个语句是执行了的，它默认存在有优先级。

下面是关于 Ripple Adder的例子  ：

    基本的全加器模型：
            module  fulladder( output logic sum , cout ,
                       input logic a , b , cin );
                always_comb begin
                    { cout , sum }  = a + b + cin ;
                end
            endmodule

    最后做出的级联加法器：

            module ripple #( parameter N =  4 ) 
            ( output logic [N-1:0] sum , output logic cout ,
              input  logic [N-1:0] A , B , input logic cin );
            logic [N-1:1] ca ; 
            genvar i ;

            fulladder f0(sum[0], ca[1] , A[0] , B[0] , cin );

            generate for( i = 0 ; i < N-1 ; i++ )
                begin:   f_loop 
                    full_adder fi(sum[i],ca[i+1],A[i],B[i],ca[i]);
                end
            endgenerate

            fulladder fn(sum[N-1] , cout , A[N-1] , B[N-1] , ca[N-1] );

            endmodule

            //    单独的实例化可以同generate配合使用，这样可以少写判断语句。

            module ripple #( parameter N =  4 ) 
            ( output logic [N-1:0] sum , output logic cout ,
              input  logic [N-1:0] A , B , input logic cin );
            logic [N-1:1] ca ; 
            genvar i ;

            task automatic fulladder( output logic sum , cout , 
                          input logic a , b , cin ) ;
                begin
                    sum = a ^ b ^ sum ;
                    cout =   a&b | a&cin | b&cin ;
                end
            endtask

                always_comb fulladder(sum[0], ca[1] , A[0] , B[0] , cin );

                generate for( i = 0 ; i < N-1 ; i++ )
                    begin:   f_loop 
                    always_comb
                        full_adder(sum[i],ca[i+1],A[i],B[i],ca[i]);
                    end
                endgenerate

                always_comb fulladder(sum[N-1] , cout , A[N-1] , B[N-1] , ca[N-1] );

            endmodule

            //    generate 并不只是实例化module对象，还可以实例化逻辑语句。

    关于wire与logic的区别：
            在sv中常常看到logic而极少看到wire类型的出现，虽然他们的公用基本相同，但还是
            有部分不一致的地方。
            在存在三，四态或总线的情况下，也就是说可能出现z，x，则需要使用wire类型的变量