Welcome to the 2023 Digital IC exchange group, QQ group No. 628200294
Virtual sequencers (not recommended)
A Virtual Sequence is one that uses multiple sequencers to control excitation generation. Because sequence, sequencer and driver focus on interfaces, almost all test platforms need a Virtual Sequence to coordinate the incentives and interactions between different interfaces.
Virtual Sequence can be implemented in two ways. The recommended method is to use an independent Virtual Sequence, while the "legacy" alternative Virtual Sequence needs to be run on the Virtual Sequence.
virtual sequencer refers to a sequencer that is not connected to the driver itself, but contains a handle to the sequencer in the test platform hierarchy.
"This chapter only represents the opinions of mentor's cookbook. Personally, I think it's better to use virtual sequencer "
virtual sequence runs on the virtual sequencer
Using this method, the virtual sequence needs to obtain the real sequencer handle through the virtual sequencer. The virtual sequencer is part of the UVM component hierarchy, so its sub sequencer reference can be made in the connection phase.
Usually, the virtual sequencer is inserted into the env level and the connection method of Env is used to allocate the sub sequencer handle. The virtual_sequence is usually created in the run method and started on the virtual sequencer -- that is, virtual_sequence.start(virtual_sequencer);
It is recommended to provide a name of the associated interface to the sub sequencer in the virtual_sequencer, which is more readable. For example, the sequencer of the main bus interface can be called "bus_master" instead of "master_axi_sequencer".
// Virtual sequencer class: class virtual_sequencer extends uvm_sequencer #(uvm_sequence_item); `uvm_component_utils(virtual_sequencer) // Note that the handles are in terms that the test writer understands bus_master_sequencer bus; gpio_sequencer gpio; function new(string name = "virtual_sequencer", uvm_component parent = null); super.new(name, parent); endfunction endclass: virtual_sequencer class env extends uvm_env; // Relevant parts of the env which combines the // virtual_sequencer and the bus and gpio agents // // Build: function void build_phase( uvm_phase phase ); m_bus_agent = bus_master_agent::type_id::create("m_bus_agent", this); m_gpio_agent = gpio_agent::type_id::create("m_gpio_agent", this); m_v_sqr = virtual_sequencer::type_id::create("m_v_sqr", this); endfunction: build_phase // Connect - where the virtual_sequencer is hooked up: // Note that these references are constant in the context of this env function void connect_phase( uvm_phase phase ); m_v_sqr.bus = m_bus_agent.m_sequencer; m_v_sqr.gpio = m_gpio_agent.m_sequencer; endfunction: connect_phase endclass:env // Virtual sequence base class: // class virtual_sequence_base extends uvm_sequence #(uvm_sequence_item); `uvm_object_utils(virtual_sequence_base) // This is needed to get to the sub-sequencers in the // m_sequencer virtual_sequencer v_sqr; // Local sub-sequencer handles bus_master_sequencer bus; gpio_sequencer gpio; function new(string name = "virtual_sequence_base"); super.new(name); endfunction // Assign pointers to the sub-sequences in the base body method: task body(); if(!$cast(v_sqr, m_sequencer)) begin `uvm_error(get_full_name(), "Virtual sequencer pointer cast failed"); end bus = v_sqr.bus; gpio = v_sqr.gpio; endtask: body endclass: virtual_sequence_base // Virtual sequence class: // class example_virtual_seq extends virtual_sequence_base; random_bus_seq bus_seq; random_gpio_chunk_seq gpio_seq; `uvm_object_utils(example_virtual_seq) function new(string name = "example_virtual_seq"); super.new(name); endfunction task body(); super.body; // Sets up the sub-sequencer pointers gpio_seq = random_gpio_chunk_seq::type_id::create("gpio_seq"); bus_seq = random_bus_seq::type_id::create("bus_seq"); repeat(20) begin bus_seq.start(bus); gpio_seq.start(gpio); end endtask: body endclass: example_virtual_seq // Inside the test class: // task run; example_virtual_sequence test_seq = example_virtual_sequencer::type_id::create("test_seq"); //... test_seq.start(m_env.m_v_sqr); //... endtask: run
Modify the Virtual Sequencer for vertical multiplexing
When creating a reusable env level environment, sequencers at different levels of the test platform can be connected together, allowing virtual sequencer or sub sequencer to run at any level. In order to achieve this level of flexibility, sub sequencer handles and virtual sequencer handles need to be encapsulated at different levels.
// Virtual sequencer from the UART env class uart_env_virtual_sqr extends uvm_sequencer #(uvm_sequence_item); // .. uart_sequencer uart; bus_sequencer bus; // .. endclass: uart_env_virtual_sqr // Virtual sequencer from the GPIO env class gpio_env_virtual_sqr extends uvm_sequencer #(uvm_sequence_item); // .. gpio_sequencer gpio; bus_sequencer bus; // .. endclass: gpio_env_virtual_sqr // Virtual sequencer from the SoC env class soc_env_virtual_sqr extends uvm_sequencer #(uvm_sequence_item); //.. // Low level sequencers to support virtual sequences running across // TB hierarchical boundaries uart_sequencer uart; bus_sequencer uart_bus; gpio_sequencer gpio; bus_sequencer gpio_bus; // Virtual sequencers to support existing virtual sequences // uart_env_virtual_sqr uart_v_sqr; gpio_env_virtual_sqr gpio_v_sqr; // Low level sequencer pointer assignment: // This has to be after connect because these connections are // one down in the hierarchy function void end_of_elaboration(); uart = uart_v_sqr.uart; uart_bus = uart_v_sqr.bus; gpio = gpio_v_sqr.gpio; gpio_bus = gpio_v_sqr.bus; endfunction: end_of_elaboration endclass: soc_env_virtual_sqr
Coding guide: the virtual sequencer needs to check whether it is an empty handle before use
The running of virtual sequences is based on the assumption that they can run on sub sequencers within the agent. However, according to the construction process of the test platform, the agent may be passive or active. In order to prevent empty handle errors in test cases, virtual sequences should check whether all sequencers they intend to use are empty handles. If empty handles are detected, they should The test case ends with ` uvm_fatal.
// Either inside the virtual sequence base class or in // an extension of it that will use specific sequencers: task body(); if(!$cast(v_sqr, m_sequencer)) begin `uvm_error(get_full_name(), "Virtual sequencer pointer cast failed") end if(v_sqr.gpio == null) begin `uvm_fatal(get_full_name(), "GPIO sub-sequencer null pointer: this test case will fail, check config or virtual sequence") end else begin gpio = v_sqr.gpio; end if(v_sqr.gpio_bus == null) begin `uvm_fatal(get_full_name(), "BUS sub-sequencer null pointer: this test case will fail, check config or virtual sequence") end else begin gpio_bus = v_sqr.gpio_bus; end endtask: body