UVM 中的TLM1.0 通信

UVM中的各种端口就可以实现这样的功能, 在monitor和 scoreboard之间专门建立一个通道，让信息只能在这个通道内流动， scoreboard也只能从这个通道中接收信息，
这样几乎就可以保证scoreboard中的信息只能从monitor中来，而不能从别的地方来；同时赋予这个通道阻塞或者非阻塞等特性。
这就省去了用户浪费大量时间编写通信相关的代码.

TLM 的定义

TLM是Transaction Level Modeling（事务级建模）的缩写, 它起源于SystemC的一种通信标准。所谓transaction level是相对
DUT中各个模块之间信号线级别的通信来说的。简单来说，一个transaction就是把具有某一特定功能的一组信息封装在一起而成为
的一个类。如my_transaction就是把一个MAC帧里的各个字段封装在了一起。

put

通信的发起者A把一个transaction发送给B。在这个过程中， A称为“发起者”，而B称为“目标”。
A具有的端口（用方框表示）称为PORT，而B的端口（用圆圈表示）称为EXPORT。这个过程中，数据流是从A流向B的

get

A向B索取一个transaction。在这个过程中， A依然是“发起者”， B依然是“目标”， A上的端口依然是
PORT，而B上的端口依然是EXPORT。这个过程中，数据流是从B流向A的。到这里，读者应该意识到， PORT和EXPORT体现的
是控制流而不是数据流。因为在put操作中，数据流是从PORT流向EXPORT的，而在get操作中，数据是从EXPORT流向PORT
的。但是无论是get还是put操作，其发起者拥有的都是PORT端口，而不是EXPORT。作为一个EXPORT来说，只能被动地接收
PORT的命令

transport

transport操作相当于一次put操作加一次get操作，这两次操作的“发起者”都是A，目标都是 B。
A上的端口依然是PORT，而B上的端口依然是EXPORT。在这个过程中，数据流先从A流向B，再从B流向A。
在现实世界中，相当于是A向B提交了一个请求(request) ，而B返回给A一个应答(response)。
所以这种transport操作也常常被称做request-response操作

put、 get和transport操作都有阻塞和非阻塞之分

UVM中的PORT与EXPORT

常用的PORT 有

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


uvm_blocking_put_port#(T);
uvm_nonblocking_put_port#(T);
uvm_put_port#(T);
uvm_blocking_get_port#(T);
uvm_nonblocking_get_port#(T);
uvm_get_port#(T);
uvm_blocking_peek_port#(T);
uvm_nonblocking_peek_port#(T);
uvm_peek_port#(T);
uvm_blocking_get_peek_port#(T);
uvm_nonblocking_get_peek_port#(T);
uvm_get_peek_port#(T);
uvm_blocking_transport_port#(REQ, RSP);
uvm_nonblocking_transport_port#(REQ, RSP);
uvm_transport_port#(REQ, RSP);

三个put系列端口对应的是TLM中的put操作，
三个get系列端口对应的是get操作，
三个transport系列端口对应的是则是transport 操作（ request-response操作）
三个peek系列端口，它们与get系列端口类似，用于主动获取数据，它与get 操作的区别将在4.3.4节中看到
三个get_peek系列端口，它集合了get操作和peek操作两者的功能
其中T 表示PORT 中的数据流类型, (REQ, RSP) 表示transport操作中发起请求时传输的数据类型和返回的数据类型
带blocking 的是阻塞
带nonblocking 的是非阻塞
即不带blocking 也不带nonblocking 的是即可以阻塞也可以非阻塞

常用的EXPORT 有

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


uvm_blocking_put_export#(T);
uvm_nonblocking_put_export#(T);
uvm_put_export#(T);
uvm_blocking_get_export#(T);
uvm_nonblocking_get_export#(T);
uvm_get_export#(T);
uvm_blocking_peek_export#(T);
uvm_nonblocking_peek_export#(T);
uvm_peek_export#(T);
uvm_blocking_get_peek_export#(T);
uvm_nonblocking_get_peek_export#(T);
uvm_get_peek_export#(T);
uvm_blocking_transport_export#(REQ, RSP);
uvm_nonblocking_transport_export#(REQ, RSP);
uvm_transport_export#(REQ, RSP);

PORT和EXPORT体现的是一种控制流，在这种控制流中， PORT具有高优先级，而EXPORT具有低优先级。只有高优先级的端口才能向低优先级的端口发起三种操作

UVM 中各种端口的互连

PORT与EXPORT的连接

UVM中使用connect函数来建立连接关系, 如A要和B通信（ A是发起者），那么可以这么写： A.port.connect（ B.export），但
是不能写成B.export.connect（ A.port）。因为在通信的过程中， A是发起者， B是被动承担者。这种通信时的主次顺序也适用于连
接时，只有发起者才能调用connect函数，而被动承担者则作为connect的参数, 示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


文件： src/ch4/section4.2/4.2.1/A.sv
class A extends uvm_component;
    `uvm_component_utils(A)
    uvm_blocking_put_port#(my_transaction) A_port;
    …
endclass
function void A::build_phase(uvm_phase phase);
    super.build_phase(phase);
    A_port = new("A_port", this);
endfunction
task A::main_phase(uvm_phase phase);
endtask

其中A_port在实例化的时候比较奇怪，第一个参数是名字，而第二个参数则是一个uvm_component类型的父结点变量。事实
上，一个uvm_blocking_put_port的new函数的原型如下:

1

function new(string name, uvm_component parent, int min_size = 1; int max_size = 1);

new函数中的min_size和max_size指的是必须连接到这个PORT的下级端口数量的最小值和最大值，
也即这一个PORT应该调用的connect函数的最小值和最大值。如果采用默认值，即min_size=max_size=1，则只能连接一个EXPORT。

B 代码为:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


文件： src/ch4/section4.2/4.2.1/B.sv
class B extends uvm_component;
    `uvm_component_utils(B)
    uvm_blocking_put_export#(my_transaction) B_export;
    …
endclass
function void B::build_phase(uvm_phase phase);
    super.build_phase(phase);
    B_export = new("B_export", this);
endfunction
task B::main_phase(uvm_phase phase);
endtask

在env中建立两者之间的连接：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


文件： src/ch4/section4.2/4.2.1/my_env.sv
class my_env extends uvm_env;
    A A_inst;
    B B_inst;
    …
        virtual function void build_phase(uvm_phase phase);
            …
            A_inst = A::type_id::create("A_inst", this);
            B_inst = B::type_id::create("B_inst", this);
        endfunction
    …
endclass
function void my_env::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    A_inst.A_port.connect(B_inst.B_export);
endfunction

运行上述代码会报错

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


UVM_INFO @ 0: reporter [RNTST] Running test my_case0...
UVM_ERROR @ 0: uvm_test_top.env.B_inst.B_export [Connection Error] connection count of 0 does not meet required minimum of 1
UVM_ERROR @ 0: uvm_test_top.env.A_inst.A_port [Connection Error] connection count of 0 does not meet required minimum of 1
UVM_FATAL @ 0: reporter [BUILDERR] stopping due to build errors

--- UVM Report Summary ---

 Report counts by severity
UVM_INFO :    1
UVM_WARNING :    0
UVM_ERROR :    2
UVM_FATAL :    1
 Report counts by id
[BUILDERR]     1
[Connection Error]     2
[RNTST]     1

原因是连接不完整, 需要IMP

UVM中的IMP

除了TLM中定义的PORT与EXPORT外， UVM中加入了第三种端口： IMP。 IMP才是UVM中的精髓，承担了UVM中TLM的绝
大部分实现代码。 UVM中的IMP如下所示:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


uvm_blocking_put_imp#(T, IMP);
uvm_nonblocking_put_imp#(T, IMP);
uvm_put_imp#(T, IMP);
uvm_blocking_get_imp#(T, IMP);
uvm_nonblocking_get_imp#(T, IMP);
uvm_get_imp#(T, IMP);
uvm_blocking_peek_imp#(T, IMP);
uvm_nonblocking_peek_imp#(T, IMP);
uvm_peek_imp#(T, IMP);
uvm_blocking_get_peek_imp#(T, IMP);
uvm_nonblocking_get_peek_imp#(T, IMP);
uvm_get_peek_imp#(T, IMP);
uvm_blocking_transport_imp#(REQ, RSP, IMP);
uvm_nonblocking_transport_imp#(REQ, RSP, IMP);
uvm_transport_imp#(REQ, RSP, IMP);

按照控制流的优先级排序， UVM中三种端口顺序为： PORT、 EXPORT、 IMP。 IMP的优先级最低，一个PORT可以连接到一个IMP，并发起三种操作，反之则不行。
示例:

A.A_port.put（ transaction）这个任务会调用B.B_export的put， B.B_export的put（ transaction）
又会调用B.B_imp的 put（ transaction），而B_imp.put最终又会调用B的相关任务，如B.put（ transaction）

A 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


文件： src/ch4/section4.2/4.2.2/A.sv
class A extends uvm_component;
    `uvm_component_utils(A)
    uvm_blocking_put_port#(my_transaction) A_port;
    …
endclass
…
task A::main_phase(uvm_phase phase);
    my_transaction tr;
    repeat(10) begin
        #10;
        tr = new("tr");
        assert(tr.randomize());
        A_port.put(tr);
    end
endtask

B 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


文件： src/ch4/section4.2/4.2.2/B.sv
class B extends uvm_component;
    `uvm_component_utils(B)
    uvm_blocking_put_export#(my_transaction) B_export;
    uvm_blocking_put_imp#(my_transaction, B) B_imp;
    …
endclass
…
function void B::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    B_export.connect(B_imp);
endfunction
function void B::put(my_transaction tr);
    `uvm_info("B", "receive a transaction", UVM_LOW)
    tr.print();
endfunction

在B的代码中，关键是要实现一个put函数/任务。如果不实现，将会给出如下的错误提示:

1
2


# ** Error: /home/landy/uvm/uvm-1.1d/src/tlm1/uvm_imps.svh(85): No field named 'put'.
# Region: /uvm_pkg::uvm_blocking_put_imp #(top_tb_sv_unit::my_transaction, top_tb_sv_unit::B)

运行上述代码，可以见到B正确地收到了A发出的transaction。在上述连接关系中， IMP是作为连接的终点。
在UVM中，只有IMP才能作为连接关系的终点。如果是PORT或者EXPORT作为终点，则会报错

PORT 与 IMP 的连接

A 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


文件： src/ch4/section4.2/4.2.2/A.sv
class A extends uvm_component;
    `uvm_component_utils(A)
    uvm_blocking_put_port#(my_transaction) A_port;
    …
endclass
…
task A::main_phase(uvm_phase phase);
    my_transaction tr;
    repeat(10) begin
        #10;
        tr = new("tr");
        assert(tr.randomize());
        A_port.put(tr);
    end
endtask

B 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


文件： src/ch4/section4.2/4.2.3/B.sv
class B extends uvm_component;
    `uvm_component_utils(B)
    uvm_blocking_put_imp#(my_transaction, B) B_imp;
    …
endclass
…
function void B::put(my_transaction tr);
    `uvm_info("B", "receive a transaction", UVM_LOW)
    tr.print();
endfunction

由于A中采用了blocking_put类型的PORT，所以在B中IMP相应的类型是uvm_blocking_put_imp,
env 代码:

1
2
3
4
5


文件： src/ch4/section4.2/4.2.3/my_env.sv
function void my_env::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    A_inst.A_port.connect(B_inst.B_imp);
endfunction

当A_port的类型是blocking_put ， B_imp的类型是blocking_put 时

那么就要在B中定义一个名字为put的函数/任务

当A_port的类型是nonblocking_put ， B_imp的类型是nonblocking_put 时

那么就要在B中定义一个名字为try_put的函数和一个名为can_put的函数

当A_port的类型是put， B_imp的类型是put时

那么就要在B中定义3个接口，一个是put任务/函数，一个是try_put函数，一个是can_put函数。

当A_port的类型是blocking_get， B_imp的类型是blocking_get时

那么就要在B中定义一个名字为get的任务/函数

当A_port的类型是nonblocking_get， B_imp的类型是nonblocking_get时

那么就要在B中定义一个名字为try_get的函数和一个名为can_get的函数

当A_port的类型是get， B_imp的类型是get时

那么就要在B中定义3个接口，一个是get任务/函数，一个是try_get函数，一个是can_get函数

当A_port的类型是blocking_peek， B_imp的类型是blocking_peek时

那么就要在B中定义一个名字为peek的任务/函数

当A_port的类型是nonblocking_peek， B_imp的类型是nonblocking_peek时

那么就要在B中定义一个名字为try_peek的函数和一个名为can_peek的函数

当A_port的类型是peek， B_imp的类型是peek时

那么就要在B中定义3个接口，一个是peek任务/函数，一个是try_peek函数，一个是can_peek函数

当A_port的类型是blocking_get_peek， B_imp的类型是blocking_get_peek时

那么就要在B中定义一个名字为get的任务/函数，一个名字为peek的任务/函数

当A_port的类型是nonblocking_get_peek， B_imp的类型是nonblocking_get_peek时

那么就要在B中定义一个名字为try_get的函数，一个名为can_get的函数，一个名字为try_peek的函数和一个名为can_peek的函数

当A_port的类型是get_peek， B_imp的类型是get_peek时

那么就要在B中定义6个接口，一个是get任务/函数，一个是try_get函数，一个是can_get函数，一个是peek任务/函数，
一个是try_peek函数，一个是can_peek函数

当A_port的类型是blocking_transport， B_imp的类型是blocking_transport时

那么就要在B中定义一个名字为transport的任务/函数。

当A_port的类型是nonblocking_transport， B_imp的类型是nonblocking_transport时

那么就要在B中定义一个名字为nb_transport 的函数

当A_port的类型是transport， B_imp的类型是transport时

那么就要在B中定义两个接口，一个是transport任务/函数，一个是 nb_transport函数

规律总结

在前述的这些规律中，对于所有blocking系列的端口来说，可以定义相应的任务或函数，如对于blocking_put端口来说，可以定
义名字为put的任务，也可以定义名字为put的函数。这是因为A会调用B中名字为put的接口，而不管这个接口的类型。由于A中的
put是个任务，所以B中的put可以是任务，也可以是函数。但是对于nonblocking系列端口来说，只能定义函数。

EXPORT 与 IMP 的连接

要实现A中的EXPORT与B中的IMP连接， A的代码为：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


文件： src/ch4/section4.2/4.2.4/A.sv
class A extends uvm_component;
    `uvm_component_utils(A)
    uvm_blocking_put_export#(my_transaction) A_export;
    …
endclass
…
task A::main_phase(uvm_phase phase);
    my_transaction tr;
    repeat(10) begin
        #10;
        tr = new("tr");
        assert(tr.randomize());
        A_export.put(tr);
    end
endtask

B 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


文件： src/ch4/section4.2/4.2.3/B.sv
class B extends uvm_component;
    `uvm_component_utils(B)
    uvm_blocking_put_imp#(my_transaction, B) B_imp;
    …
endclass
…
function void B::put(my_transaction tr);
    `uvm_info("B", "receive a transaction", UVM_LOW)
    tr.print();
endfunction

env 代码:

1
2
3
4
5


文件： src/ch4/section4.2/4.2.4/my_env.sv
function void my_env::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    A_inst.A_export.connect(B_inst.B_imp);
endfunction

规律与 PORT 和 IMP 的连接一样

PORT 与 PORT 的连接

在UVM中，支持带层次的连接关系

在上图中， A与C中是PORT， B中是IMP。 UVM支持C的PORT连接到A的PORT，并最终连接到B的IMP。
C 的代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


文件： src/ch4/section4.2/4.2.5/C.sv
class C extends uvm_component;
    `uvm_component_utils(C)
    uvm_blocking_put_port#(my_transaction) C_port;
    …
endclass
…
task C::main_phase(uvm_phase phase);
    my_transaction tr;
    repeat(10) begin
        #10;
        tr = new("tr");
        assert(tr.randomize());
        C_port.put(tr);
    end
endtask

A 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


文件： src/ch4/section4.2/4.2.5/A.sv
class A extends uvm_component;
    `uvm_component_utils(A)
    C C_inst;
    uvm_blocking_put_port#(my_transaction) A_port;
    …
endclass
function void A::build_phase(uvm_phase phase);
    super.build_phase(phase);
    A_port = new("A_port", this);
    C_inst = C::type_id::create("C_inst", this);
endfunction
function void A::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    C_inst.C_port.connect(this.A_port);
endfunction
task A::main_phase(uvm_phase phase);
endtask

B 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


文件： src/ch4/section4.2/4.2.5/B.sv
class B extends uvm_component;
    `uvm_component_utils(B)
    uvm_blocking_put_imp#(my_transaction, B) B_imp;
    …
endclass
…
function void B::put(my_transaction tr);
    `uvm_info("B", "receive a transaction", UVM_LOW)
    tr.print();
endfunction

由于A中采用了blocking_put类型的PORT，所以在B中IMP相应的类型是uvm_blocking_put_imp,
env 代码:

1
2
3
4
5


文件： src/ch4/section4.2/4.2.5/my_env.sv
function void my_env::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    A_inst.A_port.connect(B_inst.B_imp);
endfunction

PORT与PORT之间的连接不只局限于两层，可以有无限多层。

EXPORT 与 EXPORT 的连接

在下图中， A中是PORT， B与C中是EXPORT， B中还有一个IMP。 UVM支持C的EXPORT连接到B的EXPORT，并最终连接到B的IMP

C 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


文件： src/ch4/section4.2/4.2.6/C.sv
class C extends uvm_component;
    `uvm_component_utils(C)
    B B_inst;
    uvm_blocking_put_export#(my_transaction) C_export;
    …
endclass
function void C::build_phase(uvm_phase phase);
    super.build_phase(phase);
    C_export = new("C_export", this);
    B_inst = B::type_id::create("B_inst", this);
endfunction
function void C::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    this.C_export.connect(B_inst.B_export);
endfunction
task C::main_phase(uvm_phase phase);
endtask

A 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


文件： src/ch4/section4.2/4.2.5/A.sv
class A extends uvm_component;
    `uvm_component_utils(A)
    uvm_blocking_put_port#(my_transaction) A_port;
    …
endclass
…
task A::main_phase(uvm_phase phase);
    my_transaction tr;
    repeat(10) begin
        #10;
        tr = new("tr");
        assert(tr.randomize());
        A_port.put(tr);
    end
endtask

B 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


文件： src/ch4/section4.2/4.2.5/B.sv
class B extends uvm_component;
    `uvm_component_utils(B)
    uvm_blocking_put_export#(my_transaction) B_export;
    uvm_blocking_put_imp#(my_transaction, B) B_imp;
    …
endclass
…
function void B::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    B_export.connect(B_imp);
endfunction
function void B::put(my_transaction tr);
    `uvm_info("B", "receive a transaction", UVM_LOW)
    tr.print();
endfunction

env 代码:

1
2
3
4
5


文件： src/ch4/section4.2/4.2.6/my_env.sv
function void my_env::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    A_inst.A_port.connect(C_inst.C_export);
endfunction

同样的， EXPORT与EXPORT之间的连接也不只局限于两层，也可以有无限多层

blocking_get端口的使用

get系列端口与put系列端口在某些方面完全相反

在这种连接关系中，数据流依然是从A到B，但是A由动作发起者变成了动作接收者，而B由动作接收者变成了动作发起者。
B_port的类型为uvm_blocking_get_port， A_export的类型为uvm_blocking_get_export， A_imp的类型为uvm_blocking_get_imp。
与 uvm_blocking_put_imp所在的component要实现一个put的函数/任务类似， uvm_blocking_get_imp所在的component要实现一个名字为 get的函数/任务。
A的代码为：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


文件： src/ch4/section4.2/4.2.7/A.sv
class A extends uvm_component;
    `uvm_component_utils(A)
    uvm_blocking_get_export#(my_transaction) A_export;
    uvm_blocking_get_imp#(my_transaction, A) A_imp;
    my_transaction tr_q[$];
    …
endclass
function void A::build_phase(uvm_phase phase);
    super.build_phase(phase);
    A_export = new("A_export", this);
    A_imp = new("A_imp", this);
endfunction
function void A::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    A_export.connect(A_imp);
endfunction
task A::get(output my_transaction tr);
    while(tr_q.size() == 0) #2;
    tr = tr_q.pop_front();
endtask
task A::main_phase(uvm_phase phase);
    my_transaction tr;
    repeat(10) begin
        #10;
        tr = new("tr");
        tr_q.push_back(tr);
    end
endtask

B 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


文件： src/ch4/section4.2/4.2.7/B.sv
class B extends uvm_component;
    `uvm_component_utils(B)
    uvm_blocking_get_port#(my_transaction) B_port;
    …
endclass
function void B::build_phase(uvm_phase phase);
    super.build_phase(phase);
    B_port = new("B_port", this);
endfunction
task B::main_phase(uvm_phase phase);
    my_transaction tr;
    while(1) begin
        B_port.get(tr);
        `uvm_info("B", "get a transaction", UVM_LOW)
        tr.print();
    end
endtask

env 代码:

1
2
3
4
5


文件： src/ch4/section4.2/4.2.7/my_env.sv
function void my_env::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    B_inst.B_port.connect(A_inst.A_export);
endfunction

blocking_transport端口的使用

transport系列端口与put和get系列端口都不一样。在put和get系列端口中，所有的通信都是单向的，而在transport系列端口中，通信变成了双向的

A 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


文件： src/ch4/section4.2/4.2.8/A.sv
class A extends uvm_component;
    `uvm_component_utils(A)
    uvm_blocking_transport_port#(my_transaction, my_transaction) A_transport;
    …
endclass
…
task A::main_phase(uvm_phase phase);
    my_transaction tr;
    my_transaction rsp;
    repeat(10) begin
        #10;
        tr = new("tr");
        assert(tr.randomize());
        A_transport.transport(tr, rsp);
        `uvm_info("A", "received rsp", UVM_MEDIUM)
        rsp.print();
    end
endtask

B 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


文件： src/ch4/section4.2/4.2.8/B.sv
class B extends uvm_component;
    `uvm_component_utils(B)
    uvm_blocking_transport_imp#(my_transaction, my_transaction, B) B_imp;
    …
endclass
…
task B::transport(my_transaction req, output my_transaction rsp);
    `uvm_info("B", "receive a transaction", UVM_LOW)
    req.print();
    //do something according to req
    #5;
    rsp = new("rsp");
    // assert(rsp.randomize());
    rsp.dmac[7:0] = 8'h12;
endtask

env 代码:

1
2
3
4
5


文件： src/ch4/section4.2/4.2.8/my_env.sv
function void my_env::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    A_inst.A_transport.connect(B_inst.B_imp);
endfunction

在A中调用transport任务，并把生成的transaction作为第一个参数。 B中的transaport任务接收到这个transaction，根据这个
transaction做某些操作，并把操作的结果作为transport的第二个参数发送出去。 A根据接收到的rsp来决定后面的行为。

nonblocking端口的使用

nonblocking端口的所有操作都是非阻塞的，换言之，必须用函数实现，而不能用任务实现。下面以nonblocking_put端口为例介绍nonblocking端口的使用
要实现下面连接关系

A 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


文件： src/ch4/section4.2/4.2.9/A.sv
class A extends uvm_component;
    `uvm_component_utils(A)
    uvm_nonblocking_put_port#(my_transaction) A_port;
    …
endclass
…
task A::main_phase(uvm_phase phase);
    my_transaction tr;
    repeat(10) begin
        tr = new("tr");
        assert(tr.randomize());
        while(!A_port.can_put()) #10;
        void'(A_port.try_put(tr));
    end
endtask
// 当不使用 can_put 时
// task A::main_phase(uvm_phase phase);
// my_transaction tr;
// repeat(10) begin
// tr = new("tr");
// assert(tr.randomize());
// while(!A_port.try_put(tr)) #10;
// end
// endtask

由于端口变为了非阻塞的，所以在送出transaction之前需要调用can_put函数来确认是否能够执行put操作。 can_put最终会调用 B中的can_put
其实这里还可以不用can_put，而直接使用try_put：

B 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


文件： src/ch4/section4.2/4.2.9/B.sv
class B extends uvm_component;
    `uvm_component_utils(B)
    uvm_nonblocking_put_imp#(my_transaction, B) B_imp;
    my_transaction tr_q[$];
    …
endclass
…
function bit B::can_put();
    if(tr_q.size() > 0)
        return 0;
    else
        return 1;
endfunction
function bit B::try_put(my_transaction tr);
    `uvm_info("B", "receive a transaction", UVM_LOW)
    if(tr_q.size() > 0)
        return 0;
    else begin
        tr_q.push_back(tr);
        return 1;
    end
endfunction
task B::main_phase(uvm_phase phase);
    my_transaction tr;
    while(1) begin
        if(tr_q.size() > 0)
            tr = tr_q.pop_front();
        else
            #25;
    end
endtask

即使A 中不使用can_put，在B中依然需要定义一个名字为can_put的函数，这个函数里可以没有任何内容，纯粹是一个空函数
env 代码:

1
2
3
4
5


文件： src/ch4/section4.2/4.2.9/my_env.sv
function void my_env::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    A_inst.A_export.connect(B_inst.B_imp);
endfunction

UVM中的通信方式

UVM中的analysis端口

除了PORT 、 EXPORT 、 IMP 这几种端口外，UVM中还有两种特殊的端口:analysis_port和analysis_export。
这两者其实与put和get系列端口类似，都用于传递transaction。它们的区别是:

第一，默认情况下，一个analysis_port(analysis_export)可以连接多个IMP ，也就是说，analysis_port(analysis_export)与IMP 之间的通信是一对多的通信，

而put和get系列端口与相应IMP 的通信是一对一的通信(除非在实例化时指定可以连接的数量，参照 4.2.1节A_port的new函数原型代码清单4-4)。analysis_port(analysis_export)更像是一个广播

第二，put与get系列端口都有阻塞和非阻塞的区分。但是对于analysis_port和analysis_export来说，没有阻塞和非阻塞的概念。因为它本身就是广播，不必等待与其相连的其他端口的响应，所以不存在阻塞和非阻塞
第三, 一个analysis_port可以和多个IMP 相连接进行通信，但是IMP 的类型必须是uvm_analysis_imp，否则会报错
第四, 对于put系列端口，有put、try_put、can_put等操作，对于get系列端口，有get、try_get和can_get等操作。
对于analysis_port和 analysis_export来说，只有一种操作:write。在analysis_imp所在的component，必须定义一个名字为write的函数。

要实现以下链接

A 的代码为:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


文件:src/ch4/section4.3/4.3.1/analysis_port/A.sv
class A extends uvm_component;
    `uvm_component_utils(A)
    uvm_analysis_port#(my_transaction) A_ap;
...
endclass
...
task A::main_phase(uvm_phase phase); my_transaction tr;
    repeat(10) begin
        #10;
        tr = new("tr"); assert(tr.randomize()); A_ap.write(tr);
    end
endtask

B 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


文件：src/ch4/section4.3/4.3.1/analysis_port/B.sv
class B extends uvm_component;
    `uvm_component_utils(B)
    uvm_analysis_imp#(my_transaction, B) B_imp;
    …
endclass
…
function void B::write(my_transaction tr);
    `uvm_info("B", "receive a transaction", UVM_LOW)
    tr.print();
endfunction

如前所述，B是B_imp所在的component，因此要在B中定义一个名字为write的函数。在B的main_phase中不需要做任何操作。
C 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


文件：src/ch4/section4.3/4.3.1/analysis_port/C.sv
class C extends uvm_component;
    `uvm_component_utils(C)
    uvm_analysis_imp#(my_transaction, C) C_imp;
    …
endclass
…
function void C::write(my_transaction tr);
    `uvm_info("C", "receive a transaction", UVM_LOW)
    tr.print();
endfunction

env 代码:

1
2
3
4
5
6


文件：src/ch4/section4.3/4.3.1/analysis_port/my_env.sv
function void my_env::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    A_inst.A_ap.connect(B_inst.B_imp);
    A_inst.A_ap.connect(C_inst.C_imp);
endfunction

与put系列端口的PORT和EXPORT直接相连会出错的情况一样，analysis_port如果和一个analysis_export直接相连也会出错。只
有在analysis_export后面再连接一级uvm_analysis_imp，才不会出错

上面只是一个analysis_port与IMP相连的例子。analysis_export和IMP也可以这样相连接，只需将上面例子中的
uvm_analysis_port改为uvm_analysis_export就可以

一个component内有多个IMP

跨层次IMP 的使用

考虑上图中o_agt的monitor与scoreboard之间的通信，使用analysis_port实现。
monitor 代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class monitor extends uvm_monitor;
    uvm_analysis_port#(my_transaction) ap;
    task main_phase(uvm_phase phase);
        super.main_phase(phase);
        my_transaction tr;
        …
            ap.write(tr);
        …
endtask
endclass

scoreboard 代码:

1
2
3
4
5
6


class scoreboard extends uvm_scoreboard;
    uvm_analysis_imp#(my_transaction, scoreboard) scb_imp;
    task write(my_transaction tr);
        //do something on tr
    endtask
endclass

之后在env中可以使用connect连接。由于monitor与scoreboard在UVM树中并不是平等的兄妹关系，其中间还间隔了o_agt，所以这里有三种连接方式，
第一种是直接在env中跨层次引用monitor中的ap:

1
2
3
4


function void my_env::connect_phase(uvm_phase phase);
    o_agt.mon.ap.connect(scb.scb_imp);
…
endfunction

第二种是在agent中声明一个ap并实例化它，在connect_phase将其与monitor的ap相连，并可以在env中把agent的ap直接连接到 scoreboard的imp：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class my_agent extends uvm_agent ;
    uvm_analysis_port #(my_transaction) ap;
    …
    function void build_phase(uvm_phase phase);
        super.build_phase(phase);
        ap = new("ap", this);
        …
    endfunction
    function void my_agent::connect_phase(uvm_phase phase);
        mon.ap.connect(this.ap);
        …
    endfunction
endclass
function void my_env::connect_phase(uvm_phase phase);
    o_agt.ap.connect(scb.scb_imp);
    …
endfunction

第三种是在agent中声明一个ap，但是不实例化它，让其指向monitor中的ap。在env中可以直接连接agent的ap到scoreboard的 imp:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class my_agent extends uvm_agent ;
    uvm_analysis_port #(my_transaction) ap;
    …
    function void my_agent::connect_phase(uvm_phase phase);
        ap = mon.ap;
        …
    endfunction
endclass
function void my_env::connect_phase(uvm_phase phase);
    o_agt.ap.connect(scb.scb_imp);
    …
endfunction

如上所述的三种方式中，第一种最简单，但是其层次关系并不好，第二种稍显麻烦，第三种既具有明显的层次关系，同时其
实现也较简单。

当一个component 中有多个IMP

如 scb 中即要接收来自 monitor 的数据, 又要接收来自 refrence 的数据, 就需要两个 IMP ,
但是write 函数只有一个, 怎么办呢?
UVM考虑到了这种情况，它定义了一个宏uvm_analysis_imp_decl来解决这个问题，其使用方式为：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


文件：src/ch4/section4.3/4.3.3/my_scoreboard.sv
`uvm_analysis_imp_decl(_monitor)
`uvm_analysis_imp_decl(_model)
class my_scoreboard extends uvm_scoreboard;
    my_transaction expect_queue[$];
    uvm_analysis_imp_monitor#(my_transaction, my_scoreboard) monitor_imp;
    uvm_analysis_imp_model#(my_transaction, my_scoreboard) model_imp;
    …
    extern function void write_monitor(my_transaction tr);
    extern function void write_model(my_transaction tr);
    extern virtual task main_phase(uvm_phase phase);
endclass

上述代码通过宏uvm_analysis_imp_decl声明了两个后缀_monitor和_model。
UVM会根据这两个后缀定义两个新的IMP类： uvm_analysis_imp_monitor和uvm_analysis_imp_model，
并在my_scoreboard中分别实例化这两个类：monitor_imp和model_imp。当与 monitor_imp相连接的analysis_port执行write函数时，会自动调用write_monitor函数，而与model_imp相连接的analysis_port执行write 函数时，会自动调用write_model函数。所以，只要完成后缀的声明，并在write后面添加上相应的后缀就可以正常工作了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


文件：src/ch4/section4.3/4.3.3/my_scoreboard.sv
function void my_scoreboard::write_model(my_transaction tr);
    expect_queue.push_back(tr);
endfunction
function void my_scoreboard::write_monitor(my_transaction tr);
    my_transaction tmp_tran;
    bit result;
    if(expect_queue.size() > 0) begin
        …
    end
endfunction

使用FIFO通信

在agent和scoreboard之间添加一个uvm_analysis_fifo。FIFO的本质是一块缓存加两个IMP。在monitor与FIFO的
连接关系中，monitor中依然是analysis_port，FIFO中是uvm_analysis_imp，数据流和控制流的方向相同。在scoreboard与FIFO的连接关系中，scoreboard中使用blocking_get_port端口：
scoreboard 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


文件：src/ch4/section4.3/4.3.4/my_scoreboard.sv
class my_scoreboard extends uvm_scoreboard;
    my_transaction expect_queue[$];
    uvm_blocking_get_port #(my_transaction) exp_port;   // expect
    uvm_blocking_get_port #(my_transaction) act_port;   // actual
    …
endclass
…
task my_scoreboard::main_phase(uvm_phase phase);
    …
    fork
        while (1) begin
            exp_port.get(get_expect);
            expect_queue.push_back(get_expect);
        end
        while (1) begin
            act_port.get(get_actual);
            …
        end
    join
endtask

而FIFO中使用的是一个get端口的IMP。在这种连接关系中，控制流是从scoreboard到FIFO，而数据流是从FIFO到scoreboard
env 中代码 :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


文件：src/ch4/section4.3/4.3.4/my_env.sv
class my_env extends uvm_env;
    my_agent i_agt;
    my_agent o_agt;
    my_model mdl;
    my_scoreboard scb;
    uvm_tlm_analysis_fifo #(my_transaction) agt_scb_fifo;
    uvm_tlm_analysis_fifo #(my_transaction) agt_mdl_fifo;
    uvm_tlm_analysis_fifo #(my_transaction) mdl_scb_fifo;
    …
endclass
function void my_env::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    i_agt.ap.connect(agt_mdl_fifo.analysis_export);
    mdl.port.connect(agt_mdl_fifo.blocking_get_export);
    mdl.ap.connect(mdl_scb_fifo.analysis_export);
    scb.exp_port.connect(mdl_scb_fifo.blocking_get_export);
    o_agt.ap.connect(agt_scb_fifo.analysis_export);
    scb.act_port.connect(agt_scb_fifo.blocking_get_export);
endfunction

FIFO中有两个IMP，但是在上面的连接关系中，FIFO中却是EXPORT，这是为什么呢？实际上，FIFO中的 analysis_export和blocking_get_export虽然名字中有关键字export，
但是其类型却是IMP。UVM为了掩饰IMP的存在，在它们的命名中加入了export关键字。如analysis_export的原型如下：

1

uvm_analysis_imp #(T, uvm_tlm_analysis_fifo #(T)) analysis_export;

analysis_export 是FIFO 的输入端, 即往FIFO 写数据
blocking_get_export 是FIFO 的输出端, 即从FIFO 读数据
使用FIFO连接之后，第一个好处是不必在scoreboard中再写一个名字为write的函数。scoreboard可以按照自己的节奏工作，而不必跟着monitor的节奏。
第二个好处是FIFO的存在隐藏了IMP，这对于初学者来说比较容易理解。第三个好处是可以轻易解决上一节讲到的当reference model和monitor同时连接到scoreboard应如何处理的问题。
事实上，FIFO的存在自然而然地解决了它，这根本就不是一个问题了

FIFO上的端口及调试

put_ap
get_ap
put_export
blocking_put_export
nonblocking_put_export
analysis_export
get_peek_export
get_export
blocking_get_export
nonblocking_get_export
peek_export
blocking_peek_export
nonblocking_peek_export
blocking_get_peek_export
nonblocking_get_peek_export

上图中所有以圆圈表示的EXPORT虽然名字中有export，但是本质上都是IMP.

FIFO 中的peek 端口

peek端口与get相似，其数据流、控制流都相似，唯一的区别在于当get任务被调用时，FIFO内部缓存中会少一个transaction，
而peek被调用时，FIFO会把transaction复制一份发送出去，其内部缓存中的transaction数量并不会减少

analysis_port：put_ap和get_ap

当FIFO上的blocking_put_export或者put_export被连接到一个blocking_put_port或者put_port上时，FIFO内部被定义的put任务被调用，
这个put任务把传递过来的transaction放在FIFO内部的缓存里，同时，把这个transaction通过put_ap使用write函数发送出去。FIFO的put任务定义如下：

1
2
3
4


virtual task put( input T t );
    m.put( t );     // m即是FIFO内部的缓存，使用SystemVerilog中的mailbox来实现。
    put_ap.write( t );
endtask

与put_ap相似，当FIFO的get任务被调用时，同样会有一个transaction从get_ap上发出

1
2
3
4
5
6


virtual task get( output T t );
    m_pending_blocked_gets++;
    m.get( t );
    m_pending_blocked_gets--;
    get_ap.write( t );
endtask

什么时候会触发FIFO中的这个get任务呢？在上一节中，一个blocking_get_port连接到了FIFO上，当它调用get任务获取
transaction时就会调用FIFO的get任务。除此之外，FIFO的get_export、get_peek_export和blocking_get_peek_export被相应的PORT或
者EXPORT连接时，也能会调用FIFO的get任务

FIFO 的类型

FIFO的类型有两种，一种是 uvm_tlm_analysis_fifo ，另外一种是 uvm_tlm_fifo 。这两者的唯一差别在于前者有一个
analysis_export端口，并且有一个write函数，而后者没有。除此之外，本节上面介绍的所有端口同时适用于这两者。

FIFO 的调试

used 函数

used函数用于查询FIFO缓存中有多少transaction。

is_empty函数

用于判断当前FIFO缓存是否为空。

is_full 函数

用于判断当前FIFO缓存是否已经满了。

size 函数

作为一个缓存来说，其能存储的transaction是有限的。那么这个最大值是在哪里定义的呢？
FIFO的new函数原型如下：
1

function new(string name, uvm_component parent = null, int size = 1);
FIFO在本质上是一个component，所以其前两个参数是uvm_component的new函数中的两个参数。第三个参数是size，用于设定FIFO缓存的上限，在默认的情况下为1。
若要把缓存设置为无限大小，将传入的size参数设置为0即可。通过size函数可以返回这个上限值

flush 函数
1

virtual function void flush();
这个函数用于清空FIFO缓存中的所有数据，它一般用于复位等操作。

用FIFO还是用IMP

在用FIFO通信的方法中，完全隐藏了IMP这个UVM中特有、而TLM中根本就没有的东西。用户可以完全不关心IMP。
因此，对于用户来说，只需要知道analysis_port、blocking_get_port即可。这大大简化了初学者
的工作量。尤其是在scoreboard面临多个IMP，且需要为IMP声明一个后缀时，这种优势更加明显。
FIFO连接的方式增加了env中代码的复杂度，满满的看上去似乎都是与FIFO相关的代码。尤其是当要连接的端口数量众多时，这个缺点更加明显。

使用端口数组的情况，FIFO要优于IMP

假如参考模型中有16个类似端口要和scoreboard中相应的端口相互通信，如此多数量的端口，在参考模型中可以使用端口数组来实现:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


文件：src/ch4/section4.3/4.3.5/imp/my_model.sv
class my_model extends uvm_component;
    uvm_blocking_get_port #(my_transaction) port;
    uvm_analysis_port #(my_transaction) ap[16];
    …
endclass
…
function void my_model::build_phase(uvm_phase phase);
    super.build_phase(phase);
    port = new("port", this);
    for(int i = 0; i < 16; i++)
        ap[i] = new($sformatf("ap_%0d", i), this);
endfunction

使用 IMP 方式

如果连接关系使用IMP加后缀的方式，那么在scoreboard中的代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


文件：src/ch4/section4.3/4.3.5/imp/my_scoreboard.sv
`uvm_analysis_imp_decl(_model0)
…
`uvm_analysis_imp_decl(_modelf)
`uvm_analysis_imp_decl(_monitor)
class my_scoreboard extends uvm_scoreboard;
    my_transaction expect_queue[$];
    uvm_analysis_imp_monitor#(my_transaction, my_scoreboard) monitor_imp;
    uvm_analysis_imp_model0#(my_transaction, my_scoreboard) model0_imp;
    …
    uvm_analysis_imp_modelf#(my_transaction, my_scoreboard) modelf_imp;
    `uvm_component_utils(my_scoreboard)
    extern function new(string name, uvm_component parent = null);
    extern virtual function void build_phase(uvm_phase phase);
    extern virtual task main_phase(uvm_phase phase);
    extern function void write_monitor(my_transaction tr);
    extern function void write_model0(my_transaction tr);
    …
        extern function void write_modelf(my_transaction tr);
endclass
…
function void my_scoreboard::build_phase(uvm_phase phase);
    super.build_phase(phase);
    monitor_imp = new("monitor_imp", this);
    model0_imp = new("model0_imp", this);
    …
    modelf_imp = new("modelf_imp", this);
endfunction
function void my_scoreboard::write_model0(my_transaction tr);
    expect_queue.push_back(tr);
endfunction
…
function void my_scoreboard::write_modelf(my_transaction tr);
    expect_queue.push_back(tr);
endfunction
function void my_scoreboard::write_monitor(my_transaction tr);
    …
endfunction

并且在env中，需要:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


文件：src/ch4/section4.3/4.3.5/imp/my_env.sv
function void my_env::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    i_agt.ap.connect(agt_mdl_fifo.analysis_export);
    mdl.port.connect(agt_mdl_fifo.blocking_get_export);
    o_agt.ap.connect(scb.monitor_imp);
    mdl.ap[0].connect(scb.model0_imp);
    mdl.ap[1].connect(scb.model1_imp);
    …
    mdl.ap[14].connect(scb.modele_imp);
    mdl.ap[15].connect(scb.modelf_imp);
endfunction

在如上列出的代码中使用了很多省略号，但是即使这样，相信读者也能感受到其中代码的冗余到了多么严重的程度。这一切都是因为ap与imp直接相连而不能使用for循环引起的

使用FIFO

scoreboard 代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


文件：src/ch4/section4.3/4.3.5/fifo/my_scoreboard.sv
class my_scoreboard extends uvm_scoreboard;
    my_transaction expect_queue[$];
    uvm_blocking_get_port #(my_transaction) exp_port[16];
    uvm_blocking_get_port #(my_transaction) act_port;
    …
endclass
…
function void my_scoreboard::build_phase(uvm_phase phase);
    super.build_phase(phase);
    for(int i = 0; i < 16; i++)
        exp_port[i] = new($sformatf("exp_port_%0d", i), this);
    act_port = new("act_port", this);
endfunction
task my_scoreboard::main_phase(uvm_phase phase);
    …
    for(int i = 0; i < 16; i++)
        fork
            automatic int k = i;
            while (1) begin
                exp_port[k].get(get_expect);
                expect_queue.push_back(get_expect);
            end
        join_none
    while (1) begin
        act_port.get(get_actual);
        …
        end
endtask

在env中也可以使用for循环:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


文件：src/ch4/section4.3/4.3.5/fifo/my_env.sv
class my_env extends uvm_env;
    …
    uvm_tlm_analysis_fifo #(my_transaction) agt_scb_fifo;
    uvm_tlm_analysis_fifo #(my_transaction) agt_mdl_fifo;
    uvm_tlm_analysis_fifo #(my_transaction) mdl_scb_fifo[16];
    …
    virtual function void build_phase(uvm_phase phase);
        …
        agt_scb_fifo = new("agt_scb_fifo", this);
        agt_mdl_fifo = new("agt_mdl_fifo", this);
        for(int i = 0; i < 16; i++)
            mdl_scb_fifo[i] = new($sformatf("mdl_scb_fifo_%0d", i), this);
    endfunction
    …
endclass
function void my_env::connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    i_agt.ap.connect(agt_mdl_fifo.analysis_export);
    mdl.port.connect(agt_mdl_fifo.blocking_get_export);
    for(int i = 0; i < 16; i++) begin
        mdl.ap[i].connect(mdl_scb_fifo[i].analysis_export);
        scb.exp_port[i].connect(mdl_scb_fifo[i].blocking_get_export);
    end
    o_agt.ap.connect(agt_scb_fifo.analysis_export);
    scb.act_port.connect(agt_scb_fifo.blocking_get_export);
endfunction

无论使用FIFO还是使用IMP，都能实现同样的目标，两者各有其优势与劣势。在实际应用中，读者可以根据自己的习惯来选择合适的连接方式。

UVM 中更简洁的FIFO通信方式( 只需要一组 uvm_tlm_analysis_fifo 和 uvm_analysis_port )

这种通信方式是在opentitan 的源码中抄的, opentitan 默认是基于UVM1.2 来运行的, 经过实验, 在UVM1.1 中也能用

scoreboard

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


class svpwm_scoreboard extends dv_base_scoreboard #(
    .CFG_T(svpwm_env_cfg),
    .COV_T(svpwm_env_cov)
  );
  `uvm_component_utils(svpwm_scoreboard)

  // local variables

  // TLM agent fifos
  uvm_tlm_analysis_fifo #(svpwm_item) svpwm_fifo;

  // local queues to hold incoming packets pending comparison
  svpwm_item svpwm_q[$];

  `uvm_component_new

  function void build_phase(uvm_phase phase);
    super.build_phase(phase);
  endfunction

  function void connect_phase(uvm_phase phase);
    super.connect_phase(phase);
  endfunction

  task run_phase(uvm_phase phase);
    super.run_phase(phase);
    fork
      process_svpwm_fifo();
    join_none
  endtask

  virtual task process_svpwm_fifo();
    svpwm_item item;
    `uvm_info(get_type_name(), "process_svpwm_fifo", UVM_LOW);
    forever begin
      svpwm_fifo.get(item);
      `uvm_info(get_type_name(), $sformatf("received svpwm item:\n%0s", item.sprint()), UVM_LOW)
    end
  endtask

endclass

在env 里连接

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


class svpwm_env extends dv_base_env #(
    .CFG_T              (svpwm_env_cfg),
    .COV_T              (svpwm_env_cov),
    .VIRTUAL_SEQUENCER_T(svpwm_virtual_sequencer),
    .SCOREBOARD_T       (svpwm_scoreboard)
  );
  `uvm_component_utils(svpwm_env)

  svpwm_agent m_svpwm_agent;

  `uvm_component_new

  function void build_phase(uvm_phase phase);
    super.build_phase(phase);
    // create components
    m_svpwm_agent = svpwm_agent::type_id::create("m_svpwm_agent", this);
    uvm_config_db#(svpwm_agent_cfg)::set(this, "m_svpwm_agent*", "cfg", cfg.m_svpwm_agent_cfg);
    cfg.m_svpwm_agent_cfg.en_cov = cfg.en_cov;
  endfunction

  function void connect_phase(uvm_phase phase);
    super.connect_phase(phase);
    if (cfg.en_scb) begin
      m_svpwm_agent.monitor.analysis_port.connect(scoreboard.svpwm_fifo.analysis_export);
      `uvm_info(get_type_name(), "connect scoreboard analysis", UVM_LOW);
    end
    if (cfg.is_active && cfg.m_svpwm_agent_cfg.is_active) begin
      virtual_sequencer.svpwm_sequencer_h = m_svpwm_agent.sequencer;
    end
  endfunction

endclass

在 monitor 里发送

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


class svpwm_monitor extends dv_base_monitor #(
    .ITEM_T (svpwm_item),
    .CFG_T  (svpwm_agent_cfg),
    .COV_T  (svpwm_agent_cov)
  );
  `uvm_component_utils(svpwm_monitor)

  // the base class provides the following handles for use:
  // svpwm_agent_cfg: cfg
  // svpwm_agent_cov: cov
  // uvm_analysis_port #(svpwm_item): analysis_port

  `uvm_component_new

  function void build_phase(uvm_phase phase);
    super.build_phase(phase);
  endfunction

  task run_phase(uvm_phase phase);
    super.run_phase(phase);
  endtask

  // collect transactions forever - already forked in dv_base_monitor::run_phase
  virtual protected task collect_trans(uvm_phase phase);
    svpwm_item w_tr;
    `uvm_info(get_type_name(), "collect_trans", UVM_LOW);
    w_tr = new("w_tr");
    forever begin
      // TODO: detect event

      // TODO: sample the interface

      // TODO: sample the covergroups

      // TODO: write trans to analysis_port
      analysis_port.write(w_tr);
      repeat(10) @(posedge cfg.vif.clk);
      // `uvm_info(get_type_name(), "send item", UVM_LOW);

      // TODO: remove the line below: it is added to prevent zero delay loop in template code
      #1us;
    end
  endtask

endclass

analysis_port 在 dv_base_monitor 里定义并例化

1
2
3
4


  // Analysis port for the collected transfer.
  uvm_analysis_port #(ITEM_T) analysis_port;
...
    analysis_port = new("analysis_port", this);

简单总结

在scoreboard 中声明并实例化一个 uvm_tlm_analysis_fifo 类型的 fifo, 然后使用 fifo.get(item) 从fifo 中获取数据
在 monitor 中声明并实例化一个 uvm_analysis_port 类型的 analysis_port, 使用 analysis_port.write(item); 来往FIFO 写数据

在 env 中把monitor 和 scoreboard 连接起来

1

   agent.monitor.analysis_port.connect(scoreboard.xxx_fifo.analysis_export);

TLM 的定义

put

get

transport

put、 get和transport操作都有阻塞和非阻塞之分

UVM中的PORT与EXPORT

常用的PORT 有

常用的EXPORT 有

PORT和EXPORT体现的是一种控制流， 在这种控制流中， PORT具有高优先级， 而EXPORT具有低优先级。 只有高优先级的端口才能向低优先级的端口发起三种操作

UVM 中各种端口的互连

PORT与EXPORT的连接

UVM中的IMP

PORT 与 IMP 的连接

当A_port的类型是blocking_put ， B_imp的类型是blocking_put 时

当A_port的类型是nonblocking_put ， B_imp的类型是nonblocking_put 时

当A_port的类型是put， B_imp的类型是put时

当A_port的类型是blocking_get， B_imp的类型是blocking_get时

当A_port的类型是nonblocking_get， B_imp的类型是nonblocking_get时

当A_port的类型是get， B_imp的类型是get时

当A_port的类型是blocking_peek， B_imp的类型是blocking_peek时

当A_port的类型是nonblocking_peek， B_imp的类型是nonblocking_peek时

当A_port的类型是peek， B_imp的类型是peek时

当A_port的类型是blocking_get_peek， B_imp的类型是blocking_get_peek时

当A_port的类型是nonblocking_get_peek， B_imp的类型是nonblocking_get_peek时

当A_port的类型是get_peek， B_imp的类型是get_peek时

当A_port的类型是blocking_transport， B_imp的类型是blocking_transport时

当A_port的类型是nonblocking_transport， B_imp的类型是nonblocking_transport时

当A_port的类型是transport， B_imp的类型是transport时

规律总结

EXPORT 与 IMP 的连接

规律与 PORT 和 IMP 的连接一样

PORT 与 PORT 的连接

EXPORT 与 EXPORT 的连接

blocking_get端口的使用

blocking_transport端口的使用

nonblocking端口的使用

UVM中的通信方式

UVM中的analysis端口

一个component内有多个IMP

使用FIFO通信

FIFO上的端口及调试

FIFO 中的peek 端口

analysis_port：put_ap和get_ap

FIFO 的类型

FIFO 的调试

用FIFO还是用IMP

使用端口数组的情况，FIFO要优于IMP

UVM 中更简洁的FIFO通信方式( 只需要一组 uvm_tlm_analysis_fifo 和 uvm_analysis_port )

scoreboard

在env 里连接

在 monitor 里发送

简单总结

PORT和EXPORT体现的是一种控制流，在这种控制流中， PORT具有高优先级，而EXPORT具有低优先级。只有高优先级的端口才能向低优先级的端口发起三种操作