The sequence lifecycle

start() runs a fixed script

Every item gets its own trip through pre_do, mid_do and post_do. In the example, R's log reads pre_do(is_item=1), mid_do, a 10 ns gap for the driver, post_do, then finish_item 0 returned. post_do is the first code in the sequence that runs after the driver has finished with the item.

The fourth argument of start is call_pre_post, default 1. A parent often passes 0 so that it does the set-up itself; older code that raised objections in pre_body relied on this too. The uvm_do macros pass 0 for every child they start (U5.4). The Cookbook advises avoiding pre_body and post_body altogether, because code that may or may not run is a trap.

States you can wait for

get_sequence_state() returns the current box. wait_for_sequence_state(mask) blocks until the state is one in the mask, which may be a bitwise or of several. The example starts L in a fork and, in the other branch, waits for UVM_BODY: it prints L is in state UVM_BODY at 20 ns, when L's body began. A test can wait for a background sequence to reach its main loop, or ask whether a sequence finished or was stopped, without a flag of its own.

Wait for both ends. A killed sequence never reaches UVM_FINISHED, so wait_for_sequence_state(UVM_FINISHED) blocks forever; measured here, it was still blocked 100 ns after the kill with the state UVM_STOPPED. wait_for_sequence_state(UVM_FINISHED | UVM_STOPPED) returns at once.

Stopping a sequence

Neither call checks whether the driver is in the middle of an item, which is why the Cookbook says a started sequence should not be stopped at all. If you must stop, make sure the driver is idle first, or kill the one sequence and let the driver finish.

Killing is not undoing. The item in the driver still reaches the design, so a register it wrote stays written, and a scoreboard that predicted from the sequence still expects a result. post_start does not run, so an objection raised by hand in pre_start must be dropped in do_kill, or raised through set_automatic_phase_objection(1), which kill drops. kill also removes the sequence's queued requests, locks and grabs from every other sequencer it used, so a coordinator killed while holding a grab on another lane releases it. Anything else it changed, such as a configuration field or a register, stays changed.

Responses that nobody reads

A response travels back by sequence ID into that sequence's response queue (U4.2), and the queue belongs to the sequence object. Three lifecycle rules follow.

1. start clears it

   Every start empties the queue, so responses from an earlier run of the same object are gone.

2. Eight, then silence

   The queue holds 8 responses by default. Measured here: a sequence sends 12 items, the driver answers each, and the sequence reads only after the last; it gets 8, and the 4 overflows vanish without a report. With set_response_queue_error_report_enabled(1) each overflow is a UVM_ERROR.

3. After a kill, a warning

   A response that arrives after its sequence was killed finds no sequence and is dropped with warning [Sequencer] Dropping response ... sequence exited or has been killed. The example shows it at 50 ns, for L2.

Read responses as they arrive, or raise the depth with set_response_queue_depth(-1), or use use_response_handler(1) so the sequencer calls a function instead of queuing.

Try it

Three sequences on one driver that takes 10 ns per item and returns a response for each. R shows the full hook order for a root sequence. P starts K with call_pre_post = 0, so K has no pre_body or post_body, while P's pre_do(is_item=0), mid_do and post_do wrap the child. L is killed at 45 ns with its third item in the driver; do_kill runs, post_body does not, and the driver finishes the item at 50 ns. That item's response is dropped with the warning, because L is no longer registered.

Change k.start(m_sequencer, this, -1, 0) to k.start(m_sequencer, this) and K's pre_body and post_body reappear. Then replace l.kill() with sqr.stop_sequences() and predict the driver's next item_done before running it.

Transfer exercise: L raised an objection by hand in pre_start and drops it in post_start. Write the do_kill that keeps the test from hanging after the kill, and say which state a waiting test should accept.

Check yourself

`timescale 1ns/1ns
`include "uvm_macros.svh"
import uvm_pkg::*;
class item_c extends uvm_sequence_item;
  `uvm_object_utils(item_c)
  int idx;
  function new(string name = "item_c"); super.new(name); endfunction
endclass
class drv_c extends uvm_driver #(item_c);
  `uvm_component_utils(drv_c)
  string grants = "";
  int done;
  function new(string name, uvm_component parent); super.new(name, parent); endfunction
  task run_phase(uvm_phase phase);
    forever begin
      seq_item_port.get_next_item(req);
      grants = {grants, " ", req.get_parent_sequence().get_name(), $sformatf("%0d", req.idx)};
      #10;
      seq_item_port.item_done();
      done++;
    end
  endtask
endclass
class seq_c extends uvm_sequence #(item_c);
  `uvm_object_utils(seq_c)
  int finished;
  bit post_body_ran;
  function new(string name = "seq_c"); super.new(name); endfunction
  task body();
    for (int i = 0; i < 5; i++) begin
      item_c it = item_c::type_id::create("it");
      it.idx = i;
      start_item(it);
      finish_item(it);
      finished++;
    end
  endtask
  task post_body(); post_body_ran = 1; endtask
endclass
class my_test extends uvm_test;
  `uvm_component_utils(my_test)
  drv_c drv;
  uvm_sequencer #(item_c) sqr;
  function new(string name, uvm_component parent); super.new(name, parent); endfunction
  function void build_phase(uvm_phase phase);
    drv = drv_c::type_id::create("drv", this);
    sqr = uvm_sequencer #(item_c)::type_id::create("sqr", this);
  endfunction
  function void connect_phase(uvm_phase phase);
    drv.seq_item_port.connect(sqr.seq_item_export);
  endfunction
  task run_phase(uvm_phase phase);
    seq_c s = seq_c::type_id::create("S");
    phase.raise_objection(this);
    fork
      s.start(sqr);
      begin #25; s.kill(); end
    join
    #20;
    $display("finished=%0d state=%s post_body=%0d driver_done=%0d", s.finished, s.get_sequence_state().name(), s.post_body_ran, drv.done);
    phase.drop_objection(this);
  endtask
endclass
module tb;
  initial run_test("my_test");
endmodule

#35;
bg.kill();
bg.wait_for_sequence_state(UVM_STOPPED);

#35;
sqr.stop_sequences();

#35;
bg.kill();
#10;
sqr.stop_sequences();

#35;
bg.kill();

Practice

• A background sequence that leaves cleanly when killed Implement · Easy