| //---------------------------------------------------------------------- |
| // Copyright 2011 Cypress Semiconductor |
| // Copyright 2010 Mentor Graphics 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. |
| //---------------------------------------------------------------------- |
| |
| //---------------------------------------------------------------------- |
| // Title: UVM Resource Database |
| // |
| // Topic: Intro |
| // |
| // The <uvm_resource_db> class provides a convenience interface for |
| // the resources facility. In many cases basic operations such as |
| // creating and setting a resource or getting a resource could take |
| // multiple lines of code using the interfaces in <uvm_resource_base> or |
| // <uvm_resource#(T)>. The convenience layer in <uvm_resource_db> |
| // reduces many of those operations to a single line of code. |
| // |
| // If the run-time ~+UVM_RESOURCE_DB_TRACE~ command line option is |
| // specified, all resource DB accesses (read and write) are displayed. |
| //---------------------------------------------------------------------- |
| |
| typedef class uvm_resource_db_options; |
| typedef class uvm_cmdline_processor; |
| |
| //---------------------------------------------------------------------- |
| // class: uvm_resource_db |
| // |
| // All of the functions in uvm_resource_db#(T) are static, so they |
| // must be called using the :: operator. For example: |
| // |
| //| uvm_resource_db#(int)::set("A", "*", 17, this); |
| // |
| // The parameter value "int" identifies the resource type as |
| // uvm_resource#(int). Thus, the type of the object in the resource |
| // container is int. This maintains the type-safety characteristics of |
| // resource operations. |
| // |
| //---------------------------------------------------------------------- |
| class uvm_resource_db #(type T=uvm_object); |
| |
| typedef uvm_resource #(T) rsrc_t; |
| |
| protected function new(); |
| endfunction |
| |
| // function: get_by_type |
| // |
| // Get a resource by type. The type is specified in the db |
| // class parameter so the only argument to this function is the |
| // ~scope~. |
| |
| static function rsrc_t get_by_type(string scope); |
| return rsrc_t::get_by_type(scope, rsrc_t::get_type()); |
| endfunction |
| |
| // function: get_by_name |
| // |
| // Imports a resource by ~name~. The first argument is the current |
| // ~scope~ of the resource to be retrieved and the second argument is |
| // the ~name~. The ~rpterr~ flag indicates whether or not to generate |
| // a warning if no matching resource is found. |
| |
| static function rsrc_t get_by_name(string scope, |
| string name, |
| bit rpterr=1); |
| |
| return rsrc_t::get_by_name(scope, name, rpterr); |
| endfunction |
| |
| // function: set_default |
| // |
| // add a new item into the resources database. The item will not be |
| // written to so it will have its default value. The resource is |
| // created using ~name~ and ~scope~ as the lookup parameters. |
| |
| static function rsrc_t set_default(string scope, string name); |
| |
| rsrc_t r; |
| |
| r = new(name, scope); |
| r.set(); |
| return r; |
| endfunction |
| |
| // function- show_msg |
| |
| // internal helper function to print resource accesses |
| |
| protected static function void m_show_msg( |
| input string id, |
| input string rtype, |
| input string action, |
| input string scope, |
| input string name, |
| input uvm_object accessor, |
| input rsrc_t rsrc); |
| |
| T foo; |
| string msg=`uvm_typename(foo); |
| |
| $sformat(msg, "%s '%s%s' (type %s) %s by %s = %s", |
| rtype,scope, name=="" ? "" : {".",name}, msg,action, |
| (accessor != null) ? accessor.get_full_name() : "<unknown>", |
| rsrc==null?"null (failed lookup)":rsrc.convert2string()); |
| |
| `uvm_info(id, msg, UVM_LOW) |
| endfunction |
| |
| // function: set |
| // |
| // Create a new resource, write a ~val~ to it, and set it into the |
| // database using ~name~ and ~scope~ as the lookup parameters. The |
| // ~accessor~ is used for auditing. |
| static function void set(input string scope, input string name, |
| T val, input uvm_object accessor = null); |
| |
| rsrc_t rsrc = new(name, scope); |
| rsrc.write(val, accessor); |
| rsrc.set(); |
| |
| if(uvm_resource_db_options::is_tracing()) |
| m_show_msg("RSRCDB/SET", "Resource","set", scope, name, accessor, rsrc); |
| endfunction |
| |
| // function: set_anonymous |
| // |
| // Create a new resource, write a ~val~ to it, and set it into the |
| // database. The resource has no name and therefore will not be |
| // entered into the name map. But is does have a ~scope~ for lookup |
| // purposes. The ~accessor~ is used for auditing. |
| static function void set_anonymous(input string scope, |
| T val, input uvm_object accessor = null); |
| |
| rsrc_t rsrc = new("", scope); |
| rsrc.write(val, accessor); |
| rsrc.set(); |
| |
| if(uvm_resource_db_options::is_tracing()) |
| m_show_msg("RSRCDB/SETANON","Resource", "set", scope, "", accessor, rsrc); |
| endfunction |
| |
| // function set_override |
| // |
| // Create a new resource, write ~val~ to it, and set it into the |
| // database. Set it at the beginning of the queue in the type map and |
| // the name map so that it will be (currently) the highest priority |
| // resource with the specified name and type. |
| |
| static function void set_override(input string scope, input string name, |
| T val, uvm_object accessor = null); |
| rsrc_t rsrc = new(name, scope); |
| rsrc.write(val, accessor); |
| rsrc.set_override(); |
| |
| if(uvm_resource_db_options::is_tracing()) |
| m_show_msg("RSRCDB/SETOVRD", "Resource","set", scope, name, accessor, rsrc); |
| endfunction |
| |
| |
| |
| // function set_override_type |
| // |
| // Create a new resource, write ~val~ to it, and set it into the |
| // database. Set it at the beginning of the queue in the type map so |
| // that it will be (currently) the highest priority resource with the |
| // specified type. It will be normal priority (i.e. at the end of the |
| // queue) in the name map. |
| |
| static function void set_override_type(input string scope, input string name, |
| T val, uvm_object accessor = null); |
| rsrc_t rsrc = new(name, scope); |
| rsrc.write(val, accessor); |
| rsrc.set_override(uvm_resource_types::TYPE_OVERRIDE); |
| |
| if(uvm_resource_db_options::is_tracing()) |
| m_show_msg("RSRCDB/SETOVRDTYP","Resource", "set", scope, name, accessor, rsrc); |
| endfunction |
| |
| // function set_override_name |
| // |
| // Create a new resource, write ~val~ to it, and set it into the |
| // database. Set it at the beginning of the queue in the name map so |
| // that it will be (currently) the highest priority resource with the |
| // specified name. It will be normal priority (i.e. at the end of the |
| // queue) in the type map. |
| |
| static function void set_override_name(input string scope, input string name, |
| T val, uvm_object accessor = null); |
| rsrc_t rsrc = new(name, scope); |
| rsrc.write(val, accessor); |
| rsrc.set_override(uvm_resource_types::NAME_OVERRIDE); |
| |
| if(uvm_resource_db_options::is_tracing()) |
| m_show_msg("RSRCDB/SETOVRDNAM","Resource", "set", scope, name, accessor, rsrc); |
| endfunction |
| |
| // function: read_by_name |
| // |
| // locate a resource by ~name~ and ~scope~ and read its value. The value |
| // is returned through the output argument ~val~. The return value is a bit |
| // that indicates whether or not the read was successful. The ~accessor~ |
| // is used for auditing. |
| static function bit read_by_name(input string scope, |
| input string name, |
| inout T val, input uvm_object accessor = null); |
| |
| rsrc_t rsrc = get_by_name(scope, name); |
| |
| if(uvm_resource_db_options::is_tracing()) |
| m_show_msg("RSRCDB/RDBYNAM","Resource", "read", scope, name, accessor, rsrc); |
| |
| if(rsrc == null) |
| return 0; |
| |
| val = rsrc.read(accessor); |
| |
| return 1; |
| |
| endfunction |
| |
| // function: read_by_type |
| // |
| // Read a value by type. The value is returned through the output |
| // argument ~val~. The ~scope~ is used for the lookup. The return |
| // value is a bit that indicates whether or not the read is successful. |
| // The ~accessor~ is used for auditing. |
| static function bit read_by_type(input string scope, |
| inout T val, |
| input uvm_object accessor = null); |
| |
| rsrc_t rsrc = get_by_type(scope); |
| |
| if(uvm_resource_db_options::is_tracing()) |
| m_show_msg("RSRCDB/RDBYTYP", "Resource","read", scope, "", accessor, rsrc); |
| |
| if(rsrc == null) |
| return 0; |
| |
| val = rsrc.read(accessor); |
| |
| return 1; |
| |
| endfunction |
| |
| // function: write_by_name |
| // |
| // write a ~val~ into the resources database. First, look up the |
| // resource by ~name~ and ~scope~. If it is not located then add a new |
| // resource to the database and then write its value. |
| // |
| // Because the ~scope~ is matched to a resource which may be a |
| // regular expression, and consequently may target other scopes beyond |
| // the ~scope~ argument. Care must be taken with this function. If |
| // a <get_by_name> match is found for ~name~ and ~scope~ then ~val~ |
| // will be written to that matching resource and thus may impact |
| // other scopes which also match the resource. |
| static function bit write_by_name(input string scope, input string name, |
| input T val, input uvm_object accessor = null); |
| |
| rsrc_t rsrc = get_by_name(scope, name); |
| |
| if(uvm_resource_db_options::is_tracing()) |
| m_show_msg("RSRCDB/WR","Resource", "written", scope, name, accessor, rsrc); |
| |
| if(rsrc == null) |
| return 0; |
| |
| rsrc.write(val, accessor); |
| |
| return 1; |
| |
| endfunction |
| |
| // function: write_by_type |
| // |
| // write a ~val~ into the resources database. First, look up the |
| // resource by type. If it is not located then add a new resource to |
| // the database and then write its value. |
| // |
| // Because the ~scope~ is matched to a resource which may be a |
| // regular expression, and consequently may target other scopes beyond |
| // the ~scope~ argument. Care must be taken with this function. If |
| // a <get_by_name> match is found for ~name~ and ~scope~ then ~val~ |
| // will be written to that matching resource and thus may impact |
| // other scopes which also match the resource. |
| static function bit write_by_type(input string scope, |
| input T val, input uvm_object accessor = null); |
| |
| rsrc_t rsrc = get_by_type(scope); |
| |
| if(uvm_resource_db_options::is_tracing()) |
| m_show_msg("RSRCDB/WRTYP", "Resource","written", scope, "", accessor, rsrc); |
| |
| if(rsrc == null) |
| return 0; |
| |
| rsrc.write(val, accessor); |
| |
| return 1; |
| endfunction |
| |
| // function: dump |
| // |
| // Dump all the resources in the resource pool. This is useful for |
| // debugging purposes. This function does not use the parameter T, so |
| // it will dump the same thing -- the entire database -- no matter the |
| // value of the parameter. |
| |
| static function void dump(); |
| uvm_resource_pool rp = uvm_resource_pool::get(); |
| rp.dump(); |
| endfunction |
| |
| endclass |
| |
| |
| //---------------------------------------------------------------------- |
| // Class: uvm_resource_db_options |
| // |
| // Provides a namespace for managing options for the |
| // resources DB 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 DB facility. |
| |
| // Options include: |
| // |
| // * tracing: on/off |
| // |
| // The default for tracing is off. |
| // |
| //---------------------------------------------------------------------- |
| class uvm_resource_db_options; |
| |
| static local bit ready; |
| static local bit tracing; |
| |
| // Function: turn_on_tracing |
| // |
| // Turn tracing on for the resource database. This causes all |
| // reads and writes to the database to display information about |
| // the accesses. Tracing is off by default. |
| // |
| // This method is implicitly called by the ~+UVM_RESOURCE_DB_TRACE~. |
| |
| static function void turn_on_tracing(); |
| if (!ready) init(); |
| tracing = 1; |
| endfunction |
| |
| // Function: turn_off_tracing |
| // |
| // Turn tracing off for the resource database. |
| |
| static function void turn_off_tracing(); |
| if (!ready) init(); |
| tracing = 0; |
| endfunction |
| |
| // Function: is_tracing |
| // |
| // Returns 1 if the tracing facility is on and 0 if it is off. |
| |
| static function bit is_tracing(); |
| if (!ready) init(); |
| return tracing; |
| endfunction |
| |
| |
| static local function void init(); |
| uvm_cmdline_processor clp; |
| string trace_args[$]; |
| |
| clp = uvm_cmdline_processor::get_inst(); |
| |
| if (clp.get_arg_matches("+UVM_RESOURCE_DB_TRACE", trace_args)) begin |
| tracing = 1; |
| end |
| |
| ready = 1; |
| endfunction |
| |
| endclass |