Subversion Repositories uart2bus_testbench

//----------------------------------------------------------------------

//   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) uvm_config_seq;

typedef class uvm_sequence_request;

// Utility class for tracking default_sequences

class 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 uvm_sequencer_base extends uvm_component;

  typedef enum {SEQ_TYPE_REQ,

                SEQ_TYPE_LOCK,

                SEQ_TYPE_GRAB} 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 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 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

  //  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 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

  //  is called.

  extern virtual task 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 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 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 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 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 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 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 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 grab(uvm_sequence_base sequence_ptr);

  // Function: unlock

  //

  // Removes any locks and grabs obtained by the specified sequence_ptr.

  //

  extern virtual function void unlock(uvm_sequence_base sequence_ptr);

  // Function: ungrab

  //

  // Removes any locks and grabs obtained by the specified sequence_ptr.

  //

  extern virtual function void  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 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 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 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 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 set_arbitration(UVM_SEQ_ARB_TYPE val);

  // Function: get_arbitration

  //

  // Return the current arbitration mode set for this sequencer. See

  //  for a list of possible modes.

  //

  extern function UVM_SEQ_ARB_TYPE get_arbitration();

  // Task: wait_for_sequences

  //

  // Waits for a sequence to have a new item available. Uses

  //  to give a sequence as much time as

  // possible to deliver an item before advancing time.

  extern virtual task 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  call.

  extern virtual function void 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 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 kill_sequence(uvm_sequence_base sequence_ptr);

  extern virtual function void analysis_write(uvm_sequence_item t);

  extern virtual   function void   build();

  extern virtual   function void   build_phase(uvm_phase phase);

  extern           function void   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 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 disable_auto_item_recording();

    m_auto_item_recording = 0;

  endfunction

  virtual function bit 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              add_sequence(string type_name);

  extern function void              remove_sequence(string type_name);

  extern function void              set_sequences_queue(ref string sequencer_sequence_lib[$]);

  extern virtual task               start_default_sequence();

  extern function int               get_seq_kind(string type_name);

  extern function uvm_sequence_base get_sequence(int req_kind);

  extern function int               num_sequences();

  extern virtual function void      m_add_builtin_seqs(bit add_simple = 1);

  extern virtual task               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);