Subversion Repositories uart2bus_testbench

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

//   Copyright 2011 Cypress Semiconductor

//   Copyright 2010 Mentor Graphics Corporation

//   Copyright 2011 Cadence Design Systems, Inc.

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

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

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

// Title: Resources

//

// Topic: Intro

//

// A resource is a parameterized container that holds arbitrary data.

// Resources can be used to configure components, supply data to

// sequences, or enable sharing of information across disparate parts of

// a testbench.  They are stored using scoping information so their

// visibility can be constrained to certain parts of the testbench.

// Resource containers can hold any type of data, constrained only by

// the data types available in SystemVerilog.  Resources can contain

// scalar objects, class handles, queues, lists, or even virtual

// interfaces.

//

// Resources are stored in a resource database so that each resource can

// be retrieved by name or by type. The database has both a name table

// and a type table and each resource is entered into both. The database

// is globally accessible.

//

// Each resource has a set of scopes over which it is visible.  The set

// of scopes is represented as a regular expression.  When a resource is

// looked up the scope of the entity doing the looking up is supplied to

// the lookup function.  This is called the ~current scope~.  If the

// current scope is in the set of scopes over which a resource is

// visible then the resource can be retuned in the lookup.

//

// Resources can be looked up by name or by type. To support type lookup

// each resource has a static type handle that uniquely identifies the

// type of each specialized resource container.

//

// Multiple resources that have the same name are stored in a queue.

// Each resource is pushed into a queue with the first one at the front

// of the queue and each subsequent one behind it.  The same happens for

// multiple resources that have the same type.  The resource queues are

// searched front to back, so those placed earlier in the queue have

// precedence over those placed later.

//

// The precedence of resources with the same name or same type can be

// altered.  One way is to set the ~precedence~ member of the resource

// container to any arbitrary value.  The search algorithm will return

// the resource with the highest precedence.  In the case where there

// are multiple resources that match the search criteria and have the

// same (highest) precedence, the earliest one located in the queue will

// be one returned.  Another way to change the precedence is to use the

// set_priority function to move a resource to either the front or back

// of the queue.

//

// The classes defined here form the low level layer of the resource

// database.  The classes include the resource container and the database

// that holds the containers.  The following set of classes are defined

// here:

//

// : A class without methods or members, only

// typedefs and enums. These types and enums are used throughout the

// resources facility.  Putting the types in a class keeps them confined

// to a specific name space.

//

// : policy class for setting options, such

// as auditing, which effect resources.

//

// : the base (untyped) resource class living in the

// resource database.  This class includes the interface for setting a

// resource as read-only, notification, scope management, altering

// search priority, and managing auditing.

//

// : parameterized resource container.  This class

// includes the interfaces for reading and writing each resource.

// Because the class is parameterized, all the access functions are type

// safe.

//

// : the resource database. This is a singleton

// class object.

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

typedef class uvm_resource_base; // forward reference

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

// Class: uvm_resource_types

//

// Provides typedefs and enums used throughout the resources facility.

// This class has no members or methods, only typedefs.  It's used in

// lieu of package-scope types.  When needed, other classes can use

// these types by prefixing their usage with uvm_resource_types::.  E.g.

//

//|  uvm_resource_types::rsrc_q_t queue;

//

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

class uvm_resource_types;

  // types uses for setting overrides

  typedef bit[1:0] override_t;

  typedef enum override_t { TYPE_OVERRIDE = 2'b01,

                            NAME_OVERRIDE = 2'b10 } override_e;

   // general purpose queue of resourcex

  typedef uvm_queue#(uvm_resource_base) rsrc_q_t;

  // enum for setting resource search priority

  typedef enum { PRI_HIGH, PRI_LOW } priority_e;

  // access record for resources.  A set of these is stored for each

  // resource by accessing object.  It's updated for each read/write.

  typedef struct

  {

    time read_time;

    time write_time;

    int unsigned read_count;

    int unsigned write_count;

  } access_t;

endclass

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

// Class: uvm_resource_options

//

// Provides a namespace for managing options for the

// resources facility.  The only thing allowed in this class is static

// local data members and static functions for manipulating and

// retrieving the value of the data members.  The static local data

// members represent options and settings that control the behavior of

// the resources facility.

// Options include:

//

//  * auditing:  on/off

//

//    The default for auditing is on.  You may wish to turn it off to

//    for performance reasons.  With auditing off memory is not

//    consumed for storage of auditing information and time is not

//    spent collecting and storing auditing information.  Of course,

//    during the period when auditing is off no audit trail information

//    is available

//

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

class uvm_resource_options;

  static local bit auditing = 1;

  // Function: turn_on_auditing

  //

  // Turn auditing on for the resource database. This causes all

  // reads and writes to the database to store information about

  // the accesses. Auditing is turned on by default.

  static function void turn_on_auditing();

    auditing = 1;

  endfunction

  // Function: turn_off_auditing

  //

  // Turn auditing off for the resource database. If auditing is turned off,

  // it is not possible to get extra information about resource

  // database accesses.

  static function void turn_off_auditing();

    auditing = 0;

  endfunction

  // Function: is_auditing

  //

  // Returns 1 if the auditing facility is on and 0 if it is off.

  static function bit is_auditing();

    return auditing;

  endfunction

endclass

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

// Class: uvm_resource_base

//

// Non-parameterized base class for resources.  Supports interfaces for

// scope matching, and virtual functions for printing the resource and

// for printing the accessor list

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

virtual class uvm_resource_base extends uvm_object;

  protected string scope;

  protected bit modified;

  protected bit read_only;

  uvm_resource_types::access_t access[string];

  // variable: precedence

  //

  // This variable is used to associate a precedence that a resource

  // has with respect to other resources which match the same scope

  // and name. Resources are set to the  initially,

  // and may be set to a higher or lower precedence as desired.

  int unsigned precedence;

  // variable: default_precedence

  //

  // The default precedence for an resource that has been created.

  // When two resources have the same precedence, the first resource

  // found has precedence.

  //

  static int unsigned default_precedence = 1000;

  // Function: new

  //

  // constructor for uvm_resource_base.  The constructor takes two

  // arguments, the name of the resource and a regular expression which

  // represents the set of scopes over which this resource is visible.

  function new(string name = "", string s = "*");

    super.new(name);

    set_scope(s);

    modified = 0;

    read_only = 0;

    precedence = default_precedence;

  endfunction

  // Function: get_type_handle

  //

  // Pure virtual function that returns the type handle of the resource

  // container.

  pure virtual function uvm_resource_base get_type_handle();

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

  // Group: Read-only Interface

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

  // Function: set_read_only

  //

  // Establishes this resource as a read-only resource.  An attempt

  // to call  on the resource will cause an error.

  function void set_read_only();

    read_only = 1;

  endfunction

  // function set_read_write

  //

  // Returns the resource to normal read-write capability.

  // Implementation question: Not sure if this function is necessary.

  // Once a resource is set to read_only no one should be able to change

  // that.  If anyone can flip the read_only bit then the resource is not

  // truly read_only.

  function void set_read_write();

    read_only = 0;

  endfunction

  // Function: is_read_only

  //

  // Returns one if this resource has been set to read-only, zero

  // otherwise

  function bit is_read_only();

    return read_only;

  endfunction

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

  // Group: Notification

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

  // Task: wait_modified

  //

  // This task blocks until the resource has been modified -- that is, a

  //  operation has been performed.  When a

  //  is performed the modified bit is set which

  // releases the block.  Wait_modified() then clears the modified bit so

  // it can be called repeatedly.

  task wait_modified();

    wait (modified == 1);

    modified = 0;

  endtask

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

  // Group: Scope Interface

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

  //

  // Each resource has a name, a value and a set of scopes over which it

  // is visible. A scope is a hierarchical entity or a context.  A scope

  // name is a multi-element string that identifies a scope.  Each

  // element refers to a scope context and the elements are separated by

  // dots (.).

  //

  //|    top.env.agent.monitor

  //

  // Consider the example above of a scope name.  It consists of four

  // elements: "top", "env", "agent", and "monitor".  The elements are

  // strung together with a dot separating each element.  ~top.env.agent~

  // is the parent of ~top.env.agent.monitor~, ~top.env~ is the parent of

  // ~top.env.agent~, and so on.  A set of scopes can be represented by a

  // set of scope name strings.  A very straightforward way to represent

  // a set of strings is to use regular expressions.  A regular

  // expression is a special string that contains placeholders which can

  // be substituted in various ways to generate or recognize a

  // particular set of strings.  Here are a few simple examples:

  //

  //|     top\..*                       all of the scopes whose top-level component

  //|                            is top

  //|    top\.env\..*\.monitor  all of the scopes in env that end in monitor;

  //|                            i.e. all the monitors two levels down from env

  //|    .*\.monitor                all of the scopes that end in monitor; i.e.

  //|                            all the monitors (assuming a naming convention

  //|                            was used where all monitors are named "monitor")

  //|    top\.u[1-5]\.*         all of the scopes rooted and named u1, u2, u3,

  //                             u4, or u5, and any of their subscopes.

  //

  // The examples above use POSIX regular expression notation.  This is

  // a very general and expressive notation.  It is not always the case

  // that so much expressiveness is required.  Sometimes an expression

  // syntax that is easy to read and easy to write is useful, even if

  // the syntax is not as expressive as the full power of POSIX regular

  // expressions.  A popular substitute for regular expressions is

  // globs.  A glob is a simplified regular expression. It only has

  // three metacharacters -- *, +, and ?.  Character ranges are not

  // allowed and dots are not a metacharacter in globs as they are in

  // regular expressions.  The following table shows glob

  // metacharacters.

  //

  //|      char meaning                 regular expression

  //|                                    equivalent

  //|      *        0 or more characters        .*

  //|      +        1 or more characters        .+

  //|      ?        exactly one character       .

  //

  // Of the examples above, the first three can easily be translated

  // into globs.  The last one cannot.  It relies on notation that is

  // not available in glob syntax.

  //

  //|    regular expression         glob equivalent

  //|    ---------------------      ------------------

  //|    top\..*                    top.*

  //|    top\.env\..*\.monitor      top.env.*.monitor

  //|    .*\.monitor                *.monitor

  //

  // The resource facility supports both regular expression and glob

  // syntax.  Regular expressions are identified as such when they

  // surrounded by '/' characters. For example, ~/^top\.*/~ is

  // interpreted as the regular expression ~^top\.*~, where the

  // surrounding '/' characters have been removed. All other expressions

  // are treated as glob expressions. They are converted from glob

  // notation to regular expression notation internally.  Regular expression

  // compilation and matching as well as glob-to-regular expression

  // conversion are handled by two DPI functions:

  //

  //|    function int uvm_re_match(string re, string str);

  //|    function string uvm_glob_to_re(string glob);

  //

  // uvm_re_match both compiles and matches the regular expression.

  // All of the matching is done using regular expressions, so globs are

  // converted to regular expressions and then processed.

  // Function: set_scope

  //

  // Set the value of the regular expression that identifies the set of

  // scopes over which this resource is visible.  If the supplied

  // argument is a glob it will be converted to a regular expression

  // before it is stored.

  //

  function void set_scope(string s);

    scope = uvm_glob_to_re(s);

  endfunction

  // Function: get_scope

  //

  // Retrieve the regular expression string that identifies the set of

  // scopes over which this resource is visible.

  //

  function string get_scope();

    return scope;

  endfunction

  // Function: match_scope

  //

  // Using the regular expression facility, determine if this resource

  // is visible in a scope.  Return one if it is, zero otherwise.

  //

  function bit match_scope(string s);

    int err = uvm_re_match(scope, s);

    return (err == 0);

  endfunction

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

  // Group: Priority

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

  //

  // Functions for manipulating the search priority of resources.  The

  // function definitions here are pure virtual and are implemented in

  // derived classes.  The definitons serve as a priority management

  // interface.

  // Function: set priority

  //

  // Change the search priority of the resource based on the value of

  // the priority enum argument.

  //

  pure virtual function void set_priority (uvm_resource_types::priority_e pri);

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

  // Group: Utility Functions

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

  // function convert2string

  //

  // Create a string representation of the resource value.  By default

  // we don't know how to do this so we just return a "?".  Resource

  // specializations are expected to override this function to produce a

  // proper string representation of the resource value.

  function string convert2string();

    return "?";

  endfunction

  // Function: do_print

  //

  // Implementation of do_print which is called by print().

  function void do_print (uvm_printer printer);

    printer.print_string("",$sformatf("%s [%s] : %s", get_name(), get_scope(), convert2string()));

  endfunction

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

  // Group: Audit Trail

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

  //

  // To find out what is happening as the simulation proceeds, an audit

  // trail of each read and write is kept. The  and

  //  methods each take an accessor argument.  This is a

  // handle to the object that performed that resource access.

  //

  //|    function T read(uvm_object accessor = null);

  //|    function void write(T t, uvm_object accessor = null);

  //

  // The accessor can by anything as long as it is derived from

  // uvm_object.  The accessor object can be a component or a sequence

  // or whatever object from which a read or write was invoked.

  // Typically the ~this~ handle is used as the

  // accessor.  For example:

  //

  //|    uvm_resource#(int) rint;

  //|    int i;

  //|    ...

  //|    rint.write(7, this);

  //|    i = rint.read(this);

  //

  // The accessor's ~get_full_name()~ is stored as part of the audit trail.

  // This way you can find out what object performed each resource access.

  // Each audit record also includes the time of the access (simulation time)

  // and the particular operation performed (read or write).

  //

  // Auditing is controlled through the  class.

  // function: record_read_access

  function void record_read_access(uvm_object accessor = null);

    string str;

    uvm_resource_types::access_t access_record;

    // If an accessor object is supplied then get the accessor record.

    // Otherwise create a new access record.  In either case populate

    // the access record with information about this access.  Check

    // first to make sure that auditing is turned on.

    if(!uvm_resource_options::is_auditing())

      return;

    // If an accessor is supplied, then use its name

        // as the database entry for the accessor record.

        // Otherwise, use "" as the database entry.

    if(accessor != null)

      str = accessor.get_full_name();

    else

      str = "";

    // Create a new accessor record if one does not exist

    if(access.exists(str))

      access_record = access[str];

    else

      init_access_record(access_record);

    // Update the accessor record

    access_record.read_count++;

    access_record.read_time = $realtime;

    access[str] = access_record;

  endfunction

  // function: record_write_access

  function void record_write_access(uvm_object accessor = null);

    string str;

    // If an accessor object is supplied then get the accessor record.

    // Otherwise create a new access record.  In either case populate

    // the access record with information about this access.  Check

    // first that auditing is turned on

    if(uvm_resource_options::is_auditing()) begin

      if(accessor != null) begin

        uvm_resource_types::access_t access_record;

        string str;

        str = accessor.get_full_name();

        if(access.exists(str))

          access_record = access[str];

        else

          init_access_record(access_record);

        access_record.write_count++;

        access_record.write_time = $realtime;

        access[str] = access_record;

      end

    end

  endfunction

  // Function: print_accessors

  //

  // Dump the access records for this resource

  //

  virtual function void print_accessors();

    string str;

    uvm_component comp;

    uvm_resource_types::access_t access_record;

    string qs[$];

    if(access.num() == 0)

      return;

    foreach (access[i]) begin

      str = i;

      access_record = access[str];

      qs.push_back($sformatf("%s reads: %0d @ %0t  writes: %0d @ %0t\n",str,

               access_record.read_count,

               access_record.read_time,

               access_record.write_count,

               access_record.write_time));

    end

    `uvm_info("UVM/RESOURCE/ACCESSOR",`UVM_STRING_QUEUE_STREAMING_PACK(qs),UVM_NONE)

  endfunction

  // Function: init_access_record

  //

  // Initialize a new access record

  //

  function void init_access_record (inout uvm_resource_types::access_t access_record);

    access_record.read_time = 0;

    access_record.write_time = 0;

    access_record.read_count = 0;

    access_record.write_count = 0;

  endfunction

endclass

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

// Class - get_t

//

// Instances of get_t are stored in the history list as a record of each

// get.  Failed gets are indicated with rsrc set to ~null~.  This is part

// of the audit trail facility for resources.

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

class get_t;

  string name;

  string scope;

  uvm_resource_base rsrc;

  time t;

endclass

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

// Class: uvm_resource_pool

//

// The global (singleton) resource database.

//

// Each resource is stored both by primary name and by type handle.  The

// resource pool contains two associative arrays, one with name as the

// key and one with the type handle as the key.  Each associative array

// contains a queue of resources.  Each resource has a regular

// expression that represents the set of scopes over which it is visible.

//

//|  +------+------------+                          +------------+------+

//|  | name | rsrc queue |                          | rsrc queue | type |

//|  +------+------------+                          +------------+------+

//|  |      |            |                          |            |      |

//|  +------+------------+                  +-+-+   +------------+------+

//|  |      |            |                  | | |<--+---*        |  T   |

//|  +------+------------+   +-+-+          +-+-+   +------------+------+

//|  |  A   |        *---+-->| | |           |      |            |      |

//|  +------+------------+   +-+-+           |      +------------+------+

//|  |      |            |      |            |      |            |      |

//|  +------+------------+      +-------+  +-+      +------------+------+

//|  |      |            |              |  |        |            |      |

//|  +------+------------+              |  |        +------------+------+

//|  |      |            |              V  V        |            |      |

//|  +------+------------+            +------+      +------------+------+

//|  |      |            |            | rsrc |      |            |      |

//|  +------+------------+            +------+      +------------+------+

//

// The above diagrams illustrates how a resource whose name is A and

// type is T is stored in the pool.  The pool contains an entry in the

// type map for type T and an entry in the name map for name A.  The

// queues in each of the arrays each contain an entry for the resource A

// whose type is T.  The name map can contain in its queue other

// resources whose name is A which may or may not have the same type as

// our resource A.  Similarly, the type map can contain in its queue

// other resources whose type is T and whose name may or may not be A.

//

// Resources are added to the pool by calling ; they are retrieved

// from the pool by calling  or .  When an object

// creates a new resource and calls  the resource is made available to be

// retrieved by other objects outside of itself; an object gets a

// resource when it wants to access a resource not currently available

// in its scope.

//

// The scope is stored in the resource itself (not in the pool) so

// whether you get by name or by type the resource's visibility is

// the same.

//

// As an auditing capability, the pool contains a history of gets.  A

// record of each get, whether by  or , is stored

// in the audit record.  Both successful and failed gets are recorded. At

// the end of simulation, or any time for that matter, you can dump the

// history list.  This will tell which resources were successfully

// located and which were not.  You can use this information

// to determine if there is some error in name, type, or

// scope that has caused a resource to not be located or to be incorrectly

// located (i.e. the wrong resource is located).

//

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

class uvm_resource_pool;

  static local uvm_resource_pool rp = get();

  uvm_resource_types::rsrc_q_t rtab [string];

  uvm_resource_types::rsrc_q_t ttab [uvm_resource_base];

  get_t get_record [$];  // history of gets

  local function new();

  endfunction

  // Function: get

  //

  // Returns the singleton handle to the resource pool

  static function uvm_resource_pool get();

    if(rp == null)

      rp = new();

    return rp;

  endfunction

  // Function: spell_check

  //

  // Invokes the spell checker for a string s.  The universe of

  // correctly spelled strings -- i.e. the dictionary -- is the name

  // map.

  function bit spell_check(string s);

    return uvm_spell_chkr#(uvm_resource_types::rsrc_q_t)::check(rtab, s);

  endfunction

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

  // Group: Set

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

  // Function: set

  //

  // Add a new resource to the resource pool.  The resource is inserted

  // into both the name map and type map so it can be located by

  // either.

  //

  // An object creates a resources and ~sets~ it into the resource pool.

  // Later, other objects that want to access the resource must ~get~ it

  // from the pool

  //

  // Overrides can be specified using this interface.  Either a name

  // override, a type override or both can be specified.  If an

  // override is specified then the resource is entered at the front of

  // the queue instead of at the back.  It is not recommended that users

  // specify the override parameter directly, rather they use the

  // , , or 

  // functions.

  //

  function void set (uvm_resource_base rsrc,

                     uvm_resource_types::override_t override = 0);

    uvm_resource_types::rsrc_q_t rq;

    string name;

    uvm_resource_base type_handle;

    // If resource handle is ~null~ then there is nothing to do.

    if(rsrc == null)

      return;

    // insert into the name map.  Resources with empty names are

    // anonymous resources and are not entered into the name map

    name = rsrc.get_name();

    if(name != "") begin

      if(rtab.exists(name))

        rq = rtab[name];

      else

        rq = new();

      // Insert the resource into the queue associated with its name.

      // If we are doing a name override then insert it in the front of

      // the queue, otherwise insert it in the back.

      if(override & uvm_resource_types::NAME_OVERRIDE)

        rq.push_front(rsrc);

      else

        rq.push_back(rsrc);

      rtab[name] = rq;

    end

    // insert into the type map

    type_handle = rsrc.get_type_handle();

    if(ttab.exists(type_handle))

      rq = ttab[type_handle];

    else

      rq = new();

    // insert the resource into the queue associated with its type.  If

    // we are doing a type override then insert it in the front of the

    // queue, otherwise insert it in the back of the queue.

    if(override & uvm_resource_types::TYPE_OVERRIDE)

      rq.push_front(rsrc);

    else

      rq.push_back(rsrc);

    ttab[type_handle] = rq;

  endfunction

  // Function: set_override

  //

  // The resource provided as an argument will be entered into the pool

  // and will override both by name and type.

  function void set_override(uvm_resource_base rsrc);

    set(rsrc, (uvm_resource_types::NAME_OVERRIDE |

               uvm_resource_types::TYPE_OVERRIDE));

  endfunction

  // Function: set_name_override

  //

  // The resource provided as an argument will entered into the pool

  // using normal precedence in the type map and will override the name.

  function void set_name_override(uvm_resource_base rsrc);

    set(rsrc, uvm_resource_types::NAME_OVERRIDE);

  endfunction

  // Function: set_type_override

  //

  // The resource provided as an argument will be entered into the pool

  // using normal precedence in the name map and will override the type.

  function void set_type_override(uvm_resource_base rsrc);

    set(rsrc, uvm_resource_types::TYPE_OVERRIDE);

  endfunction

  // function - push_get_record

  //

  // Insert a new record into the get history list.

  function void push_get_record(string name, string scope,

                                  uvm_resource_base rsrc);

    get_t impt;

    // if auditing is turned off then there is no reason

    // to save a get record

    if(!uvm_resource_options::is_auditing())

      return;

    impt = new();

    impt.name  = name;

    impt.scope = scope;

    impt.rsrc  = rsrc;

    impt.t     = $realtime;

    get_record.push_back(impt);

  endfunction

  // function - dump_get_records

  //

  // Format and print the get history list.

  function void dump_get_records();

    get_t record;

    bit success;

    string qs[$];

    qs.push_back("--- resource get records ---\n");

    foreach (get_record[i]) begin

      record = get_record[i];

      success = (record.rsrc != null);

      qs.push_back($sformatf("get: name=%s  scope=%s  %s @ %0t\n",

               record.name, record.scope,

               ((success)?"success":"fail"),

               record.t));

    end

    `uvm_info("UVM/RESOURCE/GETRECORD",`UVM_STRING_QUEUE_STREAMING_PACK(qs),UVM_NONE)

  endfunction

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

  // Group: Lookup

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

  //

  // This group of functions is for finding resources in the resource database.

  //

  //  and  locate the set of resources that

  // matches the name or type (respectively) and is visible in the

  // current scope.  These functions return a queue of resources.

  //

  //  traverse a queue of resources and

  // returns the one with the highest precedence -- i.e. the one whose

  // precedence member has the highest value.

  //

  //  and  use  and 

  // (respectively) and  to find the resource with

  // the highest priority that matches the other search criteria.

  // Function: lookup_name

  //

  // Lookup resources by ~name~.  Returns a queue of resources that

  // match the ~name~, ~scope~, and ~type_handle~.  If no resources

  // match the queue is returned empty. If ~rpterr~ is set then a

  // warning is issued if no matches are found, and the spell checker is

  // invoked on ~name~.  If ~type_handle~ is ~null~ then a type check is

  // not made and resources are returned that match only ~name~ and

  // ~scope~.

  function uvm_resource_types::rsrc_q_t lookup_name(string scope = "",

                                                    string name,

                                                    uvm_resource_base type_handle = null,

                                                    bit rpterr = 1);

    uvm_resource_types::rsrc_q_t rq;

    uvm_resource_types::rsrc_q_t q;

    uvm_resource_base rsrc;

    uvm_resource_base r;

     // ensure rand stability during lookup

     begin

        process p = process::self();

        string s;

        if(p!=null) s=p.get_randstate();

        q=new();

        if(p!=null) p.set_randstate(s);

     end

    // resources with empty names are anonymous and do not exist in the name map

    if(name == "")

      return q;

    // Does an entry in the name map exist with the specified name?

    // If not, then we're done

    if(!rtab.exists(name)) begin

            if(rpterr) void'(spell_check(name));

                return q;

    end

    rsrc = null;

    rq = rtab[name];

    for(int i=0; i

      r = rq.get(i);

      // does the type and scope match?

      if(((type_handle == null) || (r.get_type_handle() == type_handle)) &&

          r.match_scope(scope))

        q.push_back(r);

    end

    return q;

  endfunction

  // Function: get_highest_precedence

  //

  // Traverse a queue, ~q~, of resources and return the one with the highest

  // precedence.  In the case where there exists more than one resource

  // with the highest precedence value, the first one that has that

  // precedence will be the one that is returned.

  function uvm_resource_base get_highest_precedence(ref uvm_resource_types::rsrc_q_t q);

    uvm_resource_base rsrc;

    uvm_resource_base r;

    int unsigned i;

    int unsigned prec;

    if(q.size() == 0)

      return null;

    // get the first resources in the queue

    rsrc = q.get(0);

    prec = rsrc.precedence;

    // start searching from the second resource

    for(int i = 1; i < q.size(); ++i) begin

      r = q.get(i);