Bound work and prove completion

Completion first, then a bound

When checking may end is settled in U7.3's section on closing the test: planned counts met, nothing waiting, then a 20 ns quiet window with checking still on. This lesson adds two things: one absolute deadline across stimulus, drain and that window, and the question of which processes the timer and its cancellation reach.

Put one deadline around the whole path

Race the complete operation against a timer, and keep the timer alive through stimulus, results checked, the quiet window and the final counts. Bounding only seq.start leaves a second hang: all requests accepted, one result that never arrives.

fork : bounded
  begin
    seq.start(sqr);
    stimulus_finished = 1;
    wait (sb.inputs == 3 && sb.checked == 3 && sb.expected.size() == 0);
    #(quiet_window);           // U7.3's quiet window, checking still on
    @(negedge vif.clk);
    // Recheck the counts: a late extra result is an error.
    finished = 1;
  end
  begin #500ns; end            // the deadline
join_any
disable bounded;
if (!finished) `uvm_error("DEADLINE", "completion did not finish")

The example's design stops accepting after two inputs. At 500 ns the diagnostic reads "2 of 3 inputs taken, driver offers x=48, ready=0". With a healthy design the work branch finishes at 120 ns. A missing final response instead reports that stimulus finished, with the checked and waiting counts.

Size the deadline from bounds, not from one run: the healthy path takes 120 ns here, and 500 ns leaves room for this design's fixed pipeline. A design that may stall, queue more work or run a slower clock needs the limit recalculated from those bounds.

Keep the absolute limit even when the quiet window restarts on activity. A faulty design that keeps producing output can then postpone completion forever.

Cancel the timer without killing unrelated work

join_any returns when either branch finishes. Record that the work branch finished, then cancel the other branch. wait fork would wait for the timer too, so a timer that reports unconditionally fires after a successful run.

The named disable bounded reaches only that block. disable fork reaches every descendant of the calling process, including background traffic it started earlier. Neither reaches a driver or monitor, whose processes belong to other components.

fork
  begin                         // the isolated helper process
    fork
      do_work();
      begin #limit; timed_out = 1; end
    join_any
    disable fork;               // descendants of this helper only
  end
join

Diagnose before deciding on recovery

The example reports an error and ends. Disabling the work branch stops the wait inside seq.start; it does not lower the driver's valid, flush the request the driver holds, or reset the design. Only stop_sequences() flushes that request; a sequence's own kill() removes it from the arbitration queues but leaves the driver's request in place.

Continuing after a timeout needs the U10.2 procedure. stop_sequences() flushes the request, a reset-aware driver abandons it without item_done, and the design's own cancellation rule updates the scoreboard and models. Never label missing work canceled just to balance the counts.

Simulated-time and wall-clock limits guard different hangs. A simulated-time deadline, local or UVM's global set_timeout, fires only while time advances. A zero-delay loop stops time, so the job runner's wall-clock limit is the only thing that ends it. When the global timeout does expire, it reports fatal PH_TIMEOUT and says only that time ran out.

Transfer: a design that may stall

Change the design: under backpressure it may legally hold ready low for up to 300 ns at a time, and a test now sends 20 items through a 4-deep queue. Recompute the deadline, and explain why doubling one observed run time is not a bound.

Try it

The design was built with STUCK_AFTER = 2, so it never raises ready after its second accept. The sequence waits for 48 forever, and at 500 ns the deadline wins and the test reports what it found.

Two edits turn the run into its other outcomes. Measured on this runner:

Check yourself

`timescale 1ns/1ns
`include "uvm_macros.svh"
import uvm_pkg::*;

class item_c extends uvm_sequence_item;
  `uvm_object_utils(item_c)
  function new(string name = "item_c"); super.new(name); endfunction
endclass

class drv_c extends uvm_driver #(item_c);
  `uvm_component_utils(drv_c)
  int idle = 0, per_item = 10, count;
  function new(string name, uvm_component parent); super.new(name, parent); endfunction
  task run_phase(uvm_phase phase);
    #(idle);
    forever begin
      seq_item_port.get_next_item(req);
      #(per_item);
      count++;
      seq_item_port.item_done();
    end
  endtask
endclass

class leaf_seq extends uvm_sequence #(item_c);
  `uvm_object_utils(leaf_seq)
  int n = 1, done;
  function new(string name = "leaf_seq"); super.new(name); endfunction
  task body();
    repeat (n) begin
      item_c it = item_c::type_id::create("it");
      start_item(it);
      finish_item(it);
      done++;
    end
  endtask
endclass

class my_test extends uvm_test;
  `uvm_component_utils(my_test)
  uvm_sequencer #(item_c) sqr;
  drv_c drv;
  function new(string name, uvm_component parent); super.new(name, parent); endfunction
  function void build_phase(uvm_phase phase);
    sqr = uvm_sequencer #(item_c)::type_id::create("sqr", this);
    drv = drv_c::type_id::create("drv", this);
    drv.idle = 30;
    drv.per_item = 100;
  endfunction
  function void connect_phase(uvm_phase phase);
    drv.seq_item_port.connect(sqr.seq_item_export);
  endfunction
  task run_phase(uvm_phase phase);
    leaf_seq seq = leaf_seq::type_id::create("seq");
    seq.n = 5;
    phase.raise_objection(this);
    fork
      seq.start(sqr);
      #250;
    join_any
    disable fork;
    $display("at %0t: %0d of 5 items done", $time, seq.done);
    phase.drop_objection(this);
  endtask
endclass

module tb;
  initial run_test("my_test");
endmodule

fork : bounded
  begin seq.start(sqr); finished = 1; end
  begin #1000ns; end
join_any
disable bounded;
if (!finished) `uvm_error("TIMEOUT", "sequence did not finish")

fork
  begin #1000ns; `uvm_error("TIMEOUT", "sequence did not finish") end
join_none
seq.start(sqr);
disable fork;

fork
  seq.start(sqr);
  begin #1000ns; `uvm_error("TIMEOUT", "sequence did not finish") end
join_any
disable fork;

fork
  seq.start(sqr);
  begin #1000ns; `uvm_error("TIMEOUT", "sequence did not finish") end
join_any
wait fork;

`timescale 1ns/1ns
`include "uvm_macros.svh"
import uvm_pkg::*;

class quiet_test extends uvm_test;
  `uvm_component_utils(quiet_test)
  event seen;
  int   extras;
  function new(string name, uvm_component parent); super.new(name, parent); endfunction
  task run_phase(uvm_phase phase);
    bit quiet = 0;
    phase.raise_objection(this);
    fork                                    // a faulty design: one extra result every 15 ns
      begin #105; forever begin extras++; ->seen; #15; end end
    join_none
    fork : bounded
      begin
        #95;                                // the expected work is checked at 95 ns
        forever begin                       // a 20 ns quiet window that restarts on activity
          fork : window
            begin #20; quiet = 1; end
            @(seen);
          join_any
          disable window;
          if (quiet) break;
        end
      end
      #500;                                 // the absolute deadline
    join_any
    disable bounded;
    $display("at %0t: quiet=%0b, %0d extra results", $time, quiet, extras);
    phase.drop_objection(this);
  endtask
endclass

module tb;
  initial run_test("quiet_test");
endmodule