IC秋招System Verilog 116道题目及答案_system verilog习题

1、求创建完成后 niu2.b的值：

class niuniuww 
 logic int a =5; 
 logic int b; 
 function new(aa = 10,bb=20) 
  a = aa; 
  b = bb+10; 
  endfunction 
endclass 
initial begin 
 niuniuww niu1 niu2; 
 niu1 = new(30); 
 niu2 = new(30,40); 
end 

A、70

B、40

C、50

D、10

答案：C

笔记：

在这里 b为动态变量（默认的class中）因此第一次创建并不会影响第二次创建的值，因此此处为40+10

2、以下关于断言中使用的符号的含义，说法错误的是：

sequence seq; 
    @(posedege sysclk) $rose(ready)  ##1 data_a[=N]  ##[1:3] data_b; 
endsequence 
说明：sysclk是系统时钟信号，ready是指示信号，data_a,data_b是1比特的数据信号。

A  $rose(ready) 表示ready信号的上升沿

B  ##1 表示下一个时钟

C  data_a[=N]表示data_a连续N个周期都为高

D  ##[1:3] 表示1个或者2个或者3个时钟之后

答案：C

笔记：

data_a[=N] 表示data_a为高重复N个周期，但不要求连续。

data_a[*N] 表示data_a连续N个周期都为高。

• ##n表示n个时钟周期后，##0表示当前周期，即交叠周期
• ##[min:max]表示在一个范围内的时钟周期延迟，min和max为非负数，序列会从min到max中时间窗口中最早的时间来匹配
• $用来表示无穷大的周期（仿真结束前），一般不建议这么做，因为它会增大仿真评估序列的负担
• [*n]表示重复，连续发生，n为非负数，如本题
• [=n]用来表示一个事件的连续性，需要重复发生n次，但不需要连续周期内发生，如本题
• 类似的[=min:max]表示从min到max的重复发生的非连续周期次数
• $rose(ready) 表示ready信号的上升沿
• $fell(ready) 表示ready信号的下降沿
• $stable(ready)表示ready信号不变
• $past(ready)表示访问ready信号若干采样周期前的数值

3、System Verilog中的string类型可以用来保存长度可变的字符串。下面关于字符串说法错误的是

A 字符串的结尾带有标识符null

B 单个字符是byte类型

C 字符串使用动态存储方式

D 函数toupper的作用是返回一个所有字符大写的字符串

答案：A

笔记：

System Verilog与C语言不一样的是，字符串的结尾并不带标识符null，所有尝试使用字符"\0"的操作都会被忽略。因此A选项是错误的。

函数toupper的作用是返回一个所有字符大写的字符串
函数tolower的作用是返回一个所有字符小写的字符串

相关题：15

4、测试平台和设计之间的时序必须密切配合。在时钟周期级的测试平台，需要在相对于时钟信号的合适的时间点驱动和接收同步信号。驱动得太晚或者采样得太早，测试平台得动作就会错过一个时钟周期。在System Verilog中，使用时钟块控制同步信号的时序。下面选项中，关于时钟块的说法错误的是？

A 时钟块中的任何信号都将同步地驱动或采样

B 可以在时钟块中使用default语句指定一个时钟偏移

C 一旦定义了时钟块，测试平台就可以用例如@arbif.cb这样的表达式等待时钟，而不需要描述确切的时钟信号和边沿

D 一个接口只能有一个时钟块

答案：D

笔记：

一个接口可以包含多个时钟块，因为每个块中都只有一个时钟表达式，所以每一个对应一个时钟域。典型的时钟表达式如@（posedge clk）定义了单时钟沿，而@（clk）定义了DDR时钟。因此，D选项是错误的。

5、通常状况下，使用systemverilog相对较多的，在专用集成芯片设计流程中关注设计的验证行为，进行的验证工作主要指：

A  RTL功能验证

B 门级的仿真

C 形式验证

D 时序验证

答案：A

笔记：

寄存器传输级 （ RTL） 的功能验证。

门级的仿真， 为了验证综合后网表和期望的功能是否一致。

形式验证 （ 等价性检查） 来确保门级网表和RTL 代码的一致性。

时序验证， 为了验证设计能否在特定的频率上运行， 通常采用静态验证工具。

功能验证在专用集成芯片设计流程中关注设计的行为， 几乎所有的功能都可以在RTL层次被验证。

6、System Verilog可以通过在变量名后面指定维度的方式来创建多维定宽数组。假设现在有一个四状态类型的数组，例如是logic。如果代码试图从一个越界的地址中读取数据，那么System Verilog返回的值是？

A  0

B  1

C  X

D  Z

答案:C

笔记：

如果你的代码试图从一个越界的地址中读取数据，那么System Verilog将返回数组元素类型的缺省值。也就是说，对于一个元素为四状态类型的数组，例如logic，返回的是X，而对于双状态类型例如int或bit，则返回0。这适用于所有的数组类型，包括定宽数组、动态数组、关联数组和队列，也同时适用于地址中含有X或者Z的情况。线网在没有驱动的时候输出是Z。因此，应该选项C选项。

7、相比四状态数据类型，System Verilog引入的双状态数据类型有利于提高仿真器的性能并减少内存的使用量。下面选项中，关于System Verilog双状态数据类型说法错误的是（）？

A bit数据类型是双状态，单比特，无符号的

B int数据类型是双状态，32比特有符号整数

C longint数据类型是双状态，32位有符号整数

D real数据类型是双状态，双精度浮点数

答案：C

笔记：

System Verilog中带符号的数据类型：

    bit b;                    //双状态，单比特

    bit [31:0] b32;      //双状态，32比特无符号整数

    int unsigned ui;    //双状态，32比特无符号整数

    int i;                     //双状态，32比特有符号整数

    byte b8;               //双状态，8比特有符号整数

    shortint s;            //双状态，16比特有符号整数

    longint l;              //双状态，64比特有符号整数

    integer i4;           //四状态，32比特有符号整数

    time t;                 //四状态，64比特无符号整数

    real r;                 //双状态， 双精度浮点数

相关题：32、49

8、流操作符用于把其后的数据打包成一个比特流。以下关于流操作符使用正确的是：

已知：

    int a;

    bit [7:0] c[4] = '{8'ha,8'hb,8'hc,8'hd);

A  a = {>>{c}};

B  >> a = {c};

C  a = {>>[c]};

D  a = <<{c};

答案：A

笔记：

见绿皮书43页，只有a = {>>{c}};的形式是对的

在SV中，流操作符>>和<<用在赋值表达式的右边，后面带表达式、结构或数组。流操作符用于把其后的数据打包成一个比特流。操作符>>把数据从左至右变成流，而<<则把数据从右至左变成流。你也可以制定一个片段宽度，把源数据按照这个宽度分段以后再转变成流。不能将比特流结果直接赋给非合并数据，而应该在赋值表达式的左边使用流操作符把比特流拆分到非合并数组中。如下面代码所示：

initial begin
	int h;
	bit [7:0] b, g[4], j[4] = '{8'ha, 8'hb, 8'hc, 8'hd};
	bit [7:0] q, r, s, t;
 
	h = {>>{j}};								//0a0b0c0d  把数组打包成整型
	h = {<<{j}};								//b030d050 位倒序
	h = {<<byte{j}};							//0d0c0b0a 字节倒序
	g = {<<byte{j}};							//0d,0c,0b,0a拆分成数组
	b = {<<{8'b0011_0101}};						//1010_1100位倒序
	b = {<<4{8'b0011_0101}}						//0101_0011半字节倒序
	{>>{q, r, s, t}} = j;						//把j分散到四个字节变量
	h = {>>{t, s, r, q}};						//把字节集中到h
end

h={>>1{j}} 或h={>> {j}}，片段宽度为1变为流
h={>>8{j}} 或 h={>>byte{j}};以片段宽度为8（byte）变为流

9、观察下面的代码。请问最后打印出来的值是（）？

initial begin
    for (int j=0;j<3;j++)
        fork
            automatic int k=j;
            $write(k);
        join_none
     #0 $display;
end

A  0 1 2

B  0 0 0

C  2 2 2

D  3 3 3

答案：A

笔记：

可参考绿皮书185页，fork...join_none块被分割成两个部分。带初始化的自动变量声明在for循环里的线程中运行。在每轮循环中，k的一个拷贝被创建并且被设置为j的当前值，然后fork...join_none（$write）被调度，包括k的拷贝。在循环完成后，#0阻塞了当前线程，因此三个线程一起运行，打印出各自拷贝值k。当线程运行完毕后，在当前时间片已经没有其他时间残留，这时System Verilog就会前进到下一个语句执行$display。因此，最后的输出为“0 1 2”。

注：EDA工具有区别，利用QuestaSim仿真出来是2 1 0，而VCS仿真出来是 0 1 2

10、在Sysytem Verilog中，提供了很多数组的方法，根据以下代码，下列关于数组缩减方法 .sum 说法正确的是：

 bit a[10],b;
    int c;
    ...
    foreach (a[i])
        a[i] = i;

A  $display("a.sum = %d",a.sum);     则显示 a.sum = 5;

B  $display("a.sum = %d",a.sum);     则显示 a.sum = 10;

C  b = a.sum;$display("b = %d",b);   则显示 b = 1;

D  c = a.sum;$display("c = %d",c);  则显示 c = 10;

答案：C

笔记：

在foreach语句中，对a[10]进行初始化赋值。foreach中对a[i]分别赋值1~10，但因为a只有1bit，所以截取1~10的最后一位，就成了0和1交替的数组,a = '{0,1,0,1,0,1,0,1,0,1}. 对一个单bit的数组求和，结果也是单bit，所以直接显示 a.sum ,或者 b=a.sum。结果是1。而c的整形数据，a中有五个1，所以c=a.sum，c的值是5.

11、对于systemverilog，下面正确的是：

enum {A, B, C, D=5, E, F} list;

A  list ==A时，list=1

B  list ==C时，list=2

C  list ==D时，list=2

D  list ==F时，list=6

答案：B

笔记：

可参考绿皮书46页，如果没有明确给定数据类型，枚举中的数值是int类型，且int类型的缺省值为0，数值依次是0, 1, 2...。

A=0，B=1，C=2，D=5，E=6，F=7 枚举类型值在没有显示指定时，默认int从0自加。且label的值也要唯一（value唯一）

相关题：60

12、在某个类中，有如下定义，下列选项描述正确的是：

 rand int  len;
rand bit  mode;
constraint c{ 
mode == 1 -> len dist {10:=1,20:=2};
mode == 0 -> len dist {10:=2,20:=1};
solve mode before len;
}
constraint mode 

A  len取10的概率是1/2;

B  len取10的概率是1/3;

C  len取10的概率是1/4;

D  len取10的概率是1;

答案：A

笔记：

solve mode before len; mode取1，0的概率相同，各1/2。而len取10的概率分别是 1/3和2/3,易得len取10的概率是1/2*1/3+1/2*2/3=1/2.

可参见绿皮书140

:=操作符表示值范围内的每一个值的权重都相同

:/操作符表示权重均分到值范围内的每一个值

例如:

rand int src,dst;
constraint c_dist{
    src dist {0:=40,[1:3]:=60};
    //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};
    //dst=0,weight=40/100
    //dst=1,weight=20/100
    //dst=2,weight=20/100
    //dst=3,weight=20/100
}

13、对于任何一种新型的验证方法学来讲，分层的测试平台是一个关键的概念。虽然分层似乎会使测试平台变得更加复杂，但它能够把代码分而治之，确实有助于减轻工作负担。下面选项中，关于断言的定义正确的是？

A  驱动了待测设计的输入

B  负责比较来自监视器和记分板的命令

C  接收到来自上层的事务

D  穿过命令层和信号层，负责监视独立的信号以寻找穿越整个命令的信号变化

答案：D

笔记：

驱动器驱动了待测设计的输入，所以A选项是驱动器的概念。

检验器负责比较来自监视器和记分板的命令，所以B选项是检验器的概念。

代理（在VMM中称为事务处理器）负责接收到来自上层的事务，所以C选项是代理的概念。

综上，应该选择D选项。

相关题：24、48、93

15、以下关于字符串的内置方法，下列说法正确的是：

string s_a="abc";
string s_b="ABC"
string s_c;
bit a,b,c,d;
initial begin
    a = s_a.compare(s_b);
    b = s_a.icompare(s_b);
    s_c = s_b.tolower;
    c = s_a.compare(s_c);
    d =  s_a.compare(s_b);
end

A  a的值是1，b的值是0，c的值是1，d的值是0

B  a的值是0，b的值是1，c的值是1，d的值是0

C  a的值是1，b的值是1，c的值是1，d的值是1

D  a的值是0，b的值是1，c的值是1，d的值是1

答案：B

笔记：

s_b.tolower() 将 中的字符转换成小写形式并返回该字符串；s_b不会发生变化.

s_a.compare(s_b);将s_a，s_b进行比较，区分大小写

s_a.icompare(s_b);将s_a，s_b进行比较，不区分大小写

相关题：3

函数toupper的作用是返回一个所有字符大写的字符串

16、constraint c_0(src dist{1:/30,[2:4]:/90};请问如上表达式约束,src数值为1的概率为多大:()

A  0.3

B  0.25

C  0.5

D  0.1

答案：B

笔记：

[2:4] :/90，表示2，3，4的权重总和是90，分别为30，1的权重也是30，

所以取1的概率是30/(30+90)=0.25.

相关题：12

:=操作符表示值范围内的每一个值的权重都相同

:/操作符表示权重均分到值范围内的每一个值

17、

bit [7:0] a,b,c; 
initial begin 
    a = 8'b1;
    b = 'b1;
    c = '1;
    $display("a=%b,b=%b,c=%b",a,b,c);
end 

A  a的值是 11111111；b的值是 00000001；c的值是 00000001

B  a的值是 00000001；b的值是 00000001；c的值是 00000001

C  a的值是 11111111；b的值是 11111111；c的值是 11111111

D  a的值是 00000001；b的值是 00000001；c的值是 11111111

答案：D

笔记：

数字表达式有以下三种：

1、<位宽><进制><数字>

        这是一种全面的的描述方式，如8'b1,展开即为 00000001

2、<进制><数字>

        位宽采用默认位宽，如'b1,本题因为bit[7:0] b,所以默认8位，与8'b1一样

3、<数字>

        默认十进制，如10=8'b1010

（左上角一个单撇）：表示位扩展信号，可以将每一位扩展为指定值，如本题'1=11111111

SV里面数据扩展一个单撇就可以

18、和Verilog相比，System Verilog提供了很多该改进的数据结构。下面选项中，不属于System Verilog引进的一些新的数据类型的是（）？

A  双状态数据类型

B  字符串

C  类和结构

D  浮点数（real）

答案：D

笔记：

System Verilog引进了一些新的数据类型，如下：

   1、 双状态数据类型

   2、 队列、动态和关联数组

   3、类和结构

   4、联合和合并结构

   5、 字符串

   6、枚举类型

19、对某些数据类型，你可能希望既可以把它作为一个整体来访问，也可以把它分解成更小的单元。例如，有一个32比特的寄存器，有时候希望把它看成四个8比特的数据，有时候则希望把它看成单个的无符号数据。System Verilog的合并数组就可以实现这个功能。下面选项 中关于System Verilog中合并数组错误的是（）？

A  与非合并数组不同的是，它的存放方式是连续的比特合集，中间没有任何闲置的空间

B  合并数组大小定义的格式必须是[msb:lsb]，而不是[size]

C  任何数组类型都可以合并，包括动态数组、队列和关联数组

D  如果需要等待数组中的变化，可以使用合并数组，也可以使用非合并数组

答案：D

笔记：

见绿皮书26-27页

        如果需要等待数组中的变化，则必须使用合并数组。当测试平台需要通过存储器数据的变化来唤醒时，会想到使用@操作符。但是这个操作符只能用于标量或者合并数组。

20、System Verilog中引进了一种新的数据类型---队列，它结合了链表和数组的优点。队列和链表相似，可以在有一个队列中的任何地方增加或删除元素。下面是关于队列操作的代码。请问j的结果最后是（）？

int j=1,
    q[$]={6,0,2,3,4,5};
initial begin
    j=q.pop_back;
end

A  3

B  4

C  5

D  6

答案：C

笔记：

 j=q.pop_back;的含义是将q队列的最后一个元素的值弹出来传给j，此时q队列的元素为{6，0，2，3，4}。

因此，j的结果是5。

见绿皮书29页，其他的方法如下代码

int j = 1,
    q2[$]={3,4},         //队列常量不需要使用“'”
    q[$]={0,2,5};        //{0,2,5}
 
innitial begin
    q.insert(1,j);       //{0,1,2,5}  把j=1插入队列下标为1的位置
    q.insert(3,q2);      //{0,1,2,3,4,5} 在q中插入q2队列
    q.delete(1);         //{0,2,3,4,5} 删除下标为1的数字
 
    q.push_front(6);    //{6,0,2,3,4,5} 在队列前面插入6
    j=q.pop_back;       //{6,0,2,3,4}   从队列末尾弹出5，所以j=5
    q.push_back(8);     //{6,0,2,3,4,8} 从队列末尾插入8
    j=q.pop_front;      //{0,2,3,4,8}   从队列后面弹出6，所以j=6
    foreach(q[i])
        $display(q[i]); //打印
    q.delete();         //{}  删除整个队列，变成空
end
 
 

相关题：45、50

21、下面选项中关于System Verilog中任务和函数的概念错误的是（）？

A  一般情况下，不带参数的子程序在定义或调用时并不需要带空括号（）

B  在System Verilog中，begin...end块变成可选的

C  System Verilog中可以允许函数在任意时刻调用任务

D  在System Verilog中，参数的传递可以指定为引用而不是复制

答案：C

笔记：

        因为任务里面可能存在一些wait、@deng延迟语句，函数需要立即返回，所以函数不能调用任务，而任务可以调用函数和任务

22、System verilog常用于编写testbench。关于以下两个赋值语句(略去其他语句），说法正确的是：

//语句一： 
wire a,b,c; 
initial 
#10 a = b+c; 
//语句二： 
wire a,b,c; 
initial 
a = #10 b+c; 

A  两个语句是相同的，没有差别

B  #10 a = b+c; 表示延迟10个时钟单位后，将0时刻的b+c的值赋予a。

C  a = #10 b+c; 表示延迟10个时钟单位后，将10时刻的b+c的值赋予a。

D  a = #10 b+c; 表示延迟10个时钟单位后，将0时刻的b+c的值赋予a。

答案：D

笔记：

#10 a = b+c; 表示延迟10个时钟单位后，将10时刻的b+c的值赋予a。

a = #10 b+c; 表示延迟10个时钟单位后，将0时刻的b+c的值赋予a。对于这种延迟，b+c的值在执行分配时被存储，但是直到延迟期之后，该值才被分配给a，而不管b或c在该时间内是否发生了变化。

23、测试平台和设计之间的时序必须密切配合。在时钟周期级的测试平台，需要在相对于时钟信号的合适的时间点驱动和接收同步信号。驱动得太晚或者采样得太早，测试平台得动作就会错过一个时钟周期。在System Verilog中，使用时钟块控制同步信号的时序。下面选项中，关于时钟块的说法错误的是（）？

A  时钟块中的任何信号都将同步地驱动或采样

B  可以在时钟块中使用default语句指定一个时钟偏移

C  一旦定义了时钟块，测试平台就可以用例如@arbif.cb这样的表达式等待时钟，而不需要描述确切的时钟信号和边沿

D  一个接口只能有一个时钟块

答案：D

笔记：

        一个接口可以包含多个时钟块，因为每个块中都只有一个时钟表达式，所以每一个对应一个时钟域。典型的时钟表达式如@（posedge clk）定义了单时钟沿，而@（clk）定义了DDR时钟。因此，D选项是错误的。

24、对于任何一种新型的验证方法学来讲，分层的测试平台是一个关键的概念。虽然分层似乎会使测试平台变得更加复杂，但它能够把代码分而治之，确实有助于减轻工作负担。下面选项中，关于代理（在VMM中称为事务处理器）的定义正确的是？

A  驱动了待测设计的输入

B  负责比较来自监视器和记分板的命令

C  接收到来自上层的事务

D  穿过命令层和信号层，负责监视独立的信号以寻找穿越整个命令的信号变化

答案：C

笔记：

驱动器驱动了待测设计的输入，所以A选项是驱动器的概念。

检验器负责比较来自监视器和记分板的命令，所以B选项是检验器的概念。

断言穿过命令层和信号层，负责监视独立的信号以寻找穿越整个命令的信号变化，所以D选项是断言的概念。

相关题：14、48、93

25、在system verilog中，变量的声明错误的是：

A  int a[][];

B  int b[8][5];

C  int [8][3] c;

D  int [3:0] d [5:0];

答案：C

笔记：

        见绿皮书26页，考察合并数组的声明: 数据类型 [数组大小] [位宽] 变量名 ,声明合并数组时，数组大小和位宽必须指定，并且位宽必须是[msb : lsb]，而不是[size]，int [8][3] c;错误，应为int [7:0][2:0] c;非合并数组可以使用如int b[8][5]; 的维度声明方式。int a 声明了一个二维的动态数组，不指明维度

26、观察下面的代码，可以看出，输出的第一条语句是“producer:before put(1)”。请问，下面的代码输出的第六条语句是什么？

`timescale 1ns/1ns
program automatic bounded;
    mailbox mbx;
    initial begin
        mbx=new(1);
        fork 
            for(int i=1;i<4;i++) begin
                $display("producer:befor put(%0d)",i);
                mbx.put(i);
                $display("producer:after put(%0d)",i);
            end
            repeat(4) begin
                int j;
                #1ns mbx.get(j);
                $display("consumer:after get(%0d)",j);
            end
        join
    end
endprogram

A  producer:before put(3)

B  consumer:after get(2)

C  producer:after put(2)

D  consumer:after get(1)

答案：A

笔记：

见绿皮书203页，

题中的代码创建了一个只能存放单条信息的具有最小容量的信箱。生产方（producer）线程试图把三条信息放入信箱，而消费方（consumer）线程则慢慢地每1ns提取一个信息。第一个put执行成功后，生产方线程试图执行put（2）但被阻塞。消费方线程被定时唤醒后，从信箱里取走信息1，这之后生产法才能把信息2放进信箱。

因此，定容信箱地输出：

    producer:before put(1)

    producer:after put(1)

    producer:before put(2)

    consumer:after get(1)

    producer:after put(2)

    producer:before put(3)

    consumer:after get(2)

    producer:after put(3)

    consumer:after get(3)

因此，第六条输出的语句是 producer:before put(3)

27、System Verilog中引进了一种新的数据类型---队列，它结合了链表和数组的优点。队列和链表相似，可以在有一个队列中的任何地方增加或删除元素。下面选项中关于队列说法错误的是（）？

A   队列可以通过索引实现对任一元素的访问

B   队列的声明是使用带有美元符号的下标：[$]

C   队列中的元素是连续存放的，所以在队列中间增加或者删除元素非常方便，无论队列有多大，这种操作所耗费的时间都是一样的

D   队列的常量只有大括号而没有数组常量中开头的单引号

答案：C

笔记：

        见绿皮书28页，队列中的元素是连续存放的，所以在队列的前面或者后面存取数据非常方便。无论队列有多大，这种操作所耗费的时间都是一样的。在队列中间增加或删除元素需要对已经存在的数据进行搬移以便腾出空间，相应操作所耗费的时间会随队列的大小线性增加。

       因此，C选项是错误的

28、下面选项中，关于Verilog和System Verilog中的数据类型说法错误的是（）？

A  Verilog-1995中所有的存储都是静态的

B  logic数据类型可以有多个结构性的驱动

C  Verilog-1995中子程序不能通过堆栈来保存形式参数和局部变量

D  System Verilog对经典的reg数据类型进行了改进，改进后的数据类型被称为logic

答案：B

笔记：

         见绿皮书19~20页，System Verilog对经典的reg数据类型进行了改进，这种改进的数据类型被称为logic。任何使用net数据类型的地方均可以使用logic，但是要求logic不能有多个结构型的驱动，例如在对双向总线建模的时候。此时，需要使用net类型，例如wire，System Verilog会对多个数据来源进行解析以后确定最终值。

        Verilog-1995所有存储都是静态的，意味着所有变量在整个仿真过程都是存活的

    因此，B选项是错误的。

   补充解释：

    1、logic类型只能有一个驱动，所有信号都声明为logic而不是reg或wire，如果存在多个驱动编译时就会报错，当然，若需要多个驱动，如双向总线，这些信号就需要被定义成线网类型，如wire。

    2、reg、wire可以改为logic类型，也就是说由verilog到SV，在SV里面所有的变量得到了简化

29、分别执行以下语句，结果错误的是：

bit [7:0] a;
bit one = 1'b1;
a = one + one;

A  $displayb(one+one);  显示10

B  $displayb(a);  显示00000010

C  $displayb(one+one+2'b0);  显示10

D  $displayb(2'(one)+one);  显示10

答案：A

笔记：

one + one只有1bit，显示0.

one+one+2'b0 使用了2比特常量，结果会转化为2比特.

2'(one)+one 采用了类型转换，结果为2比特

30、对于systemverilog的队列，描述不正确的是

A  对于队列，SV实际上分配了额外的空间

B  使用new[]进行初始化

C  空队列文本 ｛ ｝ 可以用来指示一个空队列

D  可以用SV预定义的方法删除指定位置队列成员

答案：B

笔记：

        见绿皮书28-29页，队列不用像动态数组那样调用new[]为队列分配空间，队列不用初始化，动态数组才需要在使用时new[]

31、对于systemverilog的关联数组，描述不正确的是

A  数据空间缺紧的时候， 关联数组是比动态数组更好

B  使用之前不会分配任何存储空间

C  索引表达式可以是字符串

D  内部的排列顺序是任意的

答案：D

笔记：

        见绿皮书30-31页，关联数组实现了一个所声明类型成员的查找表， 用索引的数据类型作为查找表的查找键值， 并强制了其排列顺序

32、在system verilog中具有4态的数据类型是：

A  byte

B  int

C  bit

D  reg

答案：D

笔记：

        reg类型的变量可以具有四种状态：0，1，X，Z。其余三个只能是：0，1.

相关题：7、49

33、对于systemverilog的函数和任务（function / task）  ，描述不正确的是

A  任务没有返回值

B  任务和函数中没有任何执行语句也是不会报错的

C  任务和函数的参数还可以指定位缺省

D  当任务 ／函数运行到 endtask/endfunction的时候才会退出

答案：D

笔记：

        见绿皮书58页，可以使用 return 语句在任务体或函数体的任意一点退出子程序，但task不能用return返回值，task没有返回值。

34、下列关于testbench中变量的说法错误的是：

A  在module,program,interface,task和function之外声明的变量是静态的，即整个仿真阶段都存在。

B  在module,program和interface中定义的，且在task,process和function外部声明的变量是automatic变量，作用域在该块中。

C  如果task是static类型，则在task中定义的变量默认是static类型

D  某个方法或者函数声明为automatic，则内部的变量也默认为automatic类型

答案：B

笔记：

•     变量在module、program、interface、checker、task、function外定义：static             lifetime（在整个仿真时间内存在）
•     变量在module、program、interface、checker内，且在task、function、process外定义：static lifetime
•     变量在static task、static function、block内定义：default static lifetime
•     变量在static task、static function、block内定义，但变量加上automatic修饰符：lifetime of the call or block（随用随生成）
•     变量在automatic task、automatic function、automatic block内定义：default lifetime of the call or block
•     变量在automatic task、automatic function、automatic block内定义，但变量加上static修饰符：static lifetime

        上面情况分的有点多，但总的来说就是看离这个变量最近的属性是什么就行了。而task、function是什么类型由下面规则来确定。

    1、定义在module、interface、program、package内的task、function默认是static的；反之外面的默认就是automatic。
    2、类的task和function、for循环的loop变量默认是automatic的，而不管它们是在哪里被定义的

。

相关题：52

35、求下面运行完成后v1的值（）和v2的值（）

module niuke;
  int v1,v2,r;
  function int count1(input int a )
     r = a+1;    
     return r;
  endfunction
  function automatic int count2(input int a )
     int r;
     r = a+1;
     return r;
  endfunction
  initial begin
     v1=0;
     v1=count1(v1);
     v1=count1(v1);
  end
  initial begin
     v2=0;
     v2=count2(v2);
     v2=count2(v2);
  end
endmodule 

A  2 2

B  1 2

C  1 1

D  2 1

答案：A

笔记：

module breakpoint;
int val1;
int val2;
 
int result1;//定义在这里，或者定义在未特殊声明的function/task中都是静态的方法
function int incr_static(input int a);
  $display("result1 = %0d", result1);
  result1 = a + 1;
  $display("result1 = %0d", result1);
  return result1;
endfunction
function automatic int incr_dynamic(input int a); //automatic 动态方法
//动态方法中的所有变量，如果不做特殊声明的话，都是动态的
  int result2;
  $display("result2 = %0d", result2);
  result2 = a + 1;
  $display("result2 = %0d", result2);
  return result2;
endfunction
 
initial begin
//这里的val1值也是静态的
  val1 = 0;
  val1 = incr_static(val1); //这里会打印 0，1
  val1 = incr_static(val1);  // 这里会打印1，2
end
 
initial begin
//这里的val2值也是静态的
  val2 = 0;
  val2 = incr_dynamic(val2);
  val2 = incr_dynamic(val2); // breakpoint line14 result == ? 
end
 
endmodule

执行上述代码，仿真结果是：
result1 = 0
result1 = 1
result1 = 1
result1 = 2

result2 = 0
result2 = 1
result2 = 0
result2 = 2

依次解析
result1 = 0 //int-有符号的二值变量，默认初始值为0
result1 = 1 // 0+1 =1
result1 = 1 //由于result1是静态变量，且作用域为当前module，所以一直存在，且可以被修改
result1 = 2

result2 = 0
result2 = 1
result2 = 0//由于result2是静态变量，且作用域为当前function，所以用完就销毁了下次调用就重新申明了
result2 = 2

原文链接：https://blog.csdn.net/better_xiaoxuan/article/details/79015165

相关题：43

36、在类A中有如下语句约束语句，下列选项错误的是：

 class  A;
    rand bit a,m;
    rand bit [1:0]b,n;
    constraint c1{a-> b==0;}
    constraint c2{m->n==0;solve m before n}
end class 

A  b=0的概率是1/4，n=0的概率是1/4

B  b=0的概率是1/2，n=0的概率是1/2

C  b=0的概率是2/5，n=0的概率是5/8

D  b=0的概率是1/4，n=0的概率是1/2

答案：C

笔记：

见绿皮书148-149页

考察知识点：solve before 的有无对约束概率的影响

1. 没有solve before 操作符时，所有可能的结果概率都一样

a = 0, b = 0, 1 / 5;

a = 0, b = 1, 1 / 5;

a = 0, b = 2, 1 / 5;

a = 0, b = 3, 1 / 5;

a = 1, b = 0, 1 / 5;

2. 有solve before 操作符时，有先后顺序

a = 0, b = 0, 1 / 2 * 1 / 4 = 1 / 8;

a = 0, b = 1, 1 / 2 * 1 / 4 = 1 / 8;

a = 0, b = 2, 1 / 2 * 1 / 4 = 1 / 8;

a = 0, b = 3, 1 / 2 * 1 / 4 = 1 / 8;

a = 1, b = 0, 1 / 2 * 1 = 1 / 2;

相关题：44

37、逻辑设计已经变得如此之复杂，即便是块之间的通信也必须分割成独立的实体。System Verilog使用接口为块之间的通信建模，接口可以看作一捆智能的连线。下面选项中，关于接口说法错误的是（）？

A  在接口中可以例化模块

B  可以在顶层模块中使用modport名，然后把接口放到程序和模块的端口表里

C  并非接口中的每个信号都必须连接

D  使用接口时，必须同时使用信号名和接口名

答案：A

笔记：

        模块里面可以例化模块，也可以例化interface，interface里面可以例化interface但不能例化module，使用接口时要在模块和程序块之外声明接口变量。因此，A选项是错误的。

        补充：

        1、实现模块和端口之间的连接

        2、实现类和模块之间的通信（虚接口virtual interface）

38、三种常用验证手段： 白盒、 黑盒和灰盒验证，下面对于黑盒验证，错误的是：

A  黑盒验证中， 可以不需要参考模型

B  很难验证和设计相关的特点

C  只通过其边界信号来验证一个模块或者设计的功能

D  是否使用黑盒验证取决于被测的复杂度

答案：A

笔记：

        见红宝书26-27页，白盒验证中， 可以不需要参考模型， 黑盒无法通过添加断言和监控等到被测设计，因此需要参考模型。

39、约束块中有如下语句，z的取值范围是多少：

 rand bit [5:0] z;
 constraint c{
    !(z inside {[$:4],[10,$]});
}; 

A  4<z<10

B  4≤z≤10

C  0≤z≤4 || 10≤z≤63

D  0<z<4 || 10<z<63

答案：A

笔记：

见绿皮书141页，$表示取值范围内最大值和最小值

rand bit[6:0] b; //0 <= b <= 127
rand bit[5:0] e; //0 <= b <= 63
constraint c_range{
    b inside{[$:4],[20:$]}; 
    //左边$为0，右边$为127
    //0 <=b <=4 || 20 <= b <= 127
 
    e inside{[$:4],[20:$]}; 
    //左边$为0，右边$为63. 
    //0 <=e <=4 || 20 <= e <= 63
}

40、面向对象编程（OOP）使用户能够创建复杂的数据类型，并且将它们跟使用这些数据类型的程序紧密的结合在一起。下面选项中是Verilog-2001中常用的术语。请问OOP术语中的句柄，和下面哪个选项是大致对应的？

A  模块（module）

B  实例化一个模块

C  通过实例名在模块外部引用信号和方法

D  寄存器（reg）或者线网（wire）类型的信号

答案：C

笔记：

下面是一些OOP的术语、定义以及它们与Verilog-2001的大致的对应关系。

因此，C选项是正确的

相关题：103

41、下面的选项中说法错误的是（）？

A  timeunit和timeprecision声明语句可以明确的为每个模块指明时间值，从而避免含糊不清

B  time类型的变量可以保存小数时延

C  可以使用$timeformat，$time和$realtime来使代码在事件标度上更清楚

D  使用timeunit和timeprecision声明语句时，必须把它们自己放到每个带有时延的模块里

答案：B

笔记：

        见绿皮书63页，系统任务$time的返回值是一个根据所在模块的时间精度要求进行四舍五的整数，不能带小数部分，而$realtime的返回值则是一个带小数部分的完整实数。$realtime返回64bit real型时间数值，实际上就是real型数值，$time返回64bit 整数型时间数值，小数部分四舍五入。

42、下列关于System Verilog中任务（task）和函数（function）的说法错误的是：

A  task中参数的缺省类型是 logic

B  task中参数的缺省方向是 input

C  function 必须有返回值

D  task即使包含多行语句也可以不使用begin...end

答案：C

笔记：

在System Verilog中，可以将函数声明为void类型，不产生返回值。

Function的特点：

• function中不可以内置耗时语句，被调用时是立即返回的，即不消耗仿真时间；
• 函数至少要有一个输入变量，可以无返回值或一个返回值；
• 函数参数列表中的变量缺省数据类型为logic类型；
• 函数参数参数列表中的变量如果没有规定反向，默认是 input方向；
• 如果函数有返回值，函数的返回值类型需要在函数定义时指定，且只能通过return返回一个值，或者通过赋值给与函数同名的内部变量（用的很少）；
• 如果函数没有返回值，要在函数定义时指定为 void ；
• 函数不可以调用task，因为task可能含有耗时语句，而函数不支持耗时语句。

Task的特点：

• task 可以内置耗时语句，也就是当调用task时，这个结果可以不是立即返回的；
• task 既可以调用function，也可以调用task；
• task不可以用 return 返回值；
• task 可以在参数列表中定义参数方向，以此来返回值，可以返回一个或多个值；
• task的参数列表中的参数，如果不规定方向，默认是input；
• 缺省的参数数据类型是 logic类型；

原文链接：https://blog.csdn.net/SummerXRT/article/details/120091772

43、当每个initial块中分别第二次运行函数count1/count2时候，运行到断点处，得到的r值，count1为 （）, count2的值（）

 module niukeww;
    int niu1,niu2,r;
    function int count1(input int a )
       r = a+1;    //在此处打断点
       return r;
    endfunction
    function automatic int count2(input int a )
       int r;
       r = a+1;  //在此处打断点
       return r;
    endfunction
    initial begin
       niu1=0;
       niu1=count1(niu1);
       niu1=count1(niu1);
    end
    initial begin
       niu2=0;
       niu2=count2(niu2);
       niu2=count2(niu2);
    end
endmodule 

A  1 0

B  0 1

C  1 1

D  0 0

答案：A

笔记：

断点意味着运行到该语句的前面，该语句未被执行。

静态变量可以累积，动态变量运行离开函数后值自动清空，因此只有count1的r的值进行了+1

相关题：35

44、约束块中有如下语句，关于各个变量的取值说法正确的是：

 rand bit a;
 rand bit [1:0] b;
 constraint c{
     (a==0) -> b==0;
 }; 

A  出现 a=0,b=0的概率是1/8；

B  出现 a=1,b=1的概率是1/5；

C  出现 a=1,b=0的概率是1/8；

D  a的值一定是0，不可能是1；

答案：B

笔记：

没有slove...before修饰，因为a是单比特，所以有0和1，b可以为0、1、2、3，综合起来有以下五种情况：

a=0, b=0;

a=1; b=0;

a=1; b=1;

a=1; b=2;

a=1; b=3;

相关题：36

45、执行以下操作后，队列c和变量j的值分别是：

 int c[$] = {1,5,6,8};
 int j=1;
 initial begin
    j = c.pop_back;
 end 

A  c = {1,5,6,8},j=1;

B  c = {1,5,6,8,1},j=1;

C  c = {1,5,6},j=8;

D  c = {5,6,8},j=1;

答案：C

笔记：

j=c.pop_back,将队列最后一个值取出并赋予j。

相关题：20、50

46、判断时序关系，下面选项正确的是：

 initial begin
 forever #10 clk1 = !clk1;
 end
 always @(clk1) clk2<=clk1;
 initial begin
     #5 rst<=0;
     #40 rst<=1;
 end
 always @(posedge clk or negedge rst) begin
     if (!rst) c <=0;
     else c <=c+1;
 end
 always @(posedge clk1)  $display("%0t ns, c = %0d",$time,c);
 always @(posedge clk2)  $display("%0t ns, c = %0d",$time,c); 

A  clk1和clk2和c完全同步

B  clk1和clk2的采样结果一样

C  由clk2触发的打印的信息和clk1触发的打印信息不一样

D  其他都不对

答案：C

笔记：

        由于clk1驱动clk2和c，所以实际上后两者要比前者晚一个无限接近于0的时间差，看仿真图可以发现clk1比clk2和c更早一点，因此clk2上升沿采集到的c已经发生变化。

        补充：

        为了避免RTL仿真中发生的信号竞争，建议通过非阻塞赋值或者特定的信号延迟来解决同步问题。同样地在仿真行为中，为了尽量避免时序电路中时钟和驱动信号的时序竞争问题，我们需要给出尽量明确的驱动时序和采样时序。默认情况下，时钟对组合电路的驱动会存在一个无限小时间（delta-cycle）的延迟，而该延迟无法用绝对时间单位衡量，它比最小时间单位精度还小。

47、当你调用了一个带有标量变量（不是数组，也不是对象）的方法时，System Verilog传递该标量的地址，如果想让方法也可以修改标量变量的值，可以使用（）关键词？

A  this

B  ref

C  extern

D  protected

答案：B

笔记：

this关键词的作用是：如果在类的深处，想要引用类一级的变量, 可以通过this关键字很方便的做到。this关键字被用来明确地引用当前实例的类属性或类方法。

extern关键词的作用是：System Verilog中，可以将类的方法的原型定义(方法名和参数)放在类的内部，而方法的程序体放在类的外部。通过关

键字extern可以实现方法的声明，然后通过作用域操作符::来表名这个函数作用于哪个类。

protected关键词的作用是：一个被标识成protected的类属性或方法具有local成员的所有特性,但是它可以被继承以及对子类可见。

 补充：

传递这种大片内存的值一般只有两种规则

• 地址传递，函数内部修改可以改变函数调用的值。
• 值传递，将整片空间复制一份，函数内部修改不会改变函数调用的值。

system verilog中的参数传递——ref，input，output

function void run();
   int r[2];
    r[0] = 1;
    r[1] = 2;
    f(r);
    $display("%0x %0x",r[0],r[1]);
endfunction

加input情况

function void f(input int a[2]);
    a[0] = 3;
endfunction

输出结果是：1 2
具体过程如下：

1. 函数调用之前，内存里只有 r 数组的空间
2. 函数调用之后，会将 r 拷贝一份到 a，函数里面用的都是 a 这份空间
3. 函数调用之后，赋值后，修改的是 a 这份空间的值
4. 函数返回之后，a 空间会被释放掉，所以 r 的值并没有修改

因此，input 是标准的值传递

加input情况

function void f(output int a[2]);
   a[0] = 3;
endfunction

输出结果是：3 0

具体过程如下：

1. 函数调用之前，内存里只有 r 数组的空间
2. 函数调用之后，会新建一份 a 数组，注意这里并不会把 r 的值传进来，函数里面用的都是 a 这份空间
3. 函数调用之后，赋值后，修改的是 a 这份空间的值
4. 函数返回之后，会将 r 指向 a 空间，而原来 r 指向的空间会被释放掉，所以 r 的值都被修改了

         因此，加output，采用的是地址传递，确切的说是反向的地址传递，数组共有两份，函数内部看到的是新建的一份，并传递给函数调用处，因此，函数调用前看到的是第一份，函数调用后看到的是新建的那份。

 加ref的情况

function void f(ref int a[2]);
  a[0] = 3;
endfunction

输出结果是：3 2
具体过程如下：

1. 函数调用之前，内存里只有 r 数组的空间
2. 函数调用之后，会将 a 指向 r 所在的空间，函数里面用的都是这份空间
3. 函数调用之后，赋值后，修改的是这份空间的值，所以 r 和 a 都修改了
4. 函数返回之后，所以 r 的值只有部分修改

因此，加 ref，采用的是标准的地址传递，只有一份数组，函数内部和调用处都是访问该空间。

        对比来看，input 是将函数外面的值传递到函数里面，调用结束之后，函数里面的值就被丢弃了；out 是将函数里面的值传递到函数外面来，调用结束之后，函数外面的值就丢了；ref 是函数内部和外部看到的是同一份值，哪里改都会改。另外，可以看出，采用 ref 关键字是占用内存最小的，因为只有一份数组，这样能提高效率。

原文链接：system verilog中的参数传递 · 大专栏

48、对于任何一种新型的验证方法学来讲，分层的测试平台是一个关键的概念。虽然分层似乎会使测试平台变得更加复杂，但它能够把代码分而治之，确实有助于减轻工作负担。下面选项中，关于记分板的定义正确的是？

A  驱动了待测设计的输入

B  用于预测事务结果

C  接收到来自上层的事务

D  穿过命令层和信号层，负责监视独立的信号以寻找穿越整个命令的信号变化

答案：B

笔记：

驱动器驱动了待测设计的输入，所以A选项是驱动器的概念。

代理（在VMM中称为事务处理器）接收到来自上层的事务，所以C选项是代理的概念。

断言穿过命令层和信号层，负责监视独立的信号以寻找穿越整个命令的信号变化，所以D选项是断言的概念。

综上，应该选择B选项。

相关题：14、24、93

49、相比四状态数据类型，System Verilog引入的双状态数据类型有利于提高仿真器的性能并减少内存的使用量。下面选项中，关于System Verilog双状态数据类型说法错误的是（）？

A  bit数据类型是双状态，单比特，无符号的

B  int数据类型是双状态，32比特有符号整数

C  longint数据类型是双状态，32位有符号整数

D  real数据类型是双状态，双精度浮点数

答案：C

笔记：

longint类型是双状态，64比特有符号整数(int-32, long -64)

相关题：7、32

50、执行以下操作后，队列a的值是：

 int a[$] = {1,2};
 initial begin
     a.insert{1,3};
     a.push_front(8);
     a = {a,6};
 end

A  {1,2,3,8,6}

B  {8,1,3,2,6}

C  {8,1,2,3,6}

D  {1,2,6,8,3}

答案：B

笔记：

a.insert{1,3}; 在索引值1的位置插入3

a.push_front(8);在最前面加入8

a = {q,6};在最后拼接6

结果是{8,1,3,2,6}

相关题：20、45

51、已知bit [31:0] boo;下列关于boo说法正确的是：

A  boo是有符号数

B  boo是四状态变量

C  其他选项都不对

D  bit [31:0] boo;等效于int unsigned boo;

答案：D

笔记：

bit 是双状态无符号数据类型。int 是32位双状态有符号数据类型，在声明无符号变量时，需要使用 unsigned。bit [31:0] boo;等效于int unsigned boo;

52、对于systemverilog静态变量和动态变量 ，描述不正确的是

A  动态变量在程序执行的时候在其定义作用范围创建生成

B  静态变量在被创建后保持数值， 在整个程序执行过程中都存在

C  声明成自动的变量在每次进入调用的时候进行初始化

D  默认情况下，task中生成的变量为automatic

答案：D

笔记：

        默认情况下，task中生成的变量为static,只有将program等声明为automatic才会变量默认为automatic

相关题：34

53、执行以下操作后，队列a的值是：

 int a[$] = {1,5};
 initial begin
    a.insert{1,1};
    a = a[0:$-1];
    a.push_back(8);
    a = a[1:$];
 end 

A  {1,8}

B  {1,5}

C  {1,1,5,8}

D  {1,5,8}

答案：A

笔记：

a.insert{1,1} //在下标为1处插入1

a = a[0:$-1]; //数组宽度由小标为0至下标为($-1)处，相当于删除最后一个元素

a = a[1:$]; //数组由宽度小标为1至下标为$处，相当于删除第一个元素

先在1后面插入1，截去最后一个元素5，在最后添加一个元素8，截去第一个元素1。结果是{1，8}

54、s1,s2是已经定义好的sequence，对于以下断言的描述正确的是：

A
property prop_1;
  @ (posedge clk) 
    a   |-> s1 and s2;
endproperty
在时钟上升沿，如果a为1，在下一个时钟沿开始检测 s1,s2是否同时发生，同时结束

B
property prop_2;
  @ (posedge clk) 
    a   |-> s1 ##2 s2;
endproperty
在时钟上升沿，如果a为1，在下一个时钟沿开始检测 s1是否发生，再过两个时钟周期，检测s2的是否发生

C
property prop_3;
  @ (posedge clk) 
    a   |=> s1 intersect  s2;
endproperty
在时钟上升沿，如果a为1，在同一个时钟沿开始检测 s1,s2是否同时发生

D
property prop_3;
  @ (posedge clk) 
    a   |=> b;
endproperty
在上升沿到来时，若a=1，则在下一个时钟周期继续检查b是否为1，若为1，则判断为真

答案：D

笔记：

|-> 表示在同一个时钟沿 ，

|=> 表示在下一个时钟沿。

intersect  表示两个sequence同时发生，同时结束。

and 表示两个sequence同时发生，不要求同时结束。

55、对于systemverilog的动态数组，描述错误的是：

A  在编译的时候不知道数组的大小

B  可以是一维或者多维的

C  压缩部分的一维的大小在定义的时候未被指定

D  存储空间只有当数组在运行时被显式分配之后才会存在

答案：C

笔记：

        动态数组可以是一维或者多维的， 其中非压缩部分的一维的大小在定义的时候未被指定，其存储空间只有当数组在运行时被显式分配之后才会存在

压缩部分需要一开始就指定

        补充：

        合并型数组可以实现连续的存储，赋值时不需要用 '{ }

       非合并型数组存储的数据都是相互独立（不连续）的，赋值时需要用 '{ }。

56、测试平台仿真中，下面哪一个语句在使用运行指令run 0时会被执行

A  always

B  assign

C  initial

D  都不会执行

答案：B

笔记：

assign代表着连线，只有右侧有值的存在，那么初始化后就会被执行

57、以下为任务task_a的声明和调用，调用之后task_a中各个参数的值是多少：

 task task_a(input int a=1,b=2,c=3,d=4);
     $display("%0d %0d %0d %0d",a,b,c,d);
 endtask
 initial begin
     task_a(,6,.d(8));
 end

A  a=1,b=6,c=3,d=8

B  a=1,b=2,c=3,d=4

C  a=0,b=6,c=0,d=8

D  a=6,b=2,c=3,d=4

答案：A

笔记：

        任务在声明时，指定了参数a,b,c,d的缺省值。在调用任务的时候，第一个逗号前面没有值，即a保持缺省值1，b指定为6，d通过变量名指定为8。c没有指定，保持为缺省值3。所以a=1,b=6,c=3,d=8。

58、以下关于重载(Overloading)和重写(Overriding)的区别说法错误的是：

A  当需要在子类中调用父类的被重写方法时，要使用 super 关键字

B  方法重写是在子类存在方法与父类的方法的名字相同，但是方法的内容可以不同

C  重写是父类与子类之间多态性的一种表现

D  被重载的方法必须改变参数个数

答案：D

笔记：

        方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同，SV不支持。被重载的方法必须改变参数列表(参数个数或类型不一样)；参数个数可以保持不变，只改变类型

        方法重写是在子类存在方法与父类的方法的名字相同（两个具有继承关系的类）,而且参数的个数与类型一样,返回值也一样只改变方法体。

59、哪一个数据类型是双状态，32bit有符号整数：

A  byte

B  bit

C  integer

D  int

答案：D

笔记：

int是双状态，32bit有符号整数;

byte是双状态，8bit有符号整数：

bit是双状态，1bit无符号整数：

integer是四状态，32bit有符号整数：

60、在System Verilog中定义枚举常量alpha；以下说法错误的是：

enum {a,b=8,c} alpha;

Ａ　c的值是9

Ｂ　int q;q=alpha.last;  则q的值是8

Ｃ　int p;p = alpha.num; 则p的值是3

Ｄ　int t; t= alpha.first; 则a的值是0

答案：Ｂ

笔记：

alpha.last 返回枚举类型最后一个成员的值，b指定为8，则c的值自动分配为9.

相关题：11

61、System Verilog提供了很多数组定位方法，以下说法错误的是？

A　数组定位方法的返回值通常是一个队列

Ｂ　int a[6] = '{1,2,2,5,6,7,7,7}; a.unique的值是{1,2,5,6,7}

Ｃ　int a[6] = '{1,2,2,5,6,7,7,7}; a.max的值是{7,7,7}

Ｄ　int a[6] = '{1,2,2,5,6,7,7,7}; a.min的值是{1}

答案：Ｃ

笔记：

        int a[6] = '{1,2,2,5,6,7,7,7}; a.max的值是{7},.max方法用于查找数组中的最大值，只返回一个值。

62、以下关于字符串的内置方法，使用错误的是：

string s="abc";
int a,b;
initial begin
    a = s.len();
    b = s.getc(1);
end 

Ａ　a的值是3，b的值是97

Ｂ　a的值是4，b的值是97

Ｃ　a的值是4，b的值是98

Ｄ　a的值是3，b的值是98

答案：Ｄ

笔记：

s.len()返回字符串的长度，不包含终结字符。a的值是3。

s.getc()返回s中的ASCII码，b对应的是98；

63、在SystemVerilog中有如下语句，在完成随机化之后，a的值为5的概率是多少：

rand int [9:0]a;
constraint c{
    a dist {5:=10,[1:3] :=10};
}; 

Ａ　1/4

Ｂ　1/2

Ｃ　1/3

Ｄ　1/5

答案：Ａ

笔记：

考察知识点：随机约束-权重分布

1. 关键词dist用来产生随机数的权重分布。

2. := 操作符表示取值范围内每个数值的取值权重是一样的，:/代表将权重平均分给取值范围内的每个数值。

3. 权重的和不用是100

4. 值和权重可以是常数或者变量

64、对于systemverilog的函数和任务（function / task）  ，描述不正确的是

Ａ　两个都是子函数的调用

Ｂ　可以存在两个名字完全相同的函数和任务

Ｃ　函数的执行可以跨越时间

Ｄ　可以将函数声明成void类型

答案：Ｃ

笔记：

函数里不能存在时间延迟，函数需要立即返回。

65、在system verilog中，以下哪一个语句存在语法错误：

Ａ　int aa [4]  =   [1,2,4,8];

Ｂ　int bb [5]; bb = '{5{8}};

Ｃ　bit [31:0] cc[5] = '{5{5}};

Ｄ　int dd = 0; int ee =dd;

答案：Ａ

笔记：

数组的初始化应该使用 ‘{}符号，而不是[]符号。

'{5{8}}表示5个8，等同于 '{8,8,8,8,8} 是system verilog语法所允许的。

66、system verilog相比于verilog-1995引入的数据类型不包括：

Ａ　logic

Ｂ　byte

Ｃ　int

Ｄ　integer

答案：Ｄ

笔记：

        integer在verilog-1995版本中已经存在，不属于system verilog新引入的数据类型。其余三个均是system verilog新引入的数据类型。

67、下面的选项中说法错误的是（）？

Ａ　System Verilog不能回收一个被句柄引用的对象

Ｂ　如果对象包含有从一个线程派生出来的程序，那么只要该线程仍在运行，这个对象的空间就不会被释放

Ｃ　System Verilog中，可以通过预增量（pre-increment）操作来改变一个无类型指针

Ｄ　任何被一个子线程所使用对象在该线程没有结束之前不会被解除分配

答案：Ｃ

笔记：

         System Verilog的句柄只能指向一种类型，即所谓的”安全类型“。在C中，一个典型的无类型指针只是内存中的一个地址，你可以将它设为任何数值，还可以通过预增量操作来改变它。但是System Verilog不允许对句柄作和C类似的改变，也不允许将一种类型的句柄指向另一种类型。

    因此，C选项是错误的

68、流操作符<<和>>用于赋值表达式的右边，后面带表达式、结构或数组。下面的代码是关于基本的流操作。请问，h的结果最终是（）？

initial begin 
    int h;
    bit [7:0] j[4]='{8'ha,8'hb,8'hc,8'hd};
    h={<<{j}};
end

Ａ　32'h0a0b0c0d

Ｂ　32'hb030d050

Ｃ　32'h0d0c0b0a

Ｄ　32'h0b030d05

答案：Ｂ

笔记：

bit [7:0] j[4]='{8'ha,8'hb,8'hc,8'hd};
// 即j = 0a0b0c0d -> 00001010 00001011 00001100 00001101
h={<<{j}};
// 即h = 10110000 00110000 11010000 01010000 = b030d050

69、下面的选项中说法错误的是（）？

A  对于每一个类来讲，System Verilog创建一个默认的new函数来分配并初始化对象

B  new函数不能有返回值

C  假设一个类中有多个构造函数中有new函数，可以根据赋值操作符左边的句柄类型决定调用哪个new函数

D  new函数的格式是 句柄=new[ ]

答案：D

笔记：

        new[ ]是用来设置动态数组大小的。new( )和new[ ]都是用来申请内存并初始化变量。两者最大的不同在于调用new( )函数仅创建了一个对象，而new[ ]操作则建立一个含有多个元素的数组。new( ) 可以使用参数设置对象的数值，而new[ ]只需使用一个数值来设置数组的大小。

    因此，D选项的说法是错误的。

70、关于System Verilog类中变量的声明，说法正确的是：

A  默认情况下，system verilog中的变量声明是local类型

B  声明为static的变量，在仿真过程中数值不能改变

C  如果system verilog中的变量声明是public类型，则允许在对象外部进行访问

D  其他选项都不对

答案：C

笔记：

默认情况下，system verilog中的变量声明是public类型

声明为static的变量，在仿真过程中数值可以改变

如果system verilog中的变量声明是public类型，则允许在对象外部进行访问

71、可以通过子类访问的类的成员类型有：

A  public的类成员，local的类成员

B  public的类成员，protected的类成员

C  public的类成员，local的类成员，local的类成员

D  protected的类成员，local的类成员

答案：B

笔记：

public(默认类型)：该类、子类、外部均可访问

protected：该类、子类可访问

local：只有该类可以访问

72、System Verilog中引进了一种新的数据类型---队列，它结合了链表和数组的优点。队列和链表相似，可以在有一个队列中的任何地方增加或删除元素。下面是关于队列操作的代码。请问j的结果最后是（）？

int j=1;
q[$]={0,1,2};
initial begin
    j=q[$];
end

A  0

B  1

C  2

D  3

答案：C

笔记：

j=q[$];的含义是将q队列最后一个元素的值传给j，q队列最后一个元素为2，因此j的值为2。

73、观察如下的代码，请问在（）ns，会输出“第四条语句”语句？

`timescale 1ns / 1ns
 
initial begin
    $display("第一条语句");
    #10 $display("第二条语句");
    fork 
        $display("第三条语句");
        #50 $display("第四条语句");
        #10 $display("第五条语句");
        begin
            #30 $display("第六条语句");
            #10 $display("第七条语句");
        end
    join
    $display("第八条语句");
    #80 $display("第九条语句");
end

A  40

B  50

C  60

D  70

答案：C

笔记：

begin...end中的语句以顺序方式执行，而fork...join中的语句以并发方式执行。

整个代码结果输出时间为：

    0ns时，输出“第一条语句”

    10ns时，输出“第二条语句”

    10ns时，输出“第三条语句”

    20ns时，输出“第五条语句”

    40ns时，输出“第六条语句”

    50ns时，输出“第七条语句”

    60ns时，输出“第四条语句”

    60ns时，输出“第八条语句”

    140ns时，输出“第九条语句”

因此，“第四条语句”输出时间是60ns

相关题：76、95、99

74、继承是面向对象编程的一个重要特征，以下关于system verilog中继承的说法错误的是：

A  继承的关键字是 extends

B  子类继承父类的所有数据成员和方法

C  一个子类可以继承多个父类

D  子类可以通过 super操作符引用父类中的方法和成员

答案：C

笔记：

system verilog 所提供的机制被称为单一继承（类似java）， 也就是说， 每一个子类都由唯一的父类继承而来

75、在system verilog中，执行以下的赋值语句(略去其他部分语句），以下选项正确的是：

wire [3:0]a,c;

wire [3:0]a,c;
...
assgin a = 5'b11100;
assgin c = 2'b01

A  a的值是 1110

B  a的值是 11100

C  c的值是 0001

D  c的值是 1101

答案：C

笔记：

在system verilog的赋值语句中，如果将超过变量位数的值赋予某一个变量，则会自动截去高位，只保留地位。a的值是 1100.

当位数不足时，将数值赋予变量的低位，对于无符号数高位为0. 对于有符号数，高位补充符号位。c是无符号数，所以c的值是0001.

76、观察如下的代码，请问在（）ns，会输出“第九条语句”语句？

`timescale 1ns / 1ns
 
initial begin
    $display("第一条语句");
    #10 $display("第二条语句");
    fork 
        $display("第三条语句");
        #50 $display("第四条语句");
        #10 $display("第五条语句");
        begin
            #30 $display("第六条语句");
            #10 $display("第七条语句");
        end
    join
    $display("第八条语句");
    #80 $display("第九条语句");
end

A  140

B  160

C  150

D  130

答案：A

笔记：

begin...end中的语句以顺序方式执行，而fork...join中的语句以并发方式执行。

整个代码结果输出时间为：

    0ns时，输出“第一条语句”

    10ns时，输出“第二条语句”

    10ns时，输出“第三条语句”

    20ns时，输出“第五条语句”

    40ns时，输出“第六条语句”

    50ns时，输出“第七条语句”

    60ns时，输出“第四条语句”

    60ns时，输出“第八条语句”

    140ns时，输出“第九条语句”

因此，“第九条语句”输出时间是140ns

相关题：73、95、99

77、以下描述正确的是：

A  begin...end中的语句以并行方式执行

B  fork...join中的语句以并行方式执行，不需要等其中的语句执行完成，直接开始后续的处理

C  fork...join_none中的语句以并行方式执行,同时等其中的所有的语句执行完成，才开始后续的处理

D  fork...join_any中的语句以并行方式执行，只有其中有一个语句执行完成，就开始后续的处理

答案：D

笔记：

begin...end中的语句以顺序方式执行，

fork...join中的语句以并行方式执行，同时等其中的所有的语句执行完成，才开始后续的处理

fork...join_none中的语句以并行方式执行,不需要等其中的语句执行完成，直接开始后续的处理

78、System Verilog中，在把双状态变量连接到被测设计，尤其是被测设计的输出时务必要小心。如果被测设计试图产生X或者Z，这些值会被转换成双状态值，而测试代码可能永远也察觉不了。这些值被转换成了0还是1并不重要，重要的是要随时检查未知值的传播。使用（）操作符，可以在表达式的任意位出现X或者Z时返回1。

A  $fwrite

B  $fseek

C  $isunknown

D  $fstrobe

答案：C

笔记：

$fwrite的作用是打印信息到屏幕上，类似于$display

$fseek，文件定位，可以从任意点对文件进行操作

$fstrobe 和 $strobe 使用函数使用类似，都是在时间节点到达时，执行函数

因此，应该选择C选项

79、当display显示a=1时候，求b显示是什么： 

 always @(posedge clk or negedeg rst) begin
 if (rst == 0) begin
   a=0;
   b=0;
 end
 else begin
   a = a+1;
   b = a;
   $display("%0t a=%0d,b=%0d",$time,a,b);
 end
end 

A  2

B  0

C  1

D  3

答案：C

笔记：

使用阻塞赋值，b在a加一后得到a的值，因此为1

80、对于System Verilog中函数的描述正确的：

A  函数中可以包含延时

B  函数必须有返回值

C  函数可以调用耗时的任务或者其他函数

D  函数可以不需要输入参数

答案：D

笔记：

        在Verilog-1995规定的函数必须有返回值，但是System Verilog通过void定义的函数没有返回值，这样就能被任何任务或者函数调用。

函数不能包含延时，同时也不可以调用耗时的任务。

81、Verilog和OOP都具有例化的概念，但是在细节方面却存在一些区别。下面的选项中关于Verilog和OOP中例化的概念说法错误的是（）。

A  Verilog中的例化是动态的

B  System Verilog类在使用前必须先例化

C  Verilog的实例名只可以指向一个实例

D  System Verilog句柄可以指向很多对象，当然一次只能指向一个

答案：A

笔记：

        Verilog的例化是静态的，就像硬件一样在仿真的时候不会变化，只有信号值在改变。因此，A选项是错误的。

82、求下面运行完成后niu1的值（）和niu2的值（）

module niukewang;
int niu1,niu2,r;
function int count1(input int a )
    r = a+r;
    return r;
endfunction
function automatic int count2(input int a )
    int r;
    r = a+r;
    return r;
endfunction
initial begin
    niu1=1;
    niu2=1;
    niu1=count1(niu1);
    niu2=count1(niu2);
    niu2=count2(niu2);
    niu1=count2(niu1);
end
endmodule 

A  6 4

B  2 1

C  4 6

D  2 4

答案：B

笔记：

考虑静态函数和动态函数的值的累积问题，得到

niu1=1;

niu2=1;

niu1=count1(niu1); 此处niu1=1 r=1

niu2=count1(niu2); 此处niu2=1 r为动态变量，值清空  r=a+0=1

niu2=count2(niu2); 此处niu2=1 r为动态变量，值清空 r=a+0=1

niu1=count2(niu1); 此处niu1=2

83、System Verilog 相比于verilog-1995新引入了 string字符串类型，以下关于字符串类型说法错误的是？

string s,a;

 s = "SVSVSV";

A  $display(s.getc(1));   显示"V"

B  a=s.tolower();        a的内容为："svsvsv"

C  a=s.substr(2,5));   a的内容为："SVSV"

D  s = {s,"sv"};        s的内容变为："SVSVsv"

答案：D

笔记：

{}为拼接符号。s = {s,"sv"};        s的内容变为："SVSVSVsv"

84、对于systemverilog，下面关于枚举类型不正确的是：

A  枚举类型值在没有显示指定时，默认int从1自加。

B  同类型枚举变量可以互相赋值

C  label和value的值都是唯一的

D  从包中导入enum时，只导入定义名时不会自动导入枚举值标签

答案：A

笔记：

枚举类型值在没有显示指定时，默认int从0自加。

85、下列正确的是？

reg [2:0] A = 3'b1X0;
 
reg [2:0] B = 3’b1X0;
 
wire c,d;
 
assign c = (A==B);
 
assign d= (A===B);

A  c的值是1,d的值是1

B  c的值是x,d的值是x

C  c的值是x,d的值是1

D  c的值是1,d的值是x

答案：C

86、约束块中有如下语句，关于d的取值说法错误的是：

rand bit [8:0] d;
int e[5] = '{1,1,2,2,3,3,3};
constraint c{
    d inside e;
}; 

A  d的取值范围是：1或2或3

B  d = 3的概率最大

C  2，3选取的概率相同

D  1，2选取的概率相同

答案：B

笔记：

几何中每一个值取出的概率是相同的，即使值在数组中出现多次。

87、在system verilog中，执行以下的赋值语句(略去其他部分语句），以下选项正确的是：

logic signed [3:0]  a= -4'b0001;
logic [3:0] b；
logic signed [4:0] c;
...
assign b = unsigned'(a);
assign c = a; 

A  b的值是 0001

B  b的值是 1001

C  c的值是 01111

D  c的值是 11111

答案：D

笔记：

        a声明为有符号变量，初始化为-1，则a的值是 1111（-1的补码）。使用unsigned'()做类型转化时，不改变数据的内容。所以b的值仍是 1111,但因为b是无符号数，所以b的十进制值等于 15。

        在执行赋值操作时，当位数不足时，将数值赋予变量的低位，对于无符号数高位补0. 对于有符号数，高位补充符号位。c是有符号数，高位补符号位1，所以c的值是11111.

        补充：

        logic signed [3:0]  a= -4'b0001;

        signed以补码存储，即4'b1111

88、以下关于module和program的区别说法错误的：

A  program内部不能包含always语句块，而module可以

B  program不能调用module

C  program可以调用其他program中task或function

D  module不能调用program中的task或function

答案：B

笔记：

        加入program的目的是为了解决testbech和RTL信号可能产生的竞争冒险现象。program和module的区别主要有三点，
        一、module里可以定义program，而program里不能定义module;
        二、是module里不能调用program里定义的task, function，而program可以调用module里定义的task和function；
        三、program里不能例化module,interface,其它program,也不能包含always块·。
        四、最主要的区别是program是在inactive时域执行的，而module在active时域执行的，所以program在module后执行，可以解决竞争冒险现象

89、System Verilog支持枚举类型，关于以下语句，说法正确的是：

typedef enum {init,sta1=2,sta2} test_e;
int a,b,c;
initial begin
    a = init;
    b = sta1;
    c = sta2;
end

A  a的值是0

B  b的值是1

C  c的值是2

D  a的值是1

答案：D

笔记：

第一个枚举常量init的值默认是0

第二个枚举常量指定为2，后续的枚举常量自动加一，并不影响前面的枚举常量

90、在system Verilog中，对于队列的操作说法错误的是：

q[$] = {1,2,3,3,3,4};

A  q.insert(1,1);  在2前面插入1

B  p[$] = {0,0,0}; q.insert(2,p); 在2后面插入队列p

C  int a; a = q.pop_back; a的值是4

D  q.delete(3)； 删除队列中所有的3

答案：D

笔记：

q.delete(3)；表示删除队列中索引值为3的元素，而不是等于3的所有元素。

91、执行以下的语句，下列选项错误的是：

int h;
bit [7:0] a,b,c,d;
bit [7:0] e [4] = '{8'ha,8'hb,8'hc,8'hd}
initial begin
    {>>{a,b,c,d}} = e;
    h = {<<byte{e}}
end 

A  a的值是 8’ha，h的值是 0d0c0b0a.

B  a的值是 8’hd，h的值是 0a0b0c0d.

C  a的值是 8’hd，h的值是 0d0c0b0a.

D  a的值是 8’ha，h的值是 0a0b0c0d.

答案：A

笔记：

        流操作符 >>,<<的使用很灵活，可以用在等号的右侧，也可以用作等号的左侧。>>表示顺序，数据的高位低位保持不变，<<表示倒序，byte表示按字节倒序，字节内部的数据顺序保持不变

92、System Verilog中可以产生随机变量，执行以下语句，下列选项错误的是：

A  a的范围是13-19。

B  randomize()函数为类中所有的rand,randc类型的随机变量赋予一个随机值。

C  constraint c{a>12;a<20};  等同于    constraint c{12<a<20};

D  randc类型表示周期随机性，所有可能值都被赋值过后才可能重复

答案：C

笔记：

        见绿皮书139页，约束块中一个表达式只能有一个关系操作符（<，>， <=， >= ，==）

93、对于任何一种新型的验证方法学来讲，分层的测试平台是一个关键的概念。虽然分层似乎会使测试平台变得更加复杂，但它能够把代码分而治之，确实有助于减轻工作负担。下面选项中，关于检验器的定义正确的是？

A  负责比较来自监视器和记分板的命令

B  用于预测事务结果

C  穿过命令层和信号层，负责监视独立的信号以寻找穿越整个命令的信号变化

D  负责检测信号的变化，并把这些变化按照命令分组

答案：A

笔记：

记分板用于预测事务结果，所以B选项是记分板的概念。

断言穿过命令层和信号层，负责监视独立的信号以寻找穿越整个命令的信号变化，所以C选项是断言的概念。

监视器负责检测信号的变化，并把这些变化按照命令分组，所以D选项是监视器的概念。

综上，应该选择A选项。

相关题：14、24、48

94、System Verilog中有好几种类型的变量。下面关于创建常量说法错误的是（）？

A  宏具有全局作用范围并且可以用于位段和类型定义

B  System Verilog支持const修饰符，允许在变量声明时对其进行初始化，在过程代码中改变其值

C  宏定义需要使用“ ` ”符号，这样它才能被编译器识别和扩展

D  Verilog-2001增加了带类型的parameter，但其有限的作用范围仍然使得它无法获得广泛的应用

答案：B

笔记：

        System Verilog支持const修饰符，允许在变量声明时对其进行初始化，但不能在过程代码中改变其值。因此，B选项是错误的

95、System Verilog引入了两种新的创建线程的方法---使用fork...join_none和fork...join_any。观察如下的代码，请问在（）ns，会输出“第九条语句”语句？

`timescale 1ns / 1ns
 
initial begin
    $display("第一条语句");
    #10 $display("第二条语句");
    fork 
        $display("第三条语句");
        #50 $display("第四条语句");
        #10 $display("第五条语句");
        begin
            #30 $display("第六条语句");
            #10 $display("第七条语句");
        end
    join_any
    $display("第八条语句");
    #80 $display("第九条语句");
end

A  60

B  70

C  80

D  90

答案：

笔记：

fork...join_any块对块内语句进行调度，当第一个语句完成后，父线程才继续执行，其他停顿的线程也得以继续。

整个代码结果输出时间为：

     0ns时，输出“第一条语句”

    10ns时，输出“第二条语句”

    10ns时，输出“第三条语句”

    10ns时，输出“第八条语句”

    20ns时，输出“第五条语句”

    40ns时，输出“第六条语句”

    50ns时，输出“第七条语句”

    60ns时，输出“第四条语句”

    90ns时，输出“第九条语句”

因此，“第九条语句”输出时间是90ns

相关题：73、76、99

96、以下关于覆盖率说法错误的是：

A  当功能覆盖率达到100%，可以说明设计没有问题

B  覆盖率主要包括功能覆盖率，代码覆盖率和断言覆盖率

C  状态机覆盖率，条件覆盖率属于代码覆盖率

D  代码覆盖率达到100%不能说明设计没有问题

答案：A

笔记：

        当功能覆盖率达到100%，不可以说明设计没有问题。

        补充：

        代码覆盖率和功能覆盖率是独立的两种覆盖率，代码覆盖率 100%只能表明代码经 过了充分的执行，但是代码中是否有 bug 以及 bug 是否会被发现，取决于验证环境 中的监测点是否监测了关键信号以及对这些信号的判断是否正确。

97、下面关于类的描述正确的是

A  类中定义的变量可以是wire

B  指向对象的句柄有且只能有一个

C  一个类对应一个对象

D  类可以定义变量也可以定义方法

答案：D

笔记：

class（类）是软件对象的概念，里面的变量是软件概念为动态变量，不可以定义硬件变量，一个类可以有多个映射指向多个对象

98、约束块中有如下语句，关于各个变量的取值说法正确的是：

rand bit [3:0] a,b,c,d;
constraint c{
    a < b;
    b = c;
    b > 5;
    c <10;
}; 

A  c的取值范围是 0 ≤ c＜10；

B  b的取值范围是 5 < b＜10；

C  b的取值范围是 5 ≤ b＜15；

D  a可能为11；

答案：B

笔记：

        SystemVerilog的约束并不是自上而下执行的程序性代码，而是并行的，即所有的表达式同时有效。同时System Verilog中的约束是双向的，会同时计算所有的随机变量的约束。

b = c，而且b>5,c<10。所以包含了隐式的约束条件：b<10和c>5。

99、System Verilog引入了两种新的创建线程的方法---使用fork...join_none和fork...join_any。观察如下的代码，请问在（）ns，会输出“第六条语句”语句？

`timescale 1ns / 1ns
 
initial begin
    $display("第一条语句");
    #10 $display("第二条语句");
    fork 
        $display("第三条语句");
        #50 $display("第四条语句");
        #10 $display("第五条语句");
        begin
            #30 $display("第六条语句");
            #10 $display("第七条语句");
        end
    join_any
    $display("第八条语句");
    #80 $display("第九条语句");
end

A  20

B  30

C  40

D  50

答案：C

笔记：

fork...join_any块对块内语句进行调度，当第一个语句完成后，父线程才继续执行，其他停顿的线程也得以继续。

整个代码结果输出时间为：

     0ns时，输出“第一条语句”

    10ns时，输出“第二条语句”

    10ns时，输出“第三条语句”

    10ns时，输出“第八条语句”

    20ns时，输出“第五条语句”

    40ns时，输出“第六条语句”

    50ns时，输出“第七条语句”

    60ns时，输出“第四条语句”

    90ns时，输出“第九条语句”

因此，“第六条语句”输出时间是40ns

相关题：73、76、95

100、相比四状态数据类型，System Verilog引入的双状态数据类型有利于提高仿真器的性能并减少内存的使用量。下面选项中，关于System Verilog双状态数据类型说法错误的是（）？

A  bit数据类型是双状态，单比特，无符号的

B  int数据类型是双状态，32比特有符号整数

C  longint数据类型是双状态，32位有符号整数

D  real数据类型是双状态，双精度浮点数

答案：C

笔记：

System Verilog中带符号的数据类型：

    bit b;                    //双状态，单比特

    bit [31:0] b32;      //双状态，32比特无符号整数

    int unsigned ui;    //双状态，32比特无符号整数

    int i;                     //双状态，32比特有符号整数

    byte b8;               //双状态，8比特有符号整数

    shortint s;            //双状态，16比特有符号整数

    longint l;              //双状态，64比特有符号整数

    integer i4;           //四状态，32比特有符号整数

    time t;                 //四状态，64比特无符号整数

    real r;                 //双状态， 双精度浮点数

101、下面的选项中关于覆盖组的说法错误的是（）？

A  覆盖组一次定义后便可以进行多次实例化

B  覆盖组可以定义在类里，也可以定义在程序或模块层次上

C  一个覆盖组在收集数据前，不一定要被实例化

D  一个类可以包含多个覆盖组

答案：C

笔记：

一个覆盖组必须被实例化后才可以用来收集数据。如果忘记实例化覆盖组，在运行时不会打印出没有句柄的错误信息，但是覆盖率报告里将没有这个覆盖组的任何踪迹。因此，C选项是错误的。

102、在system verilog中有如下的语句，下列说法正确的是：

class A;
   rand bit [3:0] a;
   constraint c { soft a >= 4;
                     a <= 12; }
endclass
initial begin
    A class_a = new();
    class_a.radomize with (a<4);
end 

A  约束块c和 with约束冲突，无法完成随机化

B  可以正常随机化，a的取值范围是  a≤12

C  可以正常随机化，a的取值范围是  4≤a≤12

D  可以正常随机化，a的取值范围是  a<4

答案：D

笔记：

soft软约束， a >= 4; 声明为soft在约束发生冲突时该约束不生效。所以a的取值范围由with语句决定。

103、面向对象编程（OOP）使用户能够创建复杂的数据类型，并且将它们跟使用这些数据类型的程序紧密的结合在一起。下面选项中是Verilog-2001中常用的术语。请问OOP术语中的对象，和下面哪个选项是大致对应的？

A  模块

B  实例化一个模块

C  reg或者wire类型的信号

D  initial、always块、任务和函数

答案：B

笔记：

下面是一些OOP的术语、定义以及它们与Verilog-2001的大致的对应关系。

相关题：40

104、在某个类中，有如下定义，下列选项描述正确的是：

 rand int  x;
constraint c{ x!=20;x dist {10:=1,20:=2,30:=5};} 

A  x取值为10的概率是 1/8

B  约束条件冲突，不能随机化

C  x取值为30的概率是5/6

D  x的取值范围是：10，20，30

答案：

笔记：

约束语句是并行的，上述两个语句不构成冲突

105、以下关于 generate for语句，说法正确的是：

A  循环变量使用 integer声明

B  循环表达式的中的循环变量的值可以通过IO口传入的数据确定

C  如果需要复制的语句只有一行，则可以省略 begin...end关键字

D  必须是generate开始，endgenerate结束

答案：D

笔记：

必须使用genvar申明一个正整数变量

generate-if中的条件只能是静态变量，如 genvar，parameter 等，必须在整个程序运行期间保持不变。需要复制的语句必须写到begin_end语句里面，即便只有一句

106、在System Verilog中有以下语句，下列选项正确的是：

 int a;
 integer b;
 reg c,d;
 initial begin
    c = (a==b);
    d = (a===b);
 end 

A  c的值是x,d的值是1

B  c的值是x,d的值是0

C  c的值是1,d的值是1

D  c的值是0,d的值是0

答案：B

笔记：

二值逻辑数据类型不初始化，则默认是0；四值逻辑数据类型不初始化，则默认是x。

== 不对x,z进行判断，当出现x,z的时候，结果为x。所以，c=x；

=== 可以对x,z进行判断，只有各个比特位上的数都对应，结果才为1. 0和x不对应，所以 d=0

107、System Verilog中有四个主要的调度区域，分别是：active、observed、reactive、postponed。请问下面哪个选项是observed的行为？

A  仿真模块中的设计代码

B  执行System Verilog断言

C  执行程序中的测试平台部分

D  为测试平台的输入采样信号

答案：B

笔记：

绿皮书77页，下面的表格是System Verilog主要的调度区域：

区域名	行为
active	仿真模块中的设计代码
observed	执行System Verilog断言
reactive	执行程序中的测试平台部分
postponed	为测试平台的输入采样信号

 108、对于systemverilog，下面对于静态数组描述不正确的是：

A  包含两种，压缩和非压缩

B  [5:0]bit[3]中，压缩的维数是6

C  bit\byte\reg等数据类型可以定义为压缩数组

答案：C

笔记：

在sv中，静态数组扩展了原始数组概念，引入了两种类型的数组：压缩数组和非压缩数组，bit和logic这种数据宽度>=1的可以被定义为压缩数组，但是int这种预定义了数据宽度的不可被定为压缩数组（具有预定义宽度的整数类型不能声明成压缩数组，byte shortint int longint不能是压缩数组的类型）。

109、System Verilog包含了多种数据类型，以下选项正确的是：

A  reg [4:0] a;  a是4比特无符号数。

B  int b;    b是32比特无符号数。

C  integer c;  c是64比特有符号数。

D  byte d;   d可以取的最大值是127

答案：D

笔记：

reg [4:0] a;  a是5比特无符号数。

int b;    b是32比特有符号数。

integer c;  c是32比特有符号数。和int的区别是：int是双状态类型，integer是四状态类型。

byte d； d是8比特有符号整数。最大值取127。

110、对于systemverilog程序块 ，描述不正确的是

A  在程序块中的本地变量进行赋值要采用非阻塞赋值语句

B  封装了验证程序数据、 函数和任务

C  不能包含 always块

D  程序块内的类型和数据声明对于程序块的作用范围来讲是本地的，局限于程序块内部使用

答案：A

笔记：

见绿皮书83页

• 程序块(program)内部定义的变量赋值的方式采用阻塞赋值（软件方式）
• 程序块内部在驱动外部的硬件信号时应使用非阻塞赋值（硬件方式）
• 如果tb有多个程序块，则需要等待所有程序块中最后一个initial过程完成才能结束仿真
• 如果加入了always块，仿真永远不会结束，除非调用$exit

111、当你使用一个变量名的时候，System Verilog将先在当前作用域内寻找，接着在上一级作用域内寻找，直到找到该变量为止。这也是Verilog所采取的算法。但是如果你在类的很深的底层作用域，却想明确的引用类一级的对象呢？请问这时可以使用（）关键词来引用？

A  this

B  that

C  these

D  those

答案：A

笔记：

如下面代码，关键词“this”明确的告诉System Verilog正在将局部变量oname赋给类一级变量oname。

class Scoping;
    string oname;
    
    function new(string oname);
        this.oname=oname;
    endfunction 
endclass

112、下列关于断言的描述错误的是：

A  断言可以分为立即断言和并行断言

B  立即断言不需要时钟

C  并行断言要有时钟，可以是定义断言时声明的时钟，也可以是断言中包含的sequence的时钟

D  并行断言只能在过程块、module中定义，不能在interface和program中定义。

答案：

笔记：

可以在过程块、module、interface和program块内定义并发断言

113、在system verilog中有以下代码，描述正确的是;

 int a = [$];
 int b,c;
 int n;
 initial begin
    a = {1,3,5,7,9};
    b = 6;
    c = 8;
    a = {a,b};
    n = a.size();
    c = a[$];
 end 

A  n的值是6，c的值是8；

B  b的值是6，c的值是8；

C  n的值是5，c的值是9；

D  n的值是6，c的值是6；

答案：D

笔记：

a = {a,b}; 将队列a和整型变量b拼接之后赋值给a。a = {1,3,5,7,9,6}; 长度是6。

所有执行n = a.size(), n=6.

c = a[$]; 表示取a的最后一个值，所以c = 6.

114、在system verilog中，下列关于logic说法正确的是：

A  logic数据类型和wire数据类型相同，可以有多个驱动

B  logic可以在always语句块中使用阻塞赋值

C  logic是双状态数据类型

D  logic是有符号数据类型

答案：B

笔记：

logic类型可以代替reg类型和部分wire类型的功能，是四状态无符号数据类型。但不同于wire,logic不能有多个驱动。

因为可以代替reg类型，所以可以在always语句块中使用阻塞赋值。

115、观察下面的代码。请问最后输出的结果是什么？

event e1,e2;
initial begin
    $display("第一条语句");
    -> e1;
    @e2;
    $display("第二条语句");
end
initial begin
    $display("第三条语句");
    -> e2;
    @e1;
    $display("第四条语句");
end

A                                                                                B

第一条语句                                                                第一条语句

第二条语句                                                                第二条语句

第三条语句                                                                第三条语句

第四条语句

C                                                                               D

第一条语句                                                                第一条语句

第三条语句                                                                第三条语句

第二条语句                                                                第二条语句

                                                                                  第四条语句

答案：C

笔记：

         见绿皮书193页，当运行代码的时候，第一个初始化块启动，触发e1事件，然后阻塞在另一个事件上。第二个初始化块启动，触发e2事件（唤醒第一个块），然后则阻塞在第一个事件上。但是，因为第一个事件是一个零宽度的脉冲，所以第二个线程会因为错过第一个事件而被锁住。

因此，输出结果是：        

        第一条语句

        第三条语句

        第二条语句

116、下面哪一个语句可以在program中定义或者添加

A  initial

B  always

C  interface

D  module

答案：A

笔记：

        program属于软件的范畴，不能出现硬件的描述。initial软件领域，always硬件领域，interface软硬件接口领域，module硬件领域