Lock and Grab of sequencer in UVM

There are a number of modelling scenarios where one sequence needs to have exclusive access to a driver via a sequencer. One example of this type of scenario is a sequence which is responding to an interrupt.
In order to accommodate this requirement, the uvm_sequencer provides 2 types of mechanism called lock()-unlock() and grab()-ungrab().

If sequencer is doing some sequence and based on some external events if user wants sequencer to pause the current sequence, he/she can grab/lock sequencer and start another sequence. Once the started sequence finishes sequencer can resume the normal operation, upon ungrab/unlock.
This mechanism is generally used to mimic CPU behavior, where CPU is doing a normal bus operation and when interrupt comes, CPU needs to suspend the normal operation and start interrupt handling. Once interrupt handling is over, CPU should resume the normal operation from where it was suspended.

A lock might be used to model a prioritized interrupt and a grab might be used to model a non-mask able interrupt (NMI).
The lock() and grab() calls have antidote calls to release a lock and these are unlock() and ungrab().

Lock()
1) A lock() request is put in back of the arbitration queue . A lock request will be arbitrated the same as any other request.
2) A lock is granted after all earlier requests are completed and no other locks or grabs are blocking this sequence.
3) A lock() is blocking task and when access is granted, it will unblock.
4) If no argument is supplied, then current default sequencer is chosen.

Grab()
1) A grab() request is put in front of the arbitration queue. A grab() request will be arbitrated before any other requests.
2) A grab() is granted when no other grabs or locks are blocking this sequence. (The only thing that stops a sequence from grabbing a sequencer is a pre-existing lock() or grab() condition.)
3) A grab() is blocking task and when access is granted, it will unblock.
4) If no argument is supplied, then current default sequencer is chosen.

Unlock()
The unlock sequencer function is called from within a sequence to give up its lock or grab. A locking sequence must call unlock before completion; otherwise the sequencer will remain locked.

Ungrab()
An alias of function unlock().


What happens if 2 sequences try to grab or lock the same sequencer?
The most recent grab goes to the front of the queue; the most recent lock goes to the back of the queue.

Priority in lock() and grab().
The most recent grab comes first, then the previous grab... then the oldest lock, then the most recent lock.

Let’s go through basic example of lock() and grab()

1) Lock

---------------------------------------------

	`include "uvm_pkg.sv"
	import uvm_pkg::*;
	typedef enum {PUSH_A,PUSH_B,ADD,SUB,MUL,DIV,POP_C} inst_e;
	//-----Packet/Transaction-----
	class my_seq_item extends uvm_sequence_item;
	rand inst_e inst;
	`uvm_object_utils_begin(my_seq_item)
	`uvm_field_enum(inst_e,inst, UVM_DEFAULT)
	`uvm_object_utils_end
	function new (string name = "my_seq_item");
	super.new(name);
	endfunction : new
	function string convert2string();
	convert2string = $sformatf("inst:%s", inst.name());
	endfunction : convert2string
	endclass : my_seq_item
	//-----Sequencer-----
	class my_sequencer extends uvm_sequencer #(my_seq_item);
	`uvm_sequencer_utils(my_sequencer)
	function new (string name = "my_sequencer", uvm_component parent = null);
	super.new(name, parent);
	`uvm_update_sequence_lib_and_item(my_seq_item)
	endfunction : new
	endclass : my_sequencer
	//-----Driver-----
	class my_driver extends uvm_driver #(my_seq_item);
	`uvm_component_utils(my_driver)
	function new (string name = "my_driver", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	task run_phase (uvm_phase phase);
	forever begin
	seq_item_port.get_next_item(req);
	$display($time," Driving pkt %s", req.convert2string());
	#10;
	seq_item_port.item_done();
	end
	endtask : run_phase
	endclass : my_driver
	//-----Agent-----
	class my_agent extends uvm_agent;
	my_sequencer sqr;
	my_driver drv;
	`uvm_component_utils(my_agent)
	function new (string name = "my_agent", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	function void build_phase (uvm_phase phase);
	super.build_phase(phase);
	sqr = my_sequencer::type_id::create("sqr", this);
	drv = my_driver::type_id::create("drv", this);
	endfunction : build_phase
	function void connect_phase (uvm_phase phase);
	super.connect_phase(phase);
	drv.seq_item_port.connect(sqr.seq_item_export);
	endfunction : connect_phase
	endclass : my_agent
	//-----seq_a-----
	class seq_a extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_a)
	function new(string name="seq_a");
	super.new(name);
	endfunction : new
	virtual task body();
	repeat(4) begin
	`uvm_do_with(req, { inst == PUSH_A; });
	end
	endtask : body
	endclass : seq_a
	//-----seq_b-----
	class seq_b extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_b)
	function new(string name="seq_b");
	super.new(name);
	endfunction : new
	virtual task body();
	lock(); // or lock(m_sequencer);
	repeat(4) begin
	`uvm_do_with(req, { inst == PUSH_B; });
	end
	unlock(); // or unlock(m_sequencer);
	endtask : body
	endclass : seq_b
	//-----seq_c-----
	class seq_c extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_c)
	function new(string name="seq_c");
	super.new(name);
	endfunction : new
	virtual task body();
	repeat(4) begin
	`uvm_do_with(req, { inst == POP_C; });
	end
	endtask : body
	endclass : seq_c
	//-----Virtual sequence-----
	class parallel_sequence extends uvm_sequence #(my_seq_item);
	seq_a s_a;
	seq_b s_b;
	seq_c s_c;
	`uvm_object_utils(parallel_sequence)
	function new(string name="parallel_sequence");
	super.new(name);
	endfunction : new
	virtual task body();
	s_a = seq_a::type_id::create("s_a");
	s_b = seq_b::type_id::create("s_b");
	s_c = seq_c::type_id::create("s_c");
	fork
	s_a.start(m_sequencer);
	s_b.start(m_sequencer);
	s_c.start(m_sequencer);
	join
	endtask : body
	endclass : parallel_sequence
	//-----Test-----
	class my_test extends uvm_test;
	my_agent agent;
	`uvm_component_utils(my_test)
	function new (string name = "my_test", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	function void build_phase (uvm_phase phase);
	super.build_phase(phase);
	agent = my_agent::type_id::create("agent", this);
	endfunction : build_phase
	task run_phase(uvm_phase phase);
	parallel_sequence p_seq;
	p_seq = parallel_sequence::type_id::create("p_seq");
	phase.raise_objection(this);
	p_seq.start(agent.sqr);
	phase.drop_objection(this);
	endtask : run_phase
	endclass : my_test
	module top();
	initial begin
	run_test("my_test");
	end
	endmodule : top
	// Output:
	// 0 Driving pkt inst:PUSH_A
	// 10 Driving pkt inst:PUSH_B
	// 20 Driving pkt inst:PUSH_B
	// 30 Driving pkt inst:PUSH_B
	// 40 Driving pkt inst:PUSH_B
	// 50 Driving pkt inst:POP_C
	// 60 Driving pkt inst:PUSH_A
	// 70 Driving pkt inst:POP_C
	// 80 Driving pkt inst:PUSH_A
	// 90 Driving pkt inst:POP_C
	// 100 Driving pkt inst:PUSH_A
	// 110 Driving pkt inst:POP_C

view raw lock_in_uvm.sv hosted with ❤ by GitHub

---------------------------------------------

2) Grab

---------------------------------------------

	`include "uvm_pkg.sv"
	import uvm_pkg::*;
	typedef enum {PUSH_A,PUSH_B,ADD,SUB,MUL,DIV,POP_C} inst_e;
	//-----Packet/Transaction-----
	class my_seq_item extends uvm_sequence_item;
	rand inst_e inst;
	`uvm_object_utils_begin(my_seq_item)
	`uvm_field_enum(inst_e,inst, UVM_DEFAULT)
	`uvm_object_utils_end
	function new (string name = "my_seq_item");
	super.new(name);
	endfunction : new
	function string convert2string();
	convert2string = $sformatf("inst:%s", inst.name());
	endfunction : convert2string
	endclass : my_seq_item
	//-----Sequencer-----
	class my_sequencer extends uvm_sequencer #(my_seq_item);
	`uvm_sequencer_utils(my_sequencer)
	function new (string name = "my_sequencer", uvm_component parent = null);
	super.new(name, parent);
	`uvm_update_sequence_lib_and_item(my_seq_item)
	endfunction : new
	endclass : my_sequencer
	//-----Driver-----
	class my_driver extends uvm_driver #(my_seq_item);
	`uvm_component_utils(my_driver)
	function new (string name = "my_driver", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	task run_phase (uvm_phase phase);
	forever begin
	seq_item_port.get_next_item(req);
	$display($time," Driving pkt %s", req.convert2string());
	#10;
	seq_item_port.item_done();
	end
	endtask : run_phase
	endclass : my_driver
	//-----Agent-----
	class my_agent extends uvm_agent;
	my_sequencer sqr;
	my_driver drv;
	`uvm_component_utils(my_agent)
	function new (string name = "my_agent", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	function void build_phase (uvm_phase phase);
	super.build_phase(phase);
	sqr = my_sequencer::type_id::create("sqr", this);
	drv = my_driver::type_id::create("drv", this);
	endfunction : build_phase
	function void connect_phase (uvm_phase phase);
	super.connect_phase(phase);
	drv.seq_item_port.connect(sqr.seq_item_export);
	endfunction : connect_phase
	endclass : my_agent
	//-----seq_a-----
	class seq_a extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_a)
	function new(string name="seq_a");
	super.new(name);
	endfunction : new
	virtual task body();
	repeat(4) begin
	`uvm_do_with(req, { inst == PUSH_A; });
	end
	endtask : body
	endclass : seq_a
	//-----seq_b-----
	class seq_b extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_b)
	function new(string name="seq_b");
	super.new(name);
	endfunction : new
	virtual task body();
	grab(); // or grab(m_sequencer);
	repeat(4) begin
	`uvm_do_with(req, { inst == PUSH_B; });
	end
	ungrab(); // or ungrab(m_sequencer);
	endtask : body
	endclass : seq_b
	//-----seq_c-----
	class seq_c extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_c)
	function new(string name="seq_c");
	super.new(name);
	endfunction : new
	virtual task body();
	repeat(4) begin
	`uvm_do_with(req, { inst == POP_C; });
	end
	endtask : body
	endclass : seq_c
	//-----Virtual Sequence-----
	class parallel_sequence extends uvm_sequence #(my_seq_item);
	seq_a s_a;
	seq_b s_b;
	seq_c s_c;
	`uvm_object_utils(parallel_sequence)
	function new(string name="parallel_sequence");
	super.new(name);
	endfunction : new
	virtual task body();
	fork
	`uvm_do(s_a)
	`uvm_do(s_b)
	`uvm_do(s_c)
	join
	endtask : body
	endclass : parallel_sequence
	//-----Test-----
	class my_test extends uvm_test;
	my_agent agent;
	`uvm_component_utils(my_test)
	function new (string name = "my_test", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	function void build_phase (uvm_phase phase);
	super.build_phase(phase);
	agent = my_agent::type_id::create("agent", this);
	endfunction : build_phase
	task run_phase(uvm_phase phase);
	parallel_sequence p_seq;
	p_seq = parallel_sequence::type_id::create("p_seq");
	phase.raise_objection(this);
	p_seq.start(agent.sqr);
	phase.drop_objection(this);
	endtask : run_phase
	endclass : my_test
	module top();
	initial begin
	run_test("my_test");
	end
	endmodule : top
	// Output:
	// 0 Driving pkt inst:PUSH_B
	// 10 Driving pkt inst:PUSH_B
	// 20 Driving pkt inst:PUSH_B
	// 30 Driving pkt inst:PUSH_B
	// 40 Driving pkt inst:PUSH_A
	// 50 Driving pkt inst:POP_C
	// 60 Driving pkt inst:PUSH_A
	// 70 Driving pkt inst:POP_C
	// 80 Driving pkt inst:PUSH_A
	// 90 Driving pkt inst:POP_C
	// 100 Driving pkt inst:PUSH_A
	// 110 Driving pkt inst:POP_C

view raw grab_in_uvm.sv hosted with ❤ by GitHub

---------------------------------------------

From output of above two examples, we can see the difference between lock() and grab() as mentioned above.

When a hierarchical sequence locks/grab a sequencer, then its child sequences will have access to the sequencer.

If one of the child sequences issues a lock/grab, then the parent sequence will not be able to start any parallel sequences or send any sequence_items until the child sequence has unlocked.

---------------------------------------------

	`include "uvm_pkg.sv"
	import uvm_pkg::*;
	typedef enum {PUSH_A,PUSH_B,ADD,SUB,MUL,DIV,POP_C} inst_e;
	//-----Packet/Transaction-----
	class my_seq_item extends uvm_sequence_item;
	rand inst_e inst;
	`uvm_object_utils_begin(my_seq_item)
	`uvm_field_enum(inst_e,inst, UVM_DEFAULT)
	`uvm_object_utils_end
	function new (string name = "my_seq_item");
	super.new(name);
	endfunction : new
	function string convert2string();
	convert2string = $sformatf("inst:%s", inst.name());
	endfunction : convert2string
	endclass : my_seq_item
	//-----Sequencer-----
	class my_sequencer extends uvm_sequencer #(my_seq_item);
	`uvm_sequencer_utils(my_sequencer)
	function new (string name = "my_sequencer", uvm_component parent = null);
	super.new(name, parent);
	`uvm_update_sequence_lib_and_item(my_seq_item)
	endfunction : new
	endclass : my_sequencer
	//-----Driver-----
	class my_driver extends uvm_driver #(my_seq_item);
	`uvm_component_utils(my_driver)
	function new (string name = "my_driver", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	task run_phase (uvm_phase phase);
	forever begin
	seq_item_port.get_next_item(req);
	$display($time," Driving pkt %s", req.convert2string());
	#10;
	seq_item_port.item_done();
	end
	endtask : run_phase
	endclass : my_driver
	//-----Agent-----
	class my_agent extends uvm_agent;
	my_sequencer sqr;
	my_driver drv;
	`uvm_component_utils(my_agent)
	function new (string name = "my_agent", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	function void build_phase (uvm_phase phase);
	super.build_phase(phase);
	sqr = my_sequencer::type_id::create("sqr", this);
	drv = my_driver::type_id::create("drv", this);
	endfunction : build_phase
	function void connect_phase (uvm_phase phase);
	super.connect_phase(phase);
	drv.seq_item_port.connect(sqr.seq_item_export);
	endfunction : connect_phase
	endclass : my_agent
	//-----Virtual Sequencer-----
	class my_virtual_sqr extends uvm_sequencer;
	my_sequencer sqr1;
	my_sequencer sqr2;
	`uvm_component_utils(my_virtual_sqr)
	function new (string name = "my_virtual_sqr", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	endclass : my_virtual_sqr
	//-----seq_a-----
	class seq_a extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_a)
	function new(string name="seq_a");
	super.new(name);
	endfunction : new
	virtual task body();
	repeat(4) begin
	`uvm_do_with(req, { inst == PUSH_A; });
	end
	endtask : body
	endclass : seq_a
	//-----seq_b-----
	class seq_b extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_b)
	function new(string name="seq_b");
	super.new(name);
	endfunction : new
	virtual task body();
	repeat(4) begin
	`uvm_do_with(req, { inst == PUSH_B; });
	end
	endtask : body
	endclass : seq_b
	//-----seq_c-----
	class seq_c extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_c)
	function new(string name="seq_c");
	super.new(name);
	endfunction : new
	virtual task body();
	repeat(4) begin
	`uvm_do_with(req, { inst == POP_C; });
	end
	endtask : body
	endclass : seq_c
	//-----Virtual Sequence-----
	class parallel_sequence extends uvm_sequence #(my_seq_item);
	seq_a s_a;
	seq_b s_b;
	seq_c s_c;
	`uvm_object_utils(parallel_sequence)
	`uvm_declare_p_sequencer(my_virtual_sqr)
	function new(string name="parallel_sequence");
	super.new(name);
	endfunction : new
	virtual task body();
	// parallel_sequence put grab on sequencer sqr1,
	// but still it's child sequences (seq_a, seq_b, seq_c) will have access of sequencer sqr1
	grab(p_sequencer.sqr1);
	fork
	begin
	`uvm_create_on(s_a, p_sequencer.sqr1)
	`uvm_rand_send(s_a)
	end
	begin
	`uvm_create_on(s_b, p_sequencer.sqr1)
	`uvm_rand_send(s_b)
	end
	begin
	`uvm_create_on(s_c, p_sequencer.sqr1)
	`uvm_rand_send(s_c)
	end
	join
	ungrab(p_sequencer.sqr1);
	endtask : body
	endclass : parallel_sequence
	//-----Test-----
	class my_test extends uvm_test;
	my_agent agent1;
	my_agent agent2;
	my_virtual_sqr vsqr;
	`uvm_component_utils(my_test)
	function new (string name = "my_test", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	function void build_phase (uvm_phase phase);
	super.build_phase(phase);
	agent1 = my_agent::type_id::create("agent1", this);
	agent2 = my_agent::type_id::create("agent2", this);
	vsqr = my_virtual_sqr::type_id::create("vsqr", this);
	endfunction : build_phase
	function void connect_phase(uvm_phase phase);
	super.connect_phase(phase);
	vsqr.sqr1 = agent1.sqr;
	vsqr.sqr2 = agent2.sqr;
	endfunction : connect_phase
	task run_phase(uvm_phase phase);
	parallel_sequence p_seq;
	p_seq = parallel_sequence::type_id::create("p_seq");
	phase.raise_objection(this);
	p_seq.start(vsqr);
	phase.drop_objection(this);
	endtask : run_phase
	endclass : my_test
	module top();
	initial begin
	run_test("my_test");
	end
	endmodule : top
	// Output:
	// 0 Driving pkt inst:PUSH_A
	// 10 Driving pkt inst:PUSH_B
	// 20 Driving pkt inst:POP_C
	// 30 Driving pkt inst:PUSH_A
	// 40 Driving pkt inst:PUSH_B
	// 50 Driving pkt inst:POP_C
	// 60 Driving pkt inst:PUSH_A
	// 70 Driving pkt inst:PUSH_B
	// 80 Driving pkt inst:POP_C
	// 90 Driving pkt inst:PUSH_A
	// 100 Driving pkt inst:PUSH_B
	// 110 Driving pkt inst:POP_C

view raw child_has_access_of_grab_lock_sqr.sv hosted with ❤ by GitHub

---------------------------------------------

A locking or grabbing sequence must always unlock before it completes,

---------------------------------------------

	`include "uvm_pkg.sv"
	import uvm_pkg::*;
	typedef enum {PUSH_A,PUSH_B,ADD,SUB,MUL,DIV,POP_C} inst_e;
	//-----Packet/Transaction-----
	class my_seq_item extends uvm_sequence_item;
	rand inst_e inst;
	`uvm_object_utils_begin(my_seq_item)
	`uvm_field_enum(inst_e,inst, UVM_DEFAULT)
	`uvm_object_utils_end
	function new (string name = "my_seq_item");
	super.new(name);
	endfunction : new
	function string convert2string();
	convert2string = $sformatf("inst:%s", inst.name());
	endfunction : convert2string
	endclass : my_seq_item
	//-----Sequencer-----
	class my_sequencer extends uvm_sequencer #(my_seq_item);
	`uvm_sequencer_utils(my_sequencer)
	function new (string name = "my_sequencer", uvm_component parent = null);
	super.new(name, parent);
	`uvm_update_sequence_lib_and_item(my_seq_item)
	endfunction : new
	endclass : my_sequencer
	//-----Driver-----
	class my_driver extends uvm_driver #(my_seq_item);
	`uvm_component_utils(my_driver)
	function new (string name = "my_driver", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	task run_phase (uvm_phase phase);
	forever begin
	seq_item_port.get_next_item(req);
	$display($time," Driving pkt %s", req.convert2string());
	#10;
	seq_item_port.item_done();
	end
	endtask : run_phase
	endclass : my_driver
	//-----Agent-----
	class my_agent extends uvm_agent;
	my_sequencer sqr;
	my_driver drv;
	`uvm_component_utils(my_agent)
	function new (string name = "my_agent", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	function void build_phase (uvm_phase phase);
	super.build_phase(phase);
	sqr = my_sequencer::type_id::create("sqr", this);
	drv = my_driver::type_id::create("drv", this);
	endfunction : build_phase
	function void connect_phase (uvm_phase phase);
	super.connect_phase(phase);
	drv.seq_item_port.connect(sqr.seq_item_export);
	endfunction : connect_phase
	endclass : my_agent
	//-----Virtual Sequencer-----
	class my_virtual_sqr extends uvm_sequencer;
	my_sequencer sqr1;
	my_sequencer sqr2;
	`uvm_component_utils(my_virtual_sqr)
	function new (string name = "my_virtual_sqr", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	endclass : my_virtual_sqr
	//-----seq_a-----
	class seq_a extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_a)
	function new(string name="seq_a");
	super.new(name);
	endfunction : new
	virtual task body();
	repeat(4) begin
	`uvm_do_with(req, { inst == PUSH_A; });
	end
	endtask : body
	endclass : seq_a
	//-----seq_b-----
	class seq_b extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_b)
	function new(string name="seq_b");
	super.new(name);
	endfunction : new
	virtual task body();
	repeat(4) begin
	`uvm_do_with(req, { inst == PUSH_B; });
	end
	endtask : body
	endclass : seq_b
	//-----seq_c-----
	class seq_c extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_c)
	function new(string name="seq_c");
	super.new(name);
	endfunction : new
	virtual task body();
	repeat(4) begin
	`uvm_do_with(req, { inst == POP_C; });
	end
	endtask : body
	endclass : seq_c
	//-----Virtual Sequence-----
	class parallel_sequence extends uvm_sequence #(my_seq_item);
	seq_a s_a;
	seq_b s_b;
	seq_c s_c;
	`uvm_object_utils(parallel_sequence)
	`uvm_declare_p_sequencer(my_virtual_sqr)
	function new(string name="parallel_sequence");
	super.new(name);
	endfunction : new
	virtual task body();
	fork
	begin
	`uvm_create_on(s_a, p_sequencer.sqr1)
	`uvm_rand_send(s_a)
	end
	begin
	`uvm_create_on(s_b, p_sequencer.sqr1)
	s_b.grab(p_sequencer.sqr1);
	// or p_sequencer.sqr1.grab(s_b);
	`uvm_rand_send(s_b)
	s_b.ungrab(p_sequencer.sqr1);
	// or p_sequencer.sqr1.ungrab(s_b);
	ungrab(p_sequencer.sqr1);
	end
	begin
	`uvm_create_on(s_c, p_sequencer.sqr1)
	`uvm_rand_send(s_c)
	end
	join
	endtask : body
	endclass : parallel_sequence
	//-----Test-----
	class my_test extends uvm_test;
	my_agent agent1;
	my_agent agent2;
	my_virtual_sqr vsqr;
	`uvm_component_utils(my_test)
	function new (string name = "my_test", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	function void build_phase (uvm_phase phase);
	super.build_phase(phase);
	agent1 = my_agent::type_id::create("agent1", this);
	agent2 = my_agent::type_id::create("agent2", this);
	vsqr = my_virtual_sqr::type_id::create("vsqr", this);
	endfunction : build_phase
	function void connect_phase(uvm_phase phase);
	super.connect_phase(phase);
	vsqr.sqr1 = agent1.sqr;
	vsqr.sqr2 = agent2.sqr;
	endfunction : connect_phase
	task run_phase(uvm_phase phase);
	parallel_sequence p_seq;
	p_seq = parallel_sequence::type_id::create("p_seq");
	phase.raise_objection(this);
	p_seq.start(vsqr);
	phase.drop_objection(this);
	endtask : run_phase
	endclass : my_test
	module top();
	initial begin
	run_test("my_test");
	end
	endmodule : top
	// Output:
	// 0 Driving pkt inst:PUSH_B
	// 10 Driving pkt inst:PUSH_B
	// 20 Driving pkt inst:PUSH_B
	// 30 Driving pkt inst:PUSH_B
	// UVM_ERROR .../uvm-1.2/seq/uvm_sequencer_base.svh(1296) @ 40: uvm_test_top.agent1.sqr [SEQFINERR] Parent sequence 'uvm_test_top.vsqr.p_seq.s_b' should not finish before locks from itself and descedent sequences are removed. The lock held by the child sequence 'uvm_test_top.vsqr.p_seq.s_b' is being removed.
	// UVM_WARNING @ 40: uvm_test_top.agent1.sqr [SQRUNL] Sequence 'uvm_test_top.vsqr.p_seq.s_b' called ungrab / unlock, but didn't have lock
	// UVM_WARNING @ 40: uvm_test_top.agent1.sqr [SQRUNL] Sequence 'uvm_test_top.vsqr.p_seq' called ungrab / unlock, but didn't have lock
	// 40 Driving pkt inst:PUSH_A
	// 50 Driving pkt inst:POP_C
	// 60 Driving pkt inst:PUSH_A
	// 70 Driving pkt inst:POP_C
	// 80 Driving pkt inst:PUSH_A
	// 90 Driving pkt inst:POP_C
	// 100 Driving pkt inst:PUSH_A
	// 110 Driving pkt inst:POP_C

view raw unlock_after_seq_finished.sv hosted with ❤ by GitHub

---------------------------------------------

Now let’s go through one example where 2 virtual sequences are running in parallel and one virtual sequence put lock/grab on agent’s sequencer.

---------------------------------------------

	`include "uvm_pkg.sv"
	import uvm_pkg::*;
	typedef enum {PUSH_A,PUSH_B,ADD,SUB,MUL,DIV,POP_C} inst_e;
	//-----Packet/Transaction-----
	class my_seq_item extends uvm_sequence_item;
	rand inst_e inst;
	`uvm_object_utils_begin(my_seq_item)
	`uvm_field_enum(inst_e,inst, UVM_DEFAULT)
	`uvm_object_utils_end
	function new (string name = "my_seq_item");
	super.new(name);
	endfunction : new
	function string convert2string();
	convert2string = $sformatf("inst:%s", inst.name());
	endfunction : convert2string
	endclass : my_seq_item
	//-----Sequencer-----
	class my_sequencer extends uvm_sequencer #(my_seq_item);
	`uvm_sequencer_utils(my_sequencer)
	function new (string name = "my_sequencer", uvm_component parent = null);
	super.new(name, parent);
	`uvm_update_sequence_lib_and_item(my_seq_item)
	endfunction : new
	endclass : my_sequencer
	//-----Driver-----
	class my_driver extends uvm_driver #(my_seq_item);
	`uvm_component_utils(my_driver)
	function new (string name = "my_driver", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	task run_phase (uvm_phase phase);
	forever begin
	seq_item_port.get_next_item(req);
	`uvm_info(get_name(), $sformatf("Driving pkt %s", req.convert2string()), UVM_LOW)
	#10;
	seq_item_port.item_done();
	end
	endtask : run_phase
	endclass : my_driver
	//-----Agent-----
	class my_agent extends uvm_agent;
	my_sequencer sqr;
	my_driver drv;
	`uvm_component_utils(my_agent)
	function new (string name = "my_agent", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	function void build_phase (uvm_phase phase);
	super.build_phase(phase);
	sqr = my_sequencer::type_id::create("sqr", this);
	drv = my_driver::type_id::create("drv", this);
	endfunction : build_phase
	function void connect_phase (uvm_phase phase);
	super.connect_phase(phase);
	drv.seq_item_port.connect(sqr.seq_item_export);
	endfunction : connect_phase
	endclass : my_agent
	//-----Virtual Sequencer-----
	class my_virtual_sqr extends uvm_sequencer;
	my_sequencer sqr1;
	my_sequencer sqr2;
	`uvm_component_utils(my_virtual_sqr)
	function new (string name = "my_virtual_sqr", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	endclass : my_virtual_sqr
	//-----seq_a-----
	class seq_a extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_a)
	function new(string name="seq_a");
	super.new(name);
	endfunction : new
	virtual task body();
	for (int unsigned i=0; i<4; i ++) begin
	`uvm_do_with(req, { inst == PUSH_A; });
	`uvm_info(get_full_name(), $sformatf("completed :%0d iteration", i), UVM_LOW)
	end
	endtask : body
	endclass : seq_a
	//-----seq_b-----
	class seq_b extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_b)
	function new(string name="seq_b");
	super.new(name);
	endfunction : new
	virtual task body();
	for (int unsigned i=0; i<4; i ++) begin
	`uvm_do_with(req, { inst == PUSH_B; });
	`uvm_info(get_full_name(), $sformatf("completed :%0d iteration", i), UVM_LOW)
	end
	endtask : body
	endclass : seq_b
	//-----seq_c-----
	class seq_c extends uvm_sequence #(my_seq_item);
	my_seq_item req;
	`uvm_object_utils(seq_c)
	function new(string name="seq_c");
	super.new(name);
	endfunction : new
	virtual task body();
	for (int unsigned i=0; i<4; i ++) begin
	`uvm_do_with(req, { inst == POP_C; });
	`uvm_info(get_full_name(), $sformatf("completed :%0d iteration", i), UVM_LOW)
	end
	endtask : body
	endclass : seq_c
	//-----Virtual Sequence-----
	class parallel_sequence extends uvm_sequence #(my_seq_item);
	seq_a s_a;
	seq_b s_b;
	seq_c s_c;
	`uvm_object_utils(parallel_sequence)
	`uvm_declare_p_sequencer(my_virtual_sqr)
	function new(string name="parallel_sequence");
	super.new(name);
	endfunction : new
	virtual task body();
	grab(p_sequencer.sqr1);
	fork
	begin
	`uvm_create_on(s_a, p_sequencer.sqr1)
	`uvm_rand_send(s_a)
	`uvm_info(get_name(), $sformatf("s_a completed"), UVM_LOW)
	end
	begin
	`uvm_create_on(s_b, p_sequencer.sqr1)
	`uvm_rand_send(s_b)
	`uvm_info(get_name(), $sformatf("s_b completed"), UVM_LOW)
	end
	begin
	`uvm_create_on(s_c, p_sequencer.sqr2)
	`uvm_rand_send(s_c)
	`uvm_info(get_name(), $sformatf("s_c completed"), UVM_LOW)
	end
	join
	ungrab(p_sequencer.sqr1);
	endtask : body
	endclass : parallel_sequence
	//-----Virtual Sequence-----
	class parallel_sequence1 extends uvm_sequence #(my_seq_item);
	seq_a s_a;
	seq_b s_b;
	seq_c s_c;
	`uvm_object_utils(parallel_sequence1)
	`uvm_declare_p_sequencer(my_virtual_sqr)
	function new(string name="parallel_sequence1");
	super.new(name);
	endfunction : new
	virtual task body();
	fork
	begin
	`uvm_create_on(s_a, p_sequencer.sqr1)
	`uvm_rand_send(s_a)
	`uvm_info(get_name(), $sformatf("s_a completed"), UVM_LOW)
	end
	begin
	`uvm_create_on(s_b, p_sequencer.sqr1)
	`uvm_rand_send(s_b)
	`uvm_info(get_name(), $sformatf("s_b completed"), UVM_LOW)
	end
	begin
	`uvm_create_on(s_c, p_sequencer.sqr2)
	`uvm_rand_send(s_c)
	`uvm_info(get_name(), $sformatf("s_c completed"), UVM_LOW)
	end
	join
	endtask : body
	endclass : parallel_sequence1
	//-----Test-----
	class my_test extends uvm_test;
	my_agent agent1;
	my_agent agent2;
	my_virtual_sqr vsqr;
	`uvm_component_utils(my_test)
	function new (string name = "my_test", uvm_component parent = null);
	super.new(name, parent);
	endfunction : new
	function void build_phase (uvm_phase phase);
	super.build_phase(phase);
	agent1 = my_agent::type_id::create("agent1", this);
	agent2 = my_agent::type_id::create("agent2", this);
	vsqr = my_virtual_sqr::type_id::create("vsqr", this);
	endfunction : build_phase
	function void connect_phase(uvm_phase phase);
	super.connect_phase(phase);
	vsqr.sqr1 = agent1.sqr;
	vsqr.sqr2 = agent2.sqr;
	endfunction : connect_phase
	task run_phase(uvm_phase phase);
	parallel_sequence p_seq;
	parallel_sequence1 p1_seq;
	p_seq = parallel_sequence::type_id::create("p_seq");
	p1_seq = parallel_sequence1::type_id::create("p1_seq");
	phase.raise_objection(this);
	fork
	p_seq.start(vsqr);
	p1_seq.start(vsqr);
	join
	phase.drop_objection(this);
	endtask : run_phase
	endclass : my_test
	module top();
	initial begin
	run_test("my_test");
	end
	endmodule : top
	// Output:
	// UVM_INFO grab_top_4.sv(42) @ 0: uvm_test_top.agent2.drv [drv] Driving pkt inst:POP_C
	// UVM_INFO grab_top_4.sv(42) @ 0: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_A
	// UVM_INFO grab_top_4.sv(128) @ 10: uvm_test_top.agent2.sqr@@p_seq.s_c [uvm_test_top.vsqr.p_seq.s_c] completed :0 iteration
	// UVM_INFO grab_top_4.sv(94) @ 10: uvm_test_top.agent1.sqr@@p_seq.s_a [uvm_test_top.vsqr.p_seq.s_a] completed :0 iteration
	// UVM_INFO grab_top_4.sv(42) @ 10: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_B
	// UVM_INFO grab_top_4.sv(42) @ 10: uvm_test_top.agent2.drv [drv] Driving pkt inst:POP_C
	// UVM_INFO grab_top_4.sv(111) @ 20: uvm_test_top.agent1.sqr@@p_seq.s_b [uvm_test_top.vsqr.p_seq.s_b] completed :0 iteration
	// UVM_INFO grab_top_4.sv(128) @ 20: uvm_test_top.agent2.sqr@@p1_seq.s_c [uvm_test_top.vsqr.p1_seq.s_c] completed :0 iteration
	// UVM_INFO grab_top_4.sv(42) @ 20: uvm_test_top.agent2.drv [drv] Driving pkt inst:POP_C
	// UVM_INFO grab_top_4.sv(42) @ 20: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_A
	// UVM_INFO grab_top_4.sv(128) @ 30: uvm_test_top.agent2.sqr@@p_seq.s_c [uvm_test_top.vsqr.p_seq.s_c] completed :1 iteration
	// UVM_INFO grab_top_4.sv(94) @ 30: uvm_test_top.agent1.sqr@@p_seq.s_a [uvm_test_top.vsqr.p_seq.s_a] completed :1 iteration
	// UVM_INFO grab_top_4.sv(42) @ 30: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_B
	// UVM_INFO grab_top_4.sv(42) @ 30: uvm_test_top.agent2.drv [drv] Driving pkt inst:POP_C
	// UVM_INFO grab_top_4.sv(111) @ 40: uvm_test_top.agent1.sqr@@p_seq.s_b [uvm_test_top.vsqr.p_seq.s_b] completed :1 iteration
	// UVM_INFO grab_top_4.sv(128) @ 40: uvm_test_top.agent2.sqr@@p1_seq.s_c [uvm_test_top.vsqr.p1_seq.s_c] completed :1 iteration
	// UVM_INFO grab_top_4.sv(42) @ 40: uvm_test_top.agent2.drv [drv] Driving pkt inst:POP_C
	// UVM_INFO grab_top_4.sv(42) @ 40: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_A
	// UVM_INFO grab_top_4.sv(128) @ 50: uvm_test_top.agent2.sqr@@p_seq.s_c [uvm_test_top.vsqr.p_seq.s_c] completed :2 iteration
	// UVM_INFO grab_top_4.sv(94) @ 50: uvm_test_top.agent1.sqr@@p_seq.s_a [uvm_test_top.vsqr.p_seq.s_a] completed :2 iteration
	// UVM_INFO grab_top_4.sv(42) @ 50: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_B
	// UVM_INFO grab_top_4.sv(42) @ 50: uvm_test_top.agent2.drv [drv] Driving pkt inst:POP_C
	// UVM_INFO grab_top_4.sv(111) @ 60: uvm_test_top.agent1.sqr@@p_seq.s_b [uvm_test_top.vsqr.p_seq.s_b] completed :2 iteration
	// UVM_INFO grab_top_4.sv(128) @ 60: uvm_test_top.agent2.sqr@@p1_seq.s_c [uvm_test_top.vsqr.p1_seq.s_c] completed :2 iteration
	// UVM_INFO grab_top_4.sv(42) @ 60: uvm_test_top.agent2.drv [drv] Driving pkt inst:POP_C
	// UVM_INFO grab_top_4.sv(42) @ 60: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_A
	// UVM_INFO grab_top_4.sv(128) @ 70: uvm_test_top.agent2.sqr@@p_seq.s_c [uvm_test_top.vsqr.p_seq.s_c] completed :3 iteration
	// UVM_INFO grab_top_4.sv(94) @ 70: uvm_test_top.agent1.sqr@@p_seq.s_a [uvm_test_top.vsqr.p_seq.s_a] completed :3 iteration
	// UVM_INFO grab_top_4.sv(161) @ 70: uvm_test_top.vsqr@@p_seq [p_seq] s_c completed
	// UVM_INFO grab_top_4.sv(151) @ 70: uvm_test_top.vsqr@@p_seq [p_seq] s_a completed
	// UVM_INFO grab_top_4.sv(42) @ 70: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_B
	// UVM_INFO grab_top_4.sv(42) @ 70: uvm_test_top.agent2.drv [drv] Driving pkt inst:POP_C
	// UVM_INFO grab_top_4.sv(111) @ 80: uvm_test_top.agent1.sqr@@p_seq.s_b [uvm_test_top.vsqr.p_seq.s_b] completed :3 iteration
	// UVM_INFO grab_top_4.sv(128) @ 80: uvm_test_top.agent2.sqr@@p1_seq.s_c [uvm_test_top.vsqr.p1_seq.s_c] completed :3 iteration
	// UVM_INFO grab_top_4.sv(156) @ 80: uvm_test_top.vsqr@@p_seq [p_seq] s_b completed
	// UVM_INFO grab_top_4.sv(195) @ 80: uvm_test_top.vsqr@@p1_seq [p1_seq] s_c completed
	// UVM_INFO grab_top_4.sv(42) @ 80: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_A
	// UVM_INFO grab_top_4.sv(94) @ 90: uvm_test_top.agent1.sqr@@p1_seq.s_a [uvm_test_top.vsqr.p1_seq.s_a] completed :0 iteration
	// UVM_INFO grab_top_4.sv(42) @ 90: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_B
	// UVM_INFO grab_top_4.sv(111) @ 100: uvm_test_top.agent1.sqr@@p1_seq.s_b [uvm_test_top.vsqr.p1_seq.s_b] completed :0 iteration
	// UVM_INFO grab_top_4.sv(42) @ 100: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_A
	// UVM_INFO grab_top_4.sv(94) @ 110: uvm_test_top.agent1.sqr@@p1_seq.s_a [uvm_test_top.vsqr.p1_seq.s_a] completed :1 iteration
	// UVM_INFO grab_top_4.sv(42) @ 110: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_B
	// UVM_INFO grab_top_4.sv(111) @ 120: uvm_test_top.agent1.sqr@@p1_seq.s_b [uvm_test_top.vsqr.p1_seq.s_b] completed :1 iteration
	// UVM_INFO grab_top_4.sv(42) @ 120: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_A
	// UVM_INFO grab_top_4.sv(94) @ 130: uvm_test_top.agent1.sqr@@p1_seq.s_a [uvm_test_top.vsqr.p1_seq.s_a] completed :2 iteration
	// UVM_INFO grab_top_4.sv(42) @ 130: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_B
	// UVM_INFO grab_top_4.sv(111) @ 140: uvm_test_top.agent1.sqr@@p1_seq.s_b [uvm_test_top.vsqr.p1_seq.s_b] completed :2 iteration
	// UVM_INFO grab_top_4.sv(42) @ 140: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_A
	// UVM_INFO grab_top_4.sv(94) @ 150: uvm_test_top.agent1.sqr@@p1_seq.s_a [uvm_test_top.vsqr.p1_seq.s_a] completed :3 iteration
	// UVM_INFO grab_top_4.sv(185) @ 150: uvm_test_top.vsqr@@p1_seq [p1_seq] s_a completed
	// UVM_INFO grab_top_4.sv(42) @ 150: uvm_test_top.agent1.drv [drv] Driving pkt inst:PUSH_B
	// UVM_INFO grab_top_4.sv(111) @ 160: uvm_test_top.agent1.sqr@@p1_seq.s_b [uvm_test_top.vsqr.p1_seq.s_b] completed :3 iteration
	// UVM_INFO grab_top_4.sv(190) @ 160: uvm_test_top.vsqr@@p1_seq [p1_seq] s_b completed

view raw two_virtual_running_in_parallel.sv hosted with ❤ by GitHub

---------------------------------------------

Difference between @event and wait(event.triggered) in SystemVerilog and usage of non-blocking event

The event data type provides a handle to a synchronization object.

There are two ways through which we can wait for particular event to be triggered.
So let's understand what is the exact difference between those 2 ways.

-----------------------------------------------

	event e;
	// Triggered event 'e'
	->e;
	// wait for event 'e' to be triggered (instantaneous)
	@(e);
	// wait for event 'e' to be triggered (Persistent)
	wait(e.triggered);

view raw sv_event_1.sv hosted with ❤ by GitHub

-----------------------------------------------

An event trigger ->e is an instantaneous event. The event waiting process @ shall execute before the triggering process -> executes. If the trigger executes first, then the waiting process remains blocked.

The triggered event property evaluates to true (1'b1) if the given event has been triggered in the current time step and false (1'b0) otherwise.
Now you no longer have to worry which came first, the triggering process –> or the waiting process @ statement. But you still have to execute the waiting process @ in the current time slot to catch the event.

Let’s see the behavior with examples,
-----------------------------------------------

	class event_class;
	event ev;
	task trig;
	->ev;
	endtask : trig
	task execute1;
	@(ev);
	$display("Testing of the event @");
	endtask : execute1
	// First trigger event and after that
	// wait for event to be triggered in same simulation time
	task ex1;
	trig;
	execute1;
	endtask : ex1
	endclass : event_class
	module top();
	event_class E;
	initial begin
	E = new();
	fork
	begin
	E.ex1; // wait using @
	end
	begin
	#10;
	$display("Missed trigger of event");
	end
	join_any
	disable fork;
	end
	endmodule : top
	// Output:
	// Missed trigger of event

view raw sv_event_2.sv hosted with ❤ by GitHub

-----------------------------------------------

-----------------------------------------------

	class event_class;
	event ev;
	task trig;
	->ev;
	endtask : trig
	task execute2;
	wait(ev.triggered);
	$display("Testing of the event wait(.triggered)");
	endtask : execute2
	// First trigger event and after that
	// wait for event to be triggered in same simulation time
	task ex2;
	trig;
	execute2;
	endtask : ex2
	endclass : event_class
	module top();
	event_class E;
	initial begin
	E = new();
	fork
	begin
	E.ex2; // wait using wait(event.triggered)
	end
	begin
	#10;
	$display("Missed trigger of event");
	end
	join_any
	disable fork;
	end
	endmodule : top
	// Output:
	// Testing of the event wait(.triggered)

view raw sv_event_3.sv hosted with ❤ by GitHub

-----------------------------------------------

The other workaround is to use nonblocking event

Non-blocking event ->>
Nonblocking events are triggered using the ->> operator.

The effect of the ->> operator is that the statement executes without blocking, and it creates a nonblocking assign update event in the time in which the delay control expires or the event control occurs. The effect of this update event shall be to trigger the referenced event in the nonblocking assignment region of the simulation cycle.

-----------------------------------------------

	module top();
	event blocking_ev;
	event non_blocking_ev;
	process process_b;
	process process_nb;
	initial begin
	fork
	begin
	process_b = process::self();
	-> blocking_ev;
	@ blocking_ev;
	end
	begin
	process_nb = process::self();
	->> non_blocking_ev;
	@ non_blocking_ev;
	end
	join_none
	#10;
	$display("process_b.status:%s", process_b.status);
	$display("process_nb.status:%s", process_nb.status);
	end
	endmodule : top
	// Output:
	// process_b.status:WAITING
	// process_nb.status:FINISHED

view raw non_blocking_event.sv hosted with ❤ by GitHub

-----------------------------------------------