//----------------------------------------------------------------------
// Copyright 2007-2011 Mentor Graphics Corporation
// Copyright 2007-2011 Cadence Design Systems, Inc.
// Copyright 2010-2011 Synopsys, Inc.
// Copyright 2013-2014 NVIDIA Corporation
// All Rights Reserved Worldwide
//
// Licensed under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in
// compliance with the License. You may obtain a copy of
// the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in
// writing, software distributed under the License is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See
// the License for the specific language governing
// permissions and limitations under the License.
//----------------------------------------------------------------------
typedef uvm_config_db#(uvm_sequence_base) [docs]uvm_config_seq;
typedef class [docs]uvm_sequence_request;
// Utility class for tracking default_sequences
class [docs]uvm_sequence_process_wrapper;
process pid;
uvm_sequence_base seq;
endclass : uvm_sequence_process_wrapper
//------------------------------------------------------------------------------
//
// CLASS: uvm_sequencer_base
//
// Controls the flow of sequences, which generate the stimulus (sequence item
// transactions) that is passed on to drivers for execution.
//
//------------------------------------------------------------------------------
class [docs]uvm_sequencer_base extends uvm_component;
typedef enum {SEQ_TYPE_REQ,
SEQ_TYPE_LOCK,
SEQ_TYPE_GRAB} [docs]seq_req_t; // FIXME SEQ_TYPE_GRAB is unused
// queue of sequences waiting for arbitration
protected uvm_sequence_request arb_sequence_q[$];
protected bit arb_completed[int];
protected uvm_sequence_base lock_list[$];
protected uvm_sequence_base reg_sequences[int];
protected int m_sequencer_id;
protected int m_lock_arb_size; // used for waiting processes
protected int m_arb_size; // used for waiting processes
protected int m_wait_for_item_sequence_id,
m_wait_for_item_transaction_id;
protected int m_wait_relevant_count = 0 ;
protected int m_max_zero_time_wait_relevant_count = 10;
protected time m_last_wait_relevant_time = 0 ;
local uvm_sequencer_arb_mode m_arbitration = UVM_SEQ_ARB_FIFO;
local static int g_request_id;
local static int g_sequence_id = 1;
local static int g_sequencer_id = 1;
// Function: new
//
// Creates and initializes an instance of this class using the normal
// constructor arguments for uvm_component: name is the name of the
// instance, and parent is the handle to the hierarchical parent.
extern function [docs]new (string name, uvm_component parent);
// Function: is_child
//
// Returns 1 if the child sequence is a child of the parent sequence,
// 0 otherwise.
//
extern function bit [docs]is_child (uvm_sequence_base parent, uvm_sequence_base child);
// Function: user_priority_arbitration
//
// When the sequencer arbitration mode is set to UVM_SEQ_ARB_USER (via the
// <set_arbitration> method), the sequencer will call this function each
// time that it needs to arbitrate among sequences.
//
// Derived sequencers may override this method to perform a custom arbitration
// policy. The override must return one of the entries from the
// avail_sequences queue, which are indexes into an internal queue,
// arb_sequence_q.
//
// The default implementation behaves like UVM_SEQ_ARB_FIFO, which returns the
// entry at avail_sequences[0].
//
extern virtual function integer [docs]user_priority_arbitration(integer avail_sequences[$]);
// Task: execute_item
//
// Executes the given transaction ~item~ directly on this sequencer. A temporary
// parent sequence is automatically created for the ~item~. There is no capability to
// retrieve responses. If the driver returns responses, they will accumulate in the
// sequencer, eventually causing response overflow unless
// <uvm_sequence_base::set_response_queue_error_report_disabled> is called.
extern virtual task [docs]execute_item(uvm_sequence_item item);
// Hidden array, keeps track of running default sequences
protected uvm_sequence_process_wrapper m_default_sequences[uvm_phase];
// Function: start_phase_sequence
//
// Start the default sequence for this phase, if any.
// The default sequence is configured via resources using
// either a sequence instance or sequence type (object wrapper).
// If both are used,
// the sequence instance takes precedence. When attempting to override
// a previous default sequence setting, you must override both
// the instance and type (wrapper) resources, else your override may not
// take effect.
//
// When setting the resource using ~set~, the 1st argument specifies the
// context pointer, usually ~this~ for components or ~null~ when executed from
// outside the component hierarchy (i.e. in module).
// The 2nd argument is the instance string, which is a path name to the
// target sequencer, relative to the context pointer. The path must include
// the name of the phase with a "_phase" suffix. The 3rd argument is the
// resource name, which is "default_sequence". The 4th argument is either
// an object wrapper for the sequence type, or an instance of a sequence.
//
// Configuration by instances
// allows pre-initialization, setting rand_mode, use of inline
// constraints, etc.
//
//| myseq_t myseq = new("myseq");
//| myseq.randomize() with { ... };
//| uvm_config_db #(uvm_sequence_base)::set(null, "top.agent.myseqr.main_phase",
//| "default_sequence",
//| myseq);
//
// Configuration by type is shorter and can be substituted via
// the factory.
//
//| uvm_config_db #(uvm_object_wrapper)::set(null, "top.agent.myseqr.main_phase",
//| "default_sequence",
//| myseq_type::type_id::get());
//
// The uvm_resource_db can similarly be used.
//
//| myseq_t myseq = new("myseq");
//| myseq.randomize() with { ... };
//| uvm_resource_db #(uvm_sequence_base)::set({get_full_name(), ".myseqr.main_phase",
//| "default_sequence",
//| myseq, this);
//
//| uvm_resource_db #(uvm_object_wrapper)::set({get_full_name(), ".myseqr.main_phase",
//| "default_sequence",
//| myseq_t::type_id::get(),
//| this );
//
//
extern virtual function void [docs]start_phase_sequence(uvm_phase phase);
// Function: stop_phase_sequence
//
// Stop the default sequence for this phase, if any exists, and it
// is still executing.
extern virtual function void [docs]stop_phase_sequence(uvm_phase phase);
// Task: wait_for_grant
//
// This task issues a request for the specified sequence. If item_priority
// is not specified, then the current sequence priority will be used by the
// arbiter. If a lock_request is made, then the sequencer will issue a lock
// immediately before granting the sequence. (Note that the lock may be
// granted without the sequence being granted if is_relevant is not asserted).
//
// When this method returns, the sequencer has granted the sequence, and the
// sequence must call send_request without inserting any simulation delay
// other than delta cycles. The driver is currently waiting for the next
// item to be sent via the send_request call.
extern virtual task [docs]wait_for_grant(uvm_sequence_base sequence_ptr,
int item_priority = -1,
bit lock_request = 0);
// Task: wait_for_item_done
//
// A sequence may optionally call wait_for_item_done. This task will block
// until the driver calls item_done() or put() on a transaction issued by the
// specified sequence. If no transaction_id parameter is specified, then the
// call will return the next time that the driver calls item_done() or put().
// If a specific transaction_id is specified, then the call will only return
// when the driver indicates that it has completed that specific item.
//
// Note that if a specific transaction_id has been specified, and the driver
// has already issued an item_done or put for that transaction, then the call
// will hang waiting for that specific transaction_id.
//
extern virtual task [docs]wait_for_item_done(uvm_sequence_base sequence_ptr,
int transaction_id);
// Function: is_blocked
//
// Returns 1 if the sequence referred to by sequence_ptr is currently locked
// out of the sequencer. It will return 0 if the sequence is currently
// allowed to issue operations.
//
// Note that even when a sequence is not blocked, it is possible for another
// sequence to issue a lock before this sequence is able to issue a request
// or lock.
//
extern function bit [docs]is_blocked(uvm_sequence_base sequence_ptr);
// Function: has_lock
//
// Returns 1 if the sequence referred to in the parameter currently has a lock
// on this sequencer, 0 otherwise.
//
// Note that even if this sequence has a lock, a child sequence may also have
// a lock, in which case the sequence is still blocked from issuing
// operations on the sequencer
//
extern function bit [docs]has_lock(uvm_sequence_base sequence_ptr);
// Task: lock
//
// Requests a lock for the sequence specified by sequence_ptr.
//
// A lock request will be arbitrated the same as any other request. A lock is
// granted after all earlier requests are completed and no other locks or
// grabs are blocking this sequence.
//
// The lock call will return when the lock has been granted.
//
extern virtual task [docs]lock(uvm_sequence_base sequence_ptr);
// Task: grab
//
// Requests a lock for the sequence specified by sequence_ptr.
//
// A grab request is put in front of the arbitration queue. It will be
// arbitrated before any other requests. A grab is granted when no other
// grabs or locks are blocking this sequence.
//
// The grab call will return when the grab has been granted.
//
extern virtual task [docs]grab(uvm_sequence_base sequence_ptr);
// Function: unlock
//
// Removes any locks and grabs obtained by the specified sequence_ptr.
//
extern virtual function void [docs]unlock(uvm_sequence_base sequence_ptr);
// Function: ungrab
//
// Removes any locks and grabs obtained by the specified sequence_ptr.
//
extern virtual function void [docs]ungrab(uvm_sequence_base sequence_ptr);
// Function: stop_sequences
//
// Tells the sequencer to kill all sequences and child sequences currently
// operating on the sequencer, and remove all requests, locks and responses
// that are currently queued. This essentially resets the sequencer to an
// idle state.
//
extern virtual function void [docs]stop_sequences();
// Function: is_grabbed
//
// Returns 1 if any sequence currently has a lock or grab on this sequencer,
// 0 otherwise.
//
extern virtual function bit [docs]is_grabbed();
// Function: current_grabber
//
// Returns a reference to the sequence that currently has a lock or grab on
// the sequence. If multiple hierarchical sequences have a lock, it returns
// the child that is currently allowed to perform operations on the sequencer.
//
extern virtual function uvm_sequence_base [docs]current_grabber();
// Function: has_do_available
//
// Returns 1 if any sequence running on this sequencer is ready to supply a
// transaction, 0 otherwise. A sequence is ready if it is not blocked (via
// ~grab~ or ~lock~ and ~is_relevant~ returns 1.
//
extern virtual function bit [docs]has_do_available();
// Function: set_arbitration
//
// Specifies the arbitration mode for the sequencer. It is one of
//
// UVM_SEQ_ARB_FIFO - Requests are granted in FIFO order (default)
// UVM_SEQ_ARB_WEIGHTED - Requests are granted randomly by weight
// UVM_SEQ_ARB_RANDOM - Requests are granted randomly
// UVM_SEQ_ARB_STRICT_FIFO - Requests at highest priority granted in FIFO order
// UVM_SEQ_ARB_STRICT_RANDOM - Requests at highest priority granted in randomly
// UVM_SEQ_ARB_USER - Arbitration is delegated to the user-defined
// function, user_priority_arbitration. That function
// will specify the next sequence to grant.
//
// The default user function specifies FIFO order.
//
extern function void [docs]set_arbitration(UVM_SEQ_ARB_TYPE val);
// Function: get_arbitration
//
// Return the current arbitration mode set for this sequencer. See
// <set_arbitration> for a list of possible modes.
//
extern function UVM_SEQ_ARB_TYPE [docs]get_arbitration();
// Task: wait_for_sequences
//
// Waits for a sequence to have a new item available. Uses
// <uvm_wait_for_nba_region> to give a sequence as much time as
// possible to deliver an item before advancing time.
extern virtual task [docs]wait_for_sequences();
// Function: send_request
//
// Derived classes implement this function to send a request item to the
// sequencer, which will forward it to the driver. If the rerandomize bit
// is set, the item will be randomized before being sent to the driver.
//
// This function may only be called after a <wait_for_grant> call.
extern virtual function void [docs]send_request(uvm_sequence_base sequence_ptr,
uvm_sequence_item t,
bit rerandomize = 0);
// Function: set_max_zero_time_wait_relevant_count
//
// Can be called at any time to change the maximum number of times
// wait_for_relevant() can be called by the sequencer in zero time before
// an error is declared. The default maximum is 10.
extern virtual function void [docs]set_max_zero_time_wait_relevant_count(int new_val) ;
//----------------------------------------------------------------------------
// INTERNAL METHODS - DO NOT CALL DIRECTLY, ONLY OVERLOAD IF VIRTUAL
//----------------------------------------------------------------------------
extern protected function void grant_queued_locks();
extern protected task m_select_sequence();
extern protected function int m_choose_next_request();
extern task m_wait_for_arbitration_completed(int request_id);
extern function void m_set_arbitration_completed(int request_id);
extern local task m_lock_req(uvm_sequence_base sequence_ptr, bit lock);
// Task- m_unlock_req
//
// Called by a sequence to request an unlock. This
// will remove a lock for this sequence if it exists
extern function void m_unlock_req(uvm_sequence_base sequence_ptr);
extern local function void remove_sequence_from_queues(uvm_sequence_base sequence_ptr);
extern function void m_sequence_exiting(uvm_sequence_base sequence_ptr);
extern function void [docs]kill_sequence(uvm_sequence_base sequence_ptr);
extern virtual function void [docs]analysis_write(uvm_sequence_item t);
extern virtual function void [docs]build();
extern virtual function void [docs]build_phase(uvm_phase phase);
extern function void [docs]do_print (uvm_printer printer);
extern virtual function int m_register_sequence(uvm_sequence_base sequence_ptr);
extern protected
virtual function void m_unregister_sequence(int sequence_id);
extern protected function
uvm_sequence_base m_find_sequence(int sequence_id);
extern protected function void m_update_lists();
extern function string [docs]convert2string();
extern protected
virtual function int m_find_number_driver_connections();
extern protected task m_wait_arb_not_equal();
extern protected task m_wait_for_available_sequence();
extern protected function int m_get_seq_item_priority(uvm_sequence_request seq_q_entry);
int m_is_relevant_completed;
`ifdef UVM_DISABLE_AUTO_ITEM_RECORDING
local bit m_auto_item_recording = 0;
`else
local bit m_auto_item_recording = 1;
`endif
// Access to following internal methods provided via seq_item_export
virtual function void [docs]disable_auto_item_recording();
m_auto_item_recording = 0;
endfunction
virtual function bit [docs]is_auto_item_recording_enabled();
return m_auto_item_recording;
endfunction
//----------------------------------------------------------------------------
// DEPRECATED - DO NOT USE IN NEW DESIGNS - NOT PART OF UVM STANDARD
//----------------------------------------------------------------------------
`ifndef UVM_NO_DEPRECATED
// Variable- count
//
// Sets the number of items to execute.
//
// Supercedes the max_random_count variable for uvm_random_sequence class
// for backward compatibility.
int count = -1;
int m_random_count;
int m_exhaustive_count;
int m_simple_count;
int unsigned max_random_count = 10;
int unsigned max_random_depth = 4;
protected string default_sequence = "uvm_random_sequence";
protected bit m_default_seq_set;
string sequences[$];
protected int sequence_ids[string];
protected rand int seq_kind;
extern function void [docs]add_sequence(string type_name);
extern function void [docs]remove_sequence(string type_name);
extern function void [docs]set_sequences_queue(ref string sequencer_sequence_lib[$]);
extern virtual task [docs]start_default_sequence();
extern function int [docs]get_seq_kind(string type_name);
extern function uvm_sequence_base [docs]get_sequence(int req_kind);
extern function int [docs]num_sequences();
extern virtual function void m_add_builtin_seqs(bit add_simple = 1);
extern virtual task [docs]run_phase(uvm_phase phase);
`endif
endclass
//------------------------------------------------------------------------------
// IMPLEMENTATION
//------------------------------------------------------------------------------
// new
// ---
function uvm_sequencer_base::new (string name, uvm_component parent);
super.new(name, parent);
m_sequencer_id = g_sequencer_id++;
m_lock_arb_size = -1;
endfunction
// build_phase
// -----------
function void uvm_sequencer_base::build_phase(uvm_phase phase);
// For mantis 3402, the config stuff must be done in the deprecated
// build() phase in order for a manual build call to work. Both
// the manual build call and the config settings in build() are
// deprecated.
super.build_phase(phase);
endfunction
function void uvm_sequencer_base::build();
int dummy;
super.build();
`ifndef UVM_NO_DEPRECATED
// deprecated parameters for sequencer. Use uvm_sequence_library class
// for sequence library functionality.
if (uvm_config_string::get(this, "", "default_sequence", default_sequence)) begin
`uvm_warning("UVM_DEPRECATED",{"default_sequence config parameter is deprecated and not ",
"part of the UVM standard. See documentation for uvm_sequencer_base::start_phase_sequence()."})
this.m_default_seq_set = 1;
end
if (uvm_config_int::get(this, "", "count", count)) begin
`uvm_warning("UVM_DEPRECATED",{"count config parameter is deprecated and not ",
"part of the UVM standard"})
end
if (uvm_config_int::get(this, "", "max_random_count", max_random_count)) begin
`uvm_warning("UVM_DEPRECATED",{"count config parameter is deprecated and not ",
"part of the UVM standard"})
end
if (uvm_config_int::get(this, "", "max_random_depth", max_random_depth)) begin
`uvm_warning("UVM_DEPRECATED",{"max_random_depth config parameter is deprecated and not ",
"part of the UVM standard. Use 'uvm_sequence_library' class for ",
"sequence library functionality"})
end
if (uvm_config_int::get(this, "", "pound_zero_count", dummy))
`uvm_warning("UVM_DEPRECATED",
{"pound_zero_count was set but ignored. ",
"Sequencer/driver synchronization now uses 'uvm_wait_for_nba_region'"})
`endif // UVM_NO_DEPRECATED
endfunction
// do_print
// --------
function void uvm_sequencer_base::do_print (uvm_printer printer);
super.do_print(printer);
printer.print_array_header("arbitration_queue", arb_sequence_q.size());
foreach (arb_sequence_q[i])
printer.print_string($sformatf("[%0d]", i),
$sformatf("%s@seqid%0d",arb_sequence_q[i].request.name(),arb_sequence_q[i].sequence_id), "[");
printer.print_array_footer(arb_sequence_q.size());
printer.print_array_header("lock_queue", lock_list.size());
foreach(lock_list[i])
printer.print_string($sformatf("[%0d]", i),
$sformatf("%s@seqid%0d",lock_list[i].get_full_name(),lock_list[i].get_sequence_id()), "[");
printer.print_array_footer(lock_list.size());
endfunction
// m_update_lists
// --------------
function void uvm_sequencer_base::m_update_lists();
m_lock_arb_size++;
endfunction
// convert2string
// ----------------
function string uvm_sequencer_base::convert2string();
string s;
$sformat(s, " -- arb i/id/type: ");
foreach (arb_sequence_q[i]) begin
$sformat(s, "%s %0d/%0d/%s ", s, i, arb_sequence_q[i].sequence_id, arb_sequence_q[i].request.name());
end
$sformat(s, "%s\n -- lock_list i/id: ", s);
foreach (lock_list[i]) begin
$sformat(s, "%s %0d/%0d",s, i, lock_list[i].get_sequence_id());
end
return(s);
endfunction
// m_find_number_driver_connections
// --------------------------------
function int uvm_sequencer_base::m_find_number_driver_connections();
return 0;
endfunction
// m_register_sequence
// -------------------
function int uvm_sequencer_base::m_register_sequence(uvm_sequence_base sequence_ptr);
if (sequence_ptr.m_get_sqr_sequence_id(m_sequencer_id, 1) > 0)
return sequence_ptr.get_sequence_id();
sequence_ptr.m_set_sqr_sequence_id(m_sequencer_id, g_sequence_id++);
reg_sequences[sequence_ptr.get_sequence_id()] = sequence_ptr;
return sequence_ptr.get_sequence_id();
endfunction
// m_find_sequence
// ---------------
function uvm_sequence_base uvm_sequencer_base::m_find_sequence(int sequence_id);
uvm_sequence_base seq_ptr;
int i;
// When sequence_id is -1, return the first available sequence. This is used
// when deleting all sequences
if (sequence_id == -1) begin
if (reg_sequences.first(i)) begin
return(reg_sequences[i]);
end
return(null);
end
if (!reg_sequences.exists(sequence_id))
return null;
return reg_sequences[sequence_id];
endfunction
// m_unregister_sequence
// ---------------------
function void uvm_sequencer_base::m_unregister_sequence(int sequence_id);
if (!reg_sequences.exists(sequence_id))
return;
reg_sequences.delete(sequence_id);
endfunction
// user_priority_arbitration
// -------------------------
function integer uvm_sequencer_base::user_priority_arbitration(integer avail_sequences[$]);
return avail_sequences[0];
endfunction
// grant_queued_locks
// ------------------
// Any lock or grab requests that are at the front of the queue will be
// granted at the earliest possible time. This function grants any queues
// at the front that are not locked out
function void uvm_sequencer_base::grant_queued_locks();
// first remove sequences with dead lock control process
begin
uvm_sequence_request q[$];
q = arb_sequence_q.find(item) with (item.request==SEQ_TYPE_LOCK && item.process_id.status inside {process::KILLED,process::FINISHED});
foreach(q[idx]) begin
`uvm_error("SEQLCKZMB", $sformatf("The task responsible for requesting a lock on sequencer '%s' for sequence '%s' has been killed, to avoid a deadlock the sequence will be removed from the arbitration queues", this.get_full_name(), q[idx].sequence_ptr.get_full_name()))
remove_sequence_from_queues(q[idx].sequence_ptr);
end
end
// now move all is_blocked() into lock_list
begin
uvm_sequence_request leading_lock_reqs[$],blocked_seqs[$],not_blocked_seqs[$];
int q1[$];
int b=arb_sequence_q.size(); // index for first non-LOCK request
q1 = arb_sequence_q.find_first_index(item) with (item.request!=SEQ_TYPE_LOCK);
if(q1.size())
b=q1[0];
if(b!=0) begin // at least one lock
leading_lock_reqs = arb_sequence_q[0:b-1]; // set of locks; arb_sequence[b] is the first req!=SEQ_TYPE_LOCK
// split into blocked/not-blocked requests
foreach(leading_lock_reqs[i]) begin
uvm_sequence_request item = leading_lock_reqs[i];
if(is_blocked(item.sequence_ptr)!=0)
blocked_seqs.push_back(item);
else
not_blocked_seqs.push_back(item);
end
if(b>arb_sequence_q.size()-1)
arb_sequence_q=blocked_seqs;
else
arb_sequence_q={blocked_seqs,arb_sequence_q[b:arb_sequence_q.size()-1]};
foreach(not_blocked_seqs[idx]) begin
lock_list.push_back(not_blocked_seqs[idx].sequence_ptr);
m_set_arbitration_completed(not_blocked_seqs[idx].request_id);
end
// trigger listeners if lock list has changed
if(not_blocked_seqs.size())
m_update_lists();
end
end
endfunction
// m_select_sequence
// -----------------
task uvm_sequencer_base::m_select_sequence();
int selected_sequence;
// Select a sequence
do begin
wait_for_sequences();
selected_sequence = m_choose_next_request();
if (selected_sequence == -1) begin
m_wait_for_available_sequence();
end
end while (selected_sequence == -1);
// issue grant
if (selected_sequence >= 0) begin
m_set_arbitration_completed(arb_sequence_q[selected_sequence].request_id);
arb_sequence_q.delete(selected_sequence);
m_update_lists();
end
endtask
// m_choose_next_request
// ---------------------
// When a driver requests an operation, this function must find the next
// available, unlocked, relevant sequence.
//
// This function returns -1 if no sequences are available or the entry into
// arb_sequence_q for the chosen sequence
function int uvm_sequencer_base::m_choose_next_request();
int i, temp;
int avail_sequence_count;
int sum_priority_val;
integer avail_sequences[$];
integer highest_sequences[$];
int highest_pri;
string s;
avail_sequence_count = 0;
grant_queued_locks();
i = 0;
while (i < arb_sequence_q.size()) begin
if ((arb_sequence_q[i].process_id.status == process::KILLED) ||
(arb_sequence_q[i].process_id.status == process::FINISHED)) begin
`uvm_error("SEQREQZMB", $sformatf("The task responsible for requesting a wait_for_grant on sequencer '%s' for sequence '%s' has been killed, to avoid a deadlock the sequence will be removed from the arbitration queues", this.get_full_name(), arb_sequence_q[i].sequence_ptr.get_full_name()))
remove_sequence_from_queues(arb_sequence_q[i].sequence_ptr);
continue;
end
if (i < arb_sequence_q.size())
if (arb_sequence_q[i].request == SEQ_TYPE_REQ)
if (is_blocked(arb_sequence_q[i].sequence_ptr) == 0)
if (arb_sequence_q[i].sequence_ptr.is_relevant() == 1) begin
if (m_arbitration == UVM_SEQ_ARB_FIFO) begin
return i;
end
else avail_sequences.push_back(i);
end
i++;
end
// Return immediately if there are 0 or 1 available sequences
if (m_arbitration == UVM_SEQ_ARB_FIFO) begin
return -1;
end
if (avail_sequences.size() < 1) begin
return -1;
end
if (avail_sequences.size() == 1) begin
return avail_sequences[0];
end
// If any locks are in place, then the available queue must
// be checked to see if a lock prevents any sequence from proceeding
if (lock_list.size() > 0) begin
for (i = 0; i < avail_sequences.size(); i++) begin
if (is_blocked(arb_sequence_q[avail_sequences[i]].sequence_ptr) != 0) begin
avail_sequences.delete(i);
i--;
end
end
if (avail_sequences.size() < 1)
return -1;
if (avail_sequences.size() == 1)
return avail_sequences[0];
end
// Weighted Priority Distribution
// Pick an available sequence based on weighted priorities of available sequences
if (m_arbitration == UVM_SEQ_ARB_WEIGHTED) begin
sum_priority_val = 0;
for (i = 0; i < avail_sequences.size(); i++) begin
sum_priority_val += m_get_seq_item_priority(arb_sequence_q[avail_sequences[i]]);
end
temp = $urandom_range(sum_priority_val-1, 0);
sum_priority_val = 0;
for (i = 0; i < avail_sequences.size(); i++) begin
if ((m_get_seq_item_priority(arb_sequence_q[avail_sequences[i]]) +
sum_priority_val) > temp) begin
return avail_sequences[i];
end
sum_priority_val += m_get_seq_item_priority(arb_sequence_q[avail_sequences[i]]);
end
uvm_report_fatal("Sequencer", "UVM Internal error in weighted arbitration code", UVM_NONE);
end
// Random Distribution
if (m_arbitration == UVM_SEQ_ARB_RANDOM) begin
i = $urandom_range(avail_sequences.size()-1, 0);
return avail_sequences[i];
end
// Strict Fifo
if ((m_arbitration == UVM_SEQ_ARB_STRICT_FIFO) || m_arbitration == UVM_SEQ_ARB_STRICT_RANDOM) begin
highest_pri = 0;
// Build a list of sequences at the highest priority
for (i = 0; i < avail_sequences.size(); i++) begin
if (m_get_seq_item_priority(arb_sequence_q[avail_sequences[i]]) > highest_pri) begin
// New highest priority, so start new list
highest_sequences.delete();
highest_sequences.push_back(avail_sequences[i]);
highest_pri = m_get_seq_item_priority(arb_sequence_q[avail_sequences[i]]);
end
else if (m_get_seq_item_priority(arb_sequence_q[avail_sequences[i]]) == highest_pri) begin
highest_sequences.push_back(avail_sequences[i]);
end
end
// Now choose one based on arbitration type
if (m_arbitration == UVM_SEQ_ARB_STRICT_FIFO) begin
return(highest_sequences[0]);
end
i = $urandom_range(highest_sequences.size()-1, 0);
return highest_sequences[i];
end
if (m_arbitration == UVM_SEQ_ARB_USER) begin
i = user_priority_arbitration( avail_sequences);
// Check that the returned sequence is in the list of available sequences. Failure to
// use an available sequence will cause highly unpredictable results.
highest_sequences = avail_sequences.find with (item == i);
if (highest_sequences.size() == 0) begin
uvm_report_fatal("Sequencer",
$sformatf("Error in User arbitration, sequence %0d not available\n%s",
i, convert2string()), UVM_NONE);
end
return(i);
end
uvm_report_fatal("Sequencer", "Internal error: Failed to choose sequence", UVM_NONE);
endfunction
// m_wait_arb_not_equal
// --------------------
task uvm_sequencer_base::m_wait_arb_not_equal();
wait (m_arb_size != m_lock_arb_size);
endtask
// m_wait_for_available_sequence
// -----------------------------
task uvm_sequencer_base::m_wait_for_available_sequence();
int i;
int is_relevant_entries[$];
// This routine will wait for a change in the request list, or for
// wait_for_relevant to return on any non-relevant, non-blocked sequence
m_arb_size = m_lock_arb_size;
for (i = 0; i < arb_sequence_q.size(); i++) begin
if (arb_sequence_q[i].request == SEQ_TYPE_REQ) begin
if (is_blocked(arb_sequence_q[i].sequence_ptr) == 0) begin
if (arb_sequence_q[i].sequence_ptr.is_relevant() == 0) begin
is_relevant_entries.push_back(i);
end
end
end
end
// Typical path - don't need fork if all queued entries are relevant
if (is_relevant_entries.size() == 0) begin
m_wait_arb_not_equal();
return;
end
fork // isolate inner fork block for disabling
begin
fork
begin
fork
begin
// One path in fork is for any wait_for_relevant to return
m_is_relevant_completed = 0;
for(i = 0; i < is_relevant_entries.size(); i++) begin
fork
automatic int k = i;
begin
arb_sequence_q[is_relevant_entries[k]].sequence_ptr.wait_for_relevant();
if ($realtime != m_last_wait_relevant_time) begin
m_last_wait_relevant_time = $realtime ;
m_wait_relevant_count = 0 ;
end
else begin
m_wait_relevant_count++ ;
if (m_wait_relevant_count > m_max_zero_time_wait_relevant_count) begin
`uvm_fatal("SEQRELEVANTLOOP",$sformatf("Zero time loop detected, passed wait_for_relevant %0d times without time advancing",m_wait_relevant_count))
end
end
m_is_relevant_completed = 1;
end
join_none
end
wait (m_is_relevant_completed > 0);
end
// The other path in the fork is for any queue entry to change
begin
m_wait_arb_not_equal();
end
join_any
end
join_any
disable fork;
end
join
endtask
// m_get_seq_item_priority
// -----------------------
function int uvm_sequencer_base::m_get_seq_item_priority(uvm_sequence_request seq_q_entry);
// If the priority was set on the item, then that is used
if (seq_q_entry.item_priority != -1) begin
if (seq_q_entry.item_priority <= 0) begin
uvm_report_fatal("SEQITEMPRI",
$sformatf("Sequence item from %s has illegal priority: %0d",
seq_q_entry.sequence_ptr.get_full_name(),
seq_q_entry.item_priority), UVM_NONE);
end
return seq_q_entry.item_priority;
end
// Otherwise, use the priority of the calling sequence
if (seq_q_entry.sequence_ptr.get_priority() < 0) begin
uvm_report_fatal("SEQDEFPRI",
$sformatf("Sequence %s has illegal priority: %0d",
seq_q_entry.sequence_ptr.get_full_name(),
seq_q_entry.sequence_ptr.get_priority()), UVM_NONE);
end
return seq_q_entry.sequence_ptr.get_priority();
endfunction
// m_wait_for_arbitration_completed
// --------------------------------
task uvm_sequencer_base::m_wait_for_arbitration_completed(int request_id);
int lock_arb_size;
// Search the list of arb_wait_q, see if this item is done
forever
begin
lock_arb_size = m_lock_arb_size;
if (arb_completed.exists(request_id)) begin
arb_completed.delete(request_id);
return;
end
wait (lock_arb_size != m_lock_arb_size);
end
endtask
// m_set_arbitration_completed
// ---------------------------
function void uvm_sequencer_base::m_set_arbitration_completed(int request_id);
arb_completed[request_id] = 1;
endfunction
// is_child
// --------
function bit uvm_sequencer_base::is_child (uvm_sequence_base parent,
uvm_sequence_base child);
uvm_sequence_base child_parent;
if (child == null) begin
uvm_report_fatal("uvm_sequencer", "is_child passed null child", UVM_NONE);
end
if (parent == null) begin
uvm_report_fatal("uvm_sequencer", "is_child passed null parent", UVM_NONE);
end
child_parent = child.get_parent_sequence();
while (child_parent != null) begin
if (child_parent.get_inst_id() == parent.get_inst_id()) begin
return 1;
end
child_parent = child_parent.get_parent_sequence();
end
return 0;
endfunction
// execute_item
// ------------
task uvm_sequencer_base::execute_item(uvm_sequence_item item);
uvm_sequence_base seq;
seq = new();
item.set_sequencer(this);
item.set_parent_sequence(seq);
seq.set_sequencer(this);
seq.start_item(item);
seq.finish_item(item);
endtask
// wait_for_grant
// --------------
task uvm_sequencer_base::wait_for_grant(uvm_sequence_base sequence_ptr,
int item_priority = -1,
bit lock_request = 0);
uvm_sequence_request req_s;
int my_seq_id;
if (sequence_ptr == null)
uvm_report_fatal("uvm_sequencer",
"wait_for_grant passed null sequence_ptr", UVM_NONE);
my_seq_id = m_register_sequence(sequence_ptr);
// If lock_request is asserted, then issue a lock. Don't wait for the response, since
// there is a request immediately following the lock request
if (lock_request == 1) begin
req_s = new();
req_s.grant = 0;
req_s.sequence_id = my_seq_id;
req_s.request = SEQ_TYPE_LOCK;
req_s.sequence_ptr = sequence_ptr;
req_s.request_id = g_request_id++;
req_s.process_id = process::self();
arb_sequence_q.push_back(req_s);
end
// Push the request onto the queue
req_s = new();
req_s.grant = 0;
req_s.request = SEQ_TYPE_REQ;
req_s.sequence_id = my_seq_id;
req_s.item_priority = item_priority;
req_s.sequence_ptr = sequence_ptr;
req_s.request_id = g_request_id++;
req_s.process_id = process::self();
arb_sequence_q.push_back(req_s);
m_update_lists();
// Wait until this entry is granted
// Continue to point to the element, since location in queue will change
m_wait_for_arbitration_completed(req_s.request_id);
// The wait_for_grant_semaphore is used only to check that send_request
// is only called after wait_for_grant. This is not a complete check, since
// requests might be done in parallel, but it will catch basic errors
req_s.sequence_ptr.m_wait_for_grant_semaphore++;
endtask
// wait_for_item_done
// ------------------
task uvm_sequencer_base::wait_for_item_done(uvm_sequence_base sequence_ptr,
int transaction_id);
int sequence_id;
sequence_id = sequence_ptr.m_get_sqr_sequence_id(m_sequencer_id, 1);
m_wait_for_item_sequence_id = -1;
m_wait_for_item_transaction_id = -1;
if (transaction_id == -1)
wait (m_wait_for_item_sequence_id == sequence_id);
else
wait ((m_wait_for_item_sequence_id == sequence_id &&
m_wait_for_item_transaction_id == transaction_id));
endtask
// is_blocked
// ----------
function bit uvm_sequencer_base::is_blocked(uvm_sequence_base sequence_ptr);
if (sequence_ptr == null)
uvm_report_fatal("uvm_sequence_controller",
"is_blocked passed null sequence_ptr", UVM_NONE);
foreach (lock_list[i]) begin
if ((lock_list[i].get_inst_id() !=
sequence_ptr.get_inst_id()) &&
(is_child(lock_list[i], sequence_ptr) == 0)) begin
return 1;
end
end
return 0;
endfunction
// has_lock
// --------
function bit uvm_sequencer_base::has_lock(uvm_sequence_base sequence_ptr);
int my_seq_id;
if (sequence_ptr == null)
uvm_report_fatal("uvm_sequence_controller",
"has_lock passed null sequence_ptr", UVM_NONE);
my_seq_id = m_register_sequence(sequence_ptr);
foreach (lock_list[i]) begin
if (lock_list[i].get_inst_id() == sequence_ptr.get_inst_id()) begin
return 1;
end
end
return 0;
endfunction
// m_lock_req
// ----------
// Internal method. Called by a sequence to request a lock.
// Puts the lock request onto the arbitration queue.
task uvm_sequencer_base::m_lock_req(uvm_sequence_base sequence_ptr, bit lock);
int my_seq_id;
uvm_sequence_request new_req;
if (sequence_ptr == null)
uvm_report_fatal("uvm_sequence_controller",
"lock_req passed null sequence_ptr", UVM_NONE);
my_seq_id = m_register_sequence(sequence_ptr);
new_req = new();
new_req.grant = 0;
new_req.sequence_id = sequence_ptr.get_sequence_id();
new_req.request = SEQ_TYPE_LOCK;
new_req.sequence_ptr = sequence_ptr;
new_req.request_id = g_request_id++;
new_req.process_id = process::self();
if (lock == 1) begin
// Locks are arbitrated just like all other requests
arb_sequence_q.push_back(new_req);
end else begin
// Grabs are not arbitrated - they go to the front
// TODO:
// Missing: grabs get arbitrated behind other grabs
arb_sequence_q.push_front(new_req);
m_update_lists();
end
// If this lock can be granted immediately, then do so.
grant_queued_locks();
m_wait_for_arbitration_completed(new_req.request_id);
endtask
// m_unlock_req
// ------------
// Called by a sequence to request an unlock. This
// will remove a lock for this sequence if it exists
function void uvm_sequencer_base::m_unlock_req(uvm_sequence_base sequence_ptr);
if (sequence_ptr == null) begin
uvm_report_fatal("uvm_sequencer",
"m_unlock_req passed null sequence_ptr", UVM_NONE);
end
begin
int q[$];
int seqid=sequence_ptr.get_inst_id();
q=lock_list.find_first_index(item) with (item.get_inst_id() == seqid);
if(q.size()==1) begin
lock_list.delete(q[0]);
grant_queued_locks(); // grant lock requests
m_update_lists();
end
else
uvm_report_warning("SQRUNL",
{"Sequence '", sequence_ptr.get_full_name(),
"' called ungrab / unlock, but didn't have lock"}, UVM_NONE);
end
endfunction
// lock
// ----
task uvm_sequencer_base::lock(uvm_sequence_base sequence_ptr);
m_lock_req(sequence_ptr, 1);
endtask
// grab
// ----
task uvm_sequencer_base::grab(uvm_sequence_base sequence_ptr);
m_lock_req(sequence_ptr, 0);
endtask
// unlock
// ------
function void uvm_sequencer_base::unlock(uvm_sequence_base sequence_ptr);
m_unlock_req(sequence_ptr);
endfunction
// ungrab
// ------
function void uvm_sequencer_base::ungrab(uvm_sequence_base sequence_ptr);
m_unlock_req(sequence_ptr);
endfunction
// remove_sequence_from_queues
// ---------------------------
function void uvm_sequencer_base::remove_sequence_from_queues(
uvm_sequence_base sequence_ptr);
int i;
int seq_id;
seq_id = sequence_ptr.m_get_sqr_sequence_id(m_sequencer_id, 0);
// Remove all queued items for this sequence and any child sequences
i = 0;
do
begin
if (arb_sequence_q.size() > i) begin
if ((arb_sequence_q[i].sequence_id == seq_id) ||
(is_child(sequence_ptr, arb_sequence_q[i].sequence_ptr))) begin
if (sequence_ptr.get_sequence_state() == UVM_FINISHED)
`uvm_error("SEQFINERR", $sformatf("Parent sequence '%s' should not finish before all items from itself and items from descendent sequences are processed. The item request from the sequence '%s' is being removed.", sequence_ptr.get_full_name(), arb_sequence_q[i].sequence_ptr.get_full_name()))
arb_sequence_q.delete(i);
m_update_lists();
end
else begin
i++;
end
end
end
while (i < arb_sequence_q.size());
// remove locks for this sequence, and any child sequences
i = 0;
do
begin
if (lock_list.size() > i) begin
if ((lock_list[i].get_inst_id() == sequence_ptr.get_inst_id()) ||
(is_child(sequence_ptr, lock_list[i]))) begin
if (sequence_ptr.get_sequence_state() == UVM_FINISHED)
`uvm_error("SEQFINERR", $sformatf("Parent sequence '%s' should not finish before locks from itself and descedent sequences are removed. The lock held by the child sequence '%s' is being removed.",sequence_ptr.get_full_name(), lock_list[i].get_full_name()))
lock_list.delete(i);
m_update_lists();
end
else begin
i++;
end
end
end
while (i < lock_list.size());
// Unregister the sequence_id, so that any returning data is dropped
m_unregister_sequence(sequence_ptr.m_get_sqr_sequence_id(m_sequencer_id, 1));
endfunction
// stop_sequences
// --------------
function void uvm_sequencer_base::stop_sequences();
uvm_sequence_base seq_ptr;
seq_ptr = m_find_sequence(-1);
while (seq_ptr != null)
begin
kill_sequence(seq_ptr);
seq_ptr = m_find_sequence(-1);
end
endfunction
// m_sequence_exiting
// ------------------
function void uvm_sequencer_base::m_sequence_exiting(uvm_sequence_base sequence_ptr);
remove_sequence_from_queues(sequence_ptr);
endfunction
// kill_sequence
// -------------
function void uvm_sequencer_base::kill_sequence(uvm_sequence_base sequence_ptr);
remove_sequence_from_queues(sequence_ptr);
sequence_ptr.m_kill();
endfunction
// is_grabbed
// ----------
function bit uvm_sequencer_base::is_grabbed();
return (lock_list.size() != 0);
endfunction
// current_grabber
// ---------------
function uvm_sequence_base uvm_sequencer_base::current_grabber();
if (lock_list.size() == 0) begin
return null;
end
return lock_list[lock_list.size()-1];
endfunction
// has_do_available
// ----------------
function bit uvm_sequencer_base::has_do_available();
foreach (arb_sequence_q[i]) begin
if ((arb_sequence_q[i].sequence_ptr.is_relevant() == 1) &&
(is_blocked(arb_sequence_q[i].sequence_ptr) == 0)) begin
return 1;
end
end
return 0;
endfunction
// set_arbitration
// ---------------
function void uvm_sequencer_base::set_arbitration(UVM_SEQ_ARB_TYPE val);
m_arbitration = val;
endfunction
// get_arbitration
// ---------------
function UVM_SEQ_ARB_TYPE uvm_sequencer_base::get_arbitration();
return m_arbitration;
endfunction
// analysis_write
// --------------
function void uvm_sequencer_base::analysis_write(uvm_sequence_item t);
return;
endfunction
// wait_for_sequences
// ------------------
task uvm_sequencer_base::wait_for_sequences();
uvm_wait_for_nba_region();
endtask
// send_request
// ------------
function void uvm_sequencer_base::send_request(uvm_sequence_base sequence_ptr,
uvm_sequence_item t,
bit rerandomize = 0);
return;
endfunction
// set_max_zero_time_wait_relevant_count
// ------------
function void uvm_sequencer_base::set_max_zero_time_wait_relevant_count(int new_val) ;
m_max_zero_time_wait_relevant_count = new_val ;
endfunction
// start_phase_sequence
// --------------------
function void uvm_sequencer_base::start_phase_sequence(uvm_phase phase);
uvm_resource_pool rp = uvm_resource_pool::get();
uvm_resource_types::rsrc_q_t rq;
uvm_sequence_base seq;
uvm_coreservice_t cs = uvm_coreservice_t::get();
uvm_factory f = cs.get_factory();
// Has a default sequence been specified?
rq = rp.lookup_name({get_full_name(), ".", phase.get_name(), "_phase"},
"default_sequence", null, 0);
uvm_resource_pool::sort_by_precedence(rq);
// Look for the first one if the appropriate type
for (int i = 0; seq == null && i < rq.size(); i++) begin
uvm_resource_base rsrc = rq.get(i);
uvm_resource#(uvm_sequence_base) sbr;
uvm_resource#(uvm_object_wrapper) owr;
// uvm_config_db#(uvm_sequence_base)?
// Priority is given to uvm_sequence_base because it is a specific sequence instance
// and thus more specific than one that is dynamically created via the
// factory and the object wrapper.
if ($cast(sbr, rsrc) && sbr != null) begin
seq = sbr.read(this);
if (seq == null) begin
`uvm_info("UVM/SQR/PH/DEF/SB/NULL", {"Default phase sequence for phase '",
phase.get_name(),"' explicitly disabled"}, UVM_FULL)
return;
end
end
// uvm_config_db#(uvm_object_wrapper)?
else if ($cast(owr, rsrc) && owr != null) begin
uvm_object_wrapper wrapper;
wrapper = owr.read(this);
if (wrapper == null) begin
`uvm_info("UVM/SQR/PH/DEF/OW/NULL", {"Default phase sequence for phase '",
phase.get_name(),"' explicitly disabled"}, UVM_FULL)
return;
end
if (!$cast(seq, f.create_object_by_type(wrapper, get_full_name(),
wrapper.get_type_name()))
|| seq == null) begin
`uvm_warning("PHASESEQ", {"Default sequence for phase '",
phase.get_name(),"' %s is not a sequence type"})
return;
end
end
end
if (seq == null) begin
`uvm_info("PHASESEQ", {"No default phase sequence for phase '",
phase.get_name(),"'"}, UVM_FULL)
return;
end
`uvm_info("PHASESEQ", {"Starting default sequence '",
seq.get_type_name(),"' for phase '", phase.get_name(),"'"}, UVM_FULL)
seq.print_sequence_info = 1;
seq.set_sequencer(this);
seq.reseed();
seq.set_starting_phase(phase);
if (!seq.do_not_randomize && !seq.randomize()) begin
`uvm_warning("STRDEFSEQ", {"Randomization failed for default sequence '",
seq.get_type_name(),"' for phase '", phase.get_name(),"'"})
return;
end
fork begin
uvm_sequence_process_wrapper w = new();
// reseed this process for random stability
w.pid = process::self();
w.seq = seq;
w.pid.srandom(uvm_create_random_seed(seq.get_type_name(), this.get_full_name()));
m_default_sequences[phase] = w;
// this will either complete naturally, or be killed later
seq.start(this);
m_default_sequences.delete(phase);
end
join_none
endfunction
// stop_phase_sequence
// --------------------
function void uvm_sequencer_base::stop_phase_sequence(uvm_phase phase);
if (m_default_sequences.exists(phase)) begin
`uvm_info("PHASESEQ",
{"Killing default sequence '", m_default_sequences[phase].seq.get_type_name(),
"' for phase '", phase.get_name(), "'"}, UVM_FULL)
m_default_sequences[phase].seq.kill();
end
else begin
`uvm_info("PHASESEQ",
{"No default sequence to kill for phase '", phase.get_name(), "'"},
UVM_FULL)
end
endfunction : stop_phase_sequence
//----------------------------------------------------------------------------
//
// *** DEPRECATED ***
//
// - DO NOT USE IN NEW DESIGNS -
//
// - NOT PART OF UVM STANDARD -
//----------------------------------------------------------------------------
`ifndef UVM_NO_DEPRECATED
// add_sequence
// ------------
//
// Adds a sequence of type specified in the type_name paramter to the
// sequencer's sequence library.
function void uvm_sequencer_base::add_sequence(string type_name);
`uvm_warning("UVM_DEPRECATED",{"Registering sequence '",type_name,
"' with sequencer '",get_full_name(),"' is deprecated. "})
//assign typename key to an int based on size
//used with get_seq_kind to return an int key to match a type name
if (!sequence_ids.exists(type_name)) begin
sequence_ids[type_name] = sequences.size();
//used w/ get_sequence to return a uvm_sequence factory object that
//matches an int id
sequences.push_back(type_name);
end
endfunction
// remove_sequence
// ---------------
function void uvm_sequencer_base::remove_sequence(string type_name);
sequence_ids.delete(type_name);
for (int i = 0; i < this.sequences.size(); i++) begin
if (this.sequences[i] == type_name)
this.sequences.delete(i);
end
endfunction
// set_sequences_queue
// -------------------
function void uvm_sequencer_base::set_sequences_queue(
ref string sequencer_sequence_lib[$]);
for(int j=0; j < sequencer_sequence_lib.size(); j++) begin
sequence_ids[sequencer_sequence_lib[j]] = sequences.size();
this.sequences.push_back(sequencer_sequence_lib[j]);
end
endfunction
// start_default_sequence
// ----------------------
// Called when the run phase begins, this method starts the default sequence,
// as specified by the default_sequence member variable.
//
task uvm_sequencer_base::start_default_sequence();
uvm_sequence_base m_seq ;
uvm_coreservice_t cs = uvm_coreservice_t::get();
uvm_factory factory=cs.get_factory();
// Default sequence was cleared, or the count is zero
if (default_sequence == "" || count == 0 ||
(sequences.size() == 0 && default_sequence == "uvm_random_sequence"))
return;
// Have run-time phases and no user setting of default sequence
if(this.m_default_seq_set == 0 && m_domain != null) begin
default_sequence = "";
`uvm_info("NODEFSEQ", {"The \"default_sequence\" has not been set. ",
"Since this sequencer has a runtime phase schedule, the ",
"uvm_random_sequence is not being started for the run phase."}, UVM_HIGH)
return;
end
// Have a user setting for both old and new default sequence mechanisms
if (this.m_default_seq_set == 1 &&
(uvm_config_db #(uvm_sequence_base)::exists(this, "run_phase", "default_sequence", 0) ||
uvm_config_db #(uvm_object_wrapper)::exists(this, "run_phase", "default_sequence", 0)))
begin
`uvm_warning("MULDEFSEQ", {"A default phase sequence has been set via the ",
"\"<phase_name>.default_sequence\" configuration option.",
"The deprecated \"default_sequence\" configuration option is ignored."})
return;
end
// no user sequences to choose from
if(sequences.size() == 2 &&
sequences[0] == "uvm_random_sequence" &&
sequences[1] == "uvm_exhaustive_sequence") begin
uvm_report_warning("NOUSERSEQ", {"No user sequence available. ",
"Not starting the (deprecated) default sequence."}, UVM_HIGH);
return;
end
`uvm_warning("UVM_DEPRECATED",{"Starting (deprecated) default sequence '",default_sequence,
"' on sequencer '",get_full_name(),
"'. See documentation for uvm_sequencer_base::start_phase_sequence() for information on ",
"starting default sequences in UVM."})
//create the sequence object
if (!$cast(m_seq, factory.create_object_by_name(default_sequence,
get_full_name(), default_sequence)))
begin
uvm_report_fatal("FCTSEQ",{"Default sequence set to invalid value : ",
default_sequence}, UVM_NONE);
end
if (m_seq == null) begin
uvm_report_fatal("STRDEFSEQ", "Null m_sequencer reference", UVM_NONE);
end
m_seq.set_starting_phase(run_ph);
m_seq.print_sequence_info = 1;
m_seq.set_parent_sequence(null);
m_seq.set_sequencer(this);
m_seq.reseed();
if (!m_seq.randomize()) begin
uvm_report_warning("STRDEFSEQ", "Failed to randomize sequence");
end
m_seq.start(this);
endtask
// get_seq_kind
// ------------
// Returns an int seq_kind correlating to the sequence of type type_name
// in the sequencers sequence library. If the named sequence is not
// registered a SEQNF warning is issued and -1 is returned.
function int uvm_sequencer_base::get_seq_kind(string type_name);
`uvm_warning("UVM_DEPRECATED", $sformatf("%m is deprecated"))
if (sequence_ids.exists(type_name))
return sequence_ids[type_name];
`uvm_warning("SEQNF",
{"Sequence type_name '",type_name,"' not registered with this sequencer."})
return -1;
endfunction
// get_sequence
// ------------
// Returns a reference to a sequence specified by the seq_kind int.
// The seq_kind int may be obtained using the get_seq_kind() method.
function uvm_sequence_base uvm_sequencer_base::get_sequence(int req_kind);
uvm_coreservice_t cs = uvm_coreservice_t::get();
uvm_factory factory = cs.get_factory();
uvm_sequence_base m_seq ;
string m_seq_type;
`uvm_warning("UVM_DEPRECATED", $sformatf("%m is deprecated"))
if (req_kind < 0 || req_kind >= sequences.size()) begin
uvm_report_error("SEQRNG",
$sformatf("Kind arg '%0d' out of range. Need 0-%0d",
req_kind, sequences.size()-1));
end
m_seq_type = sequences[req_kind];
if (!$cast(m_seq, factory.create_object_by_name(m_seq_type,
get_full_name(),
m_seq_type)))
begin
uvm_report_fatal("FCTSEQ",
$sformatf("Factory cannot produce a sequence of type %0s.",
m_seq_type), UVM_NONE);
end
m_seq.print_sequence_info = 1;
m_seq.set_sequencer (this);
return m_seq;
endfunction
// num_sequences
// -------------
function int uvm_sequencer_base::num_sequences();
return sequences.size();
endfunction
// m_add_builtin_seqs
// ------------------
function void uvm_sequencer_base::m_add_builtin_seqs(bit add_simple=1);
if(!sequence_ids.exists("uvm_random_sequence"))
add_sequence("uvm_random_sequence");
if(!sequence_ids.exists("uvm_exhaustive_sequence"))
add_sequence("uvm_exhaustive_sequence");
if(add_simple == 1) begin
if(!sequence_ids.exists("uvm_simple_sequence"))
add_sequence("uvm_simple_sequence");
end
endfunction
// run_phase
// ---------
task uvm_sequencer_base::run_phase(uvm_phase phase);
super.run_phase(phase);
start_default_sequence();
endtask
`endif // UVM_NO_DEPRECATED
//------------------------------------------------------------------------------
//
// Class- uvm_sequence_request
//
//------------------------------------------------------------------------------
class [docs]uvm_sequence_request;
bit grant;
int sequence_id;
int request_id;
int item_priority;
process process_id;
uvm_sequencer_base::seq_req_t request;
uvm_sequence_base sequence_ptr;
endclass