UVM序列指南：Verification Academy实战手册

需积分: 15 73 浏览量更新于2024-07-21 收藏 1.44MB PDF 举报

"UVM Cookbook - Sequences Guide - Verification Academy" 在验证领域，尤其是系统级验证，UVM（Universal Verification Methodology）是一个广泛使用的框架，它提供了标准的库和方法来构建可重用和可扩展的验证环境。《UVM Cookbook - Sequences Guide》是来自Verification Academy的一份宝贵资源，该资源深入讲解了如何使用UVM中的序列（Sequences）进行高效验证。 1. **Sequences** UVM中的序列是用于生成验证激励的主要机制。它们定义了一组特定的事务顺序，这些事务被驱动到设计中以进行测试。序列可以是简单的，一次性发送一个事务，也可以是复杂的，包含多个交互和条件。 2. **Sequences/Items** 在UVM中，交易（Items）是表示设计接口数据的类。序列生成并发送这些交易到验证环境的不同组件，如驱动器（Driver）。 3. **Transaction/Methods** 交易类通常包含用于描述其行为的方法，例如初始化、打包和解包。序列则使用这些方法来创建和管理交易实例。 4. **Sequences/API** UVM为序列提供了一组丰富的API，允许用户控制序列的执行，如start、wait_for_grant、finish等。 5. **Config/Configuring Sequences** 序列可以通过配置对象进行配置，以适应不同的验证场景。配置机制使得可以在运行时动态调整序列的行为。 6. **Connect/Sequencer** 序列通过与序列器（Sequencer）交互来请求资源和调度交易。序列器是序列的控制器，负责仲裁多个序列的请求。 7. **Driver/SequenceAPI** 驱动器（Driver）是连接验证环境和设计的接口，它实现了序列发送的交易在硬件接口上的实际传输。序列API允许序列与驱动器通信，指定如何处理交易。 8. **Sequences/Generation** 序列生成可以是随机的，也可以是基于规则的，如根据某种模式或概率分布生成交易。 9. **Sequences/Overrides** 序列可以覆盖其他序列的行为，这在实现不同层次的定制和重用时非常有用。 10. **Sequences/Virtual** 虚拟序列（Virtual Sequences）是不直接与硬件交互的高级序列，它们可以组合其他序列，提供更复杂的行为控制。 11. **Sequences/VirtualSequencer** 虚拟序列器允许在不直接关联物理端口的情况下控制序列，这对于多协议或多接口的设计验证非常有用。 12. **Sequences/Hierarchy** UVM支持序列的层级结构，可以创建嵌套序列来构建复杂的验证场景。 13. **Sequences/SequenceLibrary** 序列库（Sequence Library）是存储和管理序列的地方，可以方便地重用和组织验证代码。 14. **Driver/UseModels** 驱动器使用模型来描述其对设计接口的操作方式，可以是单向、双向或流水线模型，以适应不同的通信协议。 15. **Driver/Unidirectional** 单向驱动器处理只发送或只接收数据的接口。 16. **Driver/Bidirectional** 双向驱动器处理可以同时发送和接收数据的接口。 17. **Driver/Pipelined** 流水线驱动器支持连续的、无阻塞的数据传输，适合高速接口的验证。 18. **Sequences/Arbitration** 序列仲裁机制处理多个序列同时请求资源的情况，确保公平性和效率。 19. **Sequences/Priority** 优先级机制允许指定某些序列在其他序列之前获得服务。 20. **Sequences/Lock/Grab** 锁定（Lock）和抢占（Grab）机制控制序列对资源的访问权限，允许临时或长期独占资源。 21. **Sequences/Slave** 从属序列响应主序列的请求，可以用于实现复杂的协作验证场景。 22. **Stimulus/SignalWait** 信号等待（Signal Wait）机制允许序列暂停等待特定事件或条件，以便精确控制激励的生成时间。 23. **Stimulus/Interrupts** 中断处理允许序列在外部事件触发时快速响应，模拟真实系统中的中断行为。 24. **Sequences/Stopping** 停止机制使序列能够在满足特定条件时终止，比如检测到错误或完成预期行为。 25. **Sequences/Layering** 层次化序列设计有助于将验证任务分解成更小、更易管理的部分，便于维护和复用。这份文档是UVM验证方法学在线Cookbook的快照，由Mentor Graphics的验证方法团队提供，包含了关于如何利用UVM序列进行高效验证的全面指导。通过理解和应用这些概念，可以提升验证环境的质量和效率，从而加速验证过程，减少设计缺陷。

Sequences/API

Step 3 - Starting The Sequence

A sequence is started using a call to€its start() method, passing as an argument a€pointer to the sequencer through which it

will be sending sequence_items to a driver. The start() method assigns the sequencer pointer to a sequencer handle called

m_sequencer within the sequence and then calls the body task within the sequence. When the sequence body task

completes, the start method returns. Since it requires the body task to finish and this requires interaction with a driver,

start() is a blocking€method.

The start method has three optional arguments which have defaults which means that most of the time they are not

necessary:

virtual task start (uvm_sequencer_base sequencer, // Pointer to sequencer

uvm_sequence_base parent_sequencer = null, // Relevant if called within a sequence

integer this_priority = 100, // Priority on the sequencer

bit call_pre_post = 1); // pre_body and post_body methods called

// For instance - called from an uvm_component - usually the test:

apb_write_seq.start(env.m_apb_agent.m_sequencer);

// Or called from within a sequence:

apb_compare_seq.start(m_sequencer, this);

It is possible to call the sequence start method without any arguments, and this will result in the sequence running

without a direct means of being able to connect to a driver.

Sending a sequence_item to a driver

To send a sequence_item to a driver there are four steps that need to occur:

Step 1 - Creation

The sequence_item is derived from uvm_object and should be created via the factory:

Using the factory creation method allows the sequence_item to be overridden with a sequence_item of a derived type if

required.

Step 2 - Ready - start_item()

The start_item() call is made, passing the sequence_item handle as an argument. This call blocks until the sequencer

grants the sequence and the sequence_item access to the driver.

Sequences/API

Step 3 - Set

The sequence_item is prepared for use, usually through randomization, but it may also be initialised by setting properties

directly.

Step 4 - Go - finish_item()

The finish_item() call is made, which blocks until the driver has completed its side of the transfer protocol for the item.

No simulation time should be consumed between start_item() and finish_item().

Step 5 - Response - get_response()

This step is optional, and is only used if the driver sends a response to indicate to indicate that it has completed

transaction associated with the sequence_item. The get_response() call blocks until a response item is available from the

sequencers response FIFO.

// Inside some sequence connected to a sequencer

my_sequence_item item;

task body;

// Step 1 - Creation

item = my_sequence_item::type_id::create("item");

// Step 2 - Ready - start_item()

start_item(item);

// Step 3 - Set

if(!item.randomize() with {address inside {[0:32'h4FFF_FFFF]};}) begin

`uvm_error("body", "randomization failure for item")

end

// Step 4 - Go - finish_item()

finish_item(item);

endtask: body

Late Randomization

In the sequence_item flow above, steps 2 and 3 could be done in any order. However, leaving the randomization of the

sequence_item until just before the finish_item() method call€has the potential to allow€the sequence_item to be

randomized according to conditions true at the time of generation. This is sometimes referred to as late randomization.

The alternative approach is to generate the sequence_item before the start_item() call, in this case the item is generated

before it is necessarily clearhow it is going to be used.

In previous generation verification methodologies, such as Specman and the AVM,€generation was done at the beginning

of the simulation and a stream of pre-prepared sequence_items was sent across to the driver. With late randomization,

sequence_items are generated just in time and on demand.

Sequences/API

Coding Guidelines

Make sequence input variables rand, output variables non-rand

A good coding convention to follow is to make variables which are used as inputs€by€sequence random and to leave

variables which are to collect output or response information as non-random. This ensures that a sequence can be

configured by randomization with constraints. The same convention applies to sequence_items.

Obvious exceptions to this convention would be handles and strings within the sequence.

Do not use pre_/post_body in sequences

The pre_body() method is intended to be executed before the body€method€and the post_body() method is intended to be

called after body has completed. In practice, the functionality that these two methods might contain can easily be put

directly into the body method. If there is some common initialisation work to be done, then this can be put into the body

method of a base class and called using super.body().

The way in which sequences are started affects whether these methods are called or not. Using start_item(),

finish_item()€means that the methods are not called, and using start() can mean that they are not called. It is

therefore€easier for the user if the pre_/post_body methods are not used.

Use start for sequences, start_item, finish_item for sequence_items

Sequence_items should be sent to the driver using the start_item() and finish_item() calls. Sequences should be started

using the start() call.

Justification:

Although sequences can also be started using start_item() and finish_item(), it is clearer to the user whether a sequence

or a sequence item is being processed if this convention is followed.

Using the start() call also allows the user to control whether the sequences pre_body() and post_body() hook methods are

called. By default, the start() method enables the calling of the pre and post_body() methods, but this can be disabled by

passing an extra argument into the start() method. Also note that the start_item() and finish_item() calls do not call pre or

post_body().

Using start() for sequences means that a user does not need to know whether a sub-sequence contains one of these hook

methods.

Sequences should not directly consume time

Sequence code should not explicitly consume time by using delay statements. They should only consume time by virtue

of the process of sending sequence_items to a driver.

Justification:

Keeping this separation allows sequences to be reused as stimulus when an UVM€testbench is linked to an emulator for

hardware acceleration.

剩余125页未读，继续阅读

ZYZ_DIDO

粉丝: 51
资源: 15

UVM序列指南：Verification Academy实战手册

UVM cookbook

uvm cookbook

UVM_CookBook_2013

uvm-cookbook-complete-verification-academy

UVM-cookbook-complete-verification-academy.pdf

uvm-cookbook2019.pdf

UVM_Cookbook

UVM方法学实战指南：官方资料解析

SystemVerilog与UVM详解：从基础到实践

UVM cookbook 2013 自制详细书签版+练习代码，UVM查询手册.zip

最新资源