| // $Id: //dvt/vtech/dev/main/ovm/src/base/ovm_component.sv#85 $ |
| //------------------------------------------------------------------------------ |
| // Copyright 2007-2009 Mentor Graphics Corporation |
| // Copyright 2007-2009 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. |
| //------------------------------------------------------------------------------ |
| |
| `include "base/ovm_component.svh" |
| `include "base/ovm_root.svh" |
| |
| ovm_component ovm_top_levels[$]; // don't use |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS- ovm_component |
| // |
| //------------------------------------------------------------------------------ |
| |
| // new |
| // --- |
| |
| function ovm_component::new (string name, ovm_component parent); |
| string error_str; |
| |
| super.new(name); |
| |
| // If ovm_top, reset name to "" so it doesn't show in full paths then return |
| if (parent==null && name == "__top__") begin |
| set_name(""); |
| return; |
| end |
| |
| // Check that we're not in or past end_of_elaboration |
| if (end_of_elaboration_ph.is_in_progress() || |
| end_of_elaboration_ph.is_done() ) begin |
| ovm_phase curr_phase; |
| curr_phase = ovm_top.get_current_phase(); |
| ovm_report_fatal("ILLCRT", {"It is illegal to create a component once", |
| " phasing reaches end_of_elaboration. The current phase is ", |
| curr_phase.get_name()}, OVM_NONE); |
| end |
| |
| if (name == "") begin |
| name.itoa(m_inst_count); |
| name = {"COMP_", name}; |
| end |
| |
| if(parent == this) begin |
| ovm_report_fatal("THISPARENT", "cannot set the parent of a component to itself", OVM_NONE); |
| end |
| |
| if (parent == null) |
| parent = ovm_top; |
| |
| if(ovm_report_enabled(OVM_MEDIUM+1, OVM_INFO, "NEWCOMP")) |
| ovm_report_info("NEWCOMP",$psprintf("this=%0s, parent=%0s, name=%s", |
| this.get_full_name(),parent.get_full_name(),name),OVM_MEDIUM+1); |
| |
| if (parent.has_child(name) && this != parent.get_child(name)) begin |
| if (parent == ovm_top) begin |
| error_str = {"Name '",name,"' is not unique to other top-level ", |
| "instances. If parent is a module, build a unique name by combining the ", |
| "the module name and component name: $psprintf(\"\%m.\%s\",\"",name,"\")."}; |
| ovm_report_fatal("CLDEXT",error_str, OVM_NONE); |
| end |
| else |
| ovm_report_fatal("CLDEXT", |
| $psprintf("Cannot set '%s' as a child of '%s', %s", |
| name, parent.get_full_name(), |
| "which already has a child by that name."), OVM_NONE); |
| return; |
| end |
| |
| m_parent = parent; |
| |
| set_name(name); |
| |
| if (!m_parent.m_add_child(this)) |
| m_parent = null; |
| |
| event_pool = new("event_pool"); |
| |
| |
| // Now that inst name is established, reseed (if use_ovm_seeding is set) |
| reseed(); |
| |
| // Do local configuration settings (URM backward compatibility) |
| void'(get_config_int("recording_detail", recording_detail)); |
| |
| // Deprecated container of top-levels (replaced by ovm_top) |
| if (parent == ovm_top) |
| ovm_top_levels.push_back(this); |
| |
| set_report_verbosity_level(ovm_top.get_report_verbosity_level()); |
| |
| set_report_id_action("CFGOVR", OVM_NO_ACTION); |
| set_report_id_action("CFGSET", OVM_NO_ACTION); |
| |
| //Not sure what ovm_top isn't taking the setting... these two lines should be removed. |
| ovm_top.set_report_id_action("CFGOVR", OVM_NO_ACTION); |
| ovm_top.set_report_id_action("CFGSET", OVM_NO_ACTION); |
| endfunction |
| |
| |
| // m_add_child |
| // ----------- |
| |
| function bit ovm_component::m_add_child(ovm_component child); |
| |
| if (m_children.exists(child.get_name()) && |
| m_children[child.get_name()] != child) begin |
| ovm_report_warning("BDCLD", |
| $psprintf("A child with the name '%0s' (type=%0s) already exists.", |
| child.get_name(), m_children[child.get_name()].get_type_name()), OVM_NONE); |
| return 0; |
| end |
| |
| if (m_children_by_handle.exists(child)) begin |
| ovm_report_warning("BDCHLD", |
| $psprintf("A child with the name '%0s' %0s %0s'", |
| child.get_name(), |
| "already exists in parent under name '", |
| m_children_by_handle[child].get_name()), OVM_NONE); |
| return 0; |
| end |
| |
| m_children[child.get_name()] = child; |
| m_children_by_handle[child] = child; |
| return 1; |
| endfunction |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Hierarchy Methods |
| // |
| //------------------------------------------------------------------------------ |
| |
| |
| // get_first_child |
| // --------------- |
| |
| function int ovm_component::get_first_child(ref string name); |
| return m_children.first(name); |
| endfunction |
| |
| |
| // get_next_child |
| // -------------- |
| |
| function int ovm_component::get_next_child(ref string name); |
| return m_children.next(name); |
| endfunction |
| |
| |
| // get_child |
| // --------- |
| |
| function ovm_component ovm_component::get_child(string name); |
| if (m_children.exists(name)) |
| return m_children[name]; |
| ovm_report_warning("NOCHILD",{"Component with name '",name, |
| "' is not a child of component '",get_full_name(),"'"}, OVM_NONE); |
| return null; |
| endfunction |
| |
| |
| // has_child |
| // --------- |
| |
| function int ovm_component::has_child(string name); |
| return m_children.exists(name); |
| endfunction |
| |
| |
| // get_num_children |
| // ---------------- |
| |
| function int ovm_component::get_num_children(); |
| return m_children.num(); |
| endfunction |
| |
| |
| // get_full_name |
| // ------------- |
| |
| function string ovm_component::get_full_name (); |
| // Note- Implementation choice to construct full name once since the |
| // full name may be used often for lookups. |
| if(m_name == "") |
| return get_name(); |
| else |
| return m_name; |
| endfunction |
| |
| |
| // get_parent |
| // ---------- |
| |
| function ovm_component ovm_component::get_parent (); |
| return m_parent; |
| endfunction |
| |
| |
| // set_name |
| // -------- |
| |
| function void ovm_component::set_name (string name); |
| |
| super.set_name(name); |
| m_set_full_name(); |
| |
| endfunction |
| |
| |
| |
| // m_set_full_name |
| // --------------- |
| |
| function void ovm_component::m_set_full_name(); |
| if (m_parent == ovm_top || m_parent==null) |
| m_name = get_name(); |
| else |
| m_name = {m_parent.get_full_name(), ".", get_name()}; |
| |
| foreach (m_children[c]) begin |
| ovm_component tmp; |
| tmp = m_children[c]; |
| tmp.m_set_full_name(); |
| end |
| |
| endfunction |
| |
| |
| // lookup |
| // ------ |
| |
| function ovm_component ovm_component::lookup( string name ); |
| |
| string leaf , remainder; |
| ovm_component comp; |
| |
| comp = this; |
| |
| m_extract_name(name, leaf, remainder); |
| |
| if (leaf == "") begin |
| comp = ovm_top; // absolute lookup |
| m_extract_name(remainder, leaf, remainder); |
| end |
| |
| if (!comp.has_child(leaf)) begin |
| ovm_report_warning("Lookup Error", |
| $psprintf("Cannot find child %0s",leaf), OVM_NONE); |
| return null; |
| end |
| |
| if( remainder != "" ) |
| return comp.m_children[leaf].lookup(remainder); |
| |
| return comp.m_children[leaf]; |
| |
| endfunction |
| |
| |
| // m_extract_name |
| // -------------- |
| |
| function void ovm_component::m_extract_name(input string name , |
| output string leaf , |
| output string remainder ); |
| int i , len; |
| string extract_str; |
| len = name.len(); |
| |
| for( i = 0; i < name.len(); i++ ) begin |
| if( name[i] == "." ) begin |
| break; |
| end |
| end |
| |
| if( i == len ) begin |
| leaf = name; |
| remainder = ""; |
| return; |
| end |
| |
| leaf = name.substr( 0 , i - 1 ); |
| remainder = name.substr( i + 1 , len - 1 ); |
| |
| return; |
| endfunction |
| |
| |
| // flush |
| // ----- |
| |
| function void ovm_component::flush(); |
| return; |
| endfunction |
| |
| |
| // do_flush (flush_hier?) |
| // -------- |
| |
| function void ovm_component::do_flush(); |
| foreach( m_children[s] ) |
| m_children[s].do_flush(); |
| flush(); |
| endfunction |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Factory Methods |
| // |
| //------------------------------------------------------------------------------ |
| |
| // create |
| // ------ |
| |
| function ovm_object ovm_component::create (string name =""); |
| ovm_report_error("ILLCRT", |
| "create cannot be called on a ovm_component. Use create_component instead.", OVM_NONE); |
| return null; |
| endfunction |
| |
| |
| // clone |
| // ------ |
| |
| function ovm_object ovm_component::clone (); |
| ovm_report_error("ILLCLN","clone cannot be called on a ovm_component. ", OVM_NONE); |
| return null; |
| endfunction |
| |
| |
| // print_override_info |
| // ------------------- |
| |
| function void ovm_component::print_override_info (string requested_type_name, |
| string name=""); |
| factory.debug_create_by_name(requested_type_name, get_full_name(), name); |
| endfunction |
| |
| |
| // create_component |
| // ---------------- |
| |
| function ovm_component ovm_component::create_component (string requested_type_name, |
| string name); |
| return factory.create_component_by_name(requested_type_name, get_full_name(), |
| name, this); |
| endfunction |
| |
| |
| // create_object |
| // ------------- |
| |
| function ovm_object ovm_component::create_object (string requested_type_name, |
| string name=""); |
| return factory.create_object_by_name(requested_type_name, |
| get_full_name(), name); |
| endfunction |
| |
| |
| // set_type_override (static) |
| // ----------------- |
| |
| function void ovm_component::set_type_override (string original_type_name, |
| string override_type_name, |
| bit replace=1); |
| factory.set_type_override_by_name(original_type_name, |
| override_type_name, replace); |
| endfunction |
| |
| |
| // set_type_override_by_type (static) |
| // ------------------------- |
| |
| function void ovm_component::set_type_override_by_type (ovm_object_wrapper original_type, |
| ovm_object_wrapper override_type, |
| bit replace=1); |
| factory.set_type_override_by_type(original_type, override_type, replace); |
| endfunction |
| |
| |
| // set_inst_override |
| // ----------------- |
| |
| function void ovm_component::set_inst_override (string relative_inst_path, |
| string original_type_name, |
| string override_type_name); |
| string full_inst_path; |
| |
| if (relative_inst_path == "") |
| full_inst_path = get_full_name(); |
| else |
| full_inst_path = {get_full_name(), ".", relative_inst_path}; |
| |
| factory.set_inst_override_by_name( |
| original_type_name, |
| override_type_name, |
| full_inst_path); |
| endfunction |
| |
| |
| // set_inst_override_by_type |
| // ------------------------- |
| |
| function void ovm_component::set_inst_override_by_type (string relative_inst_path, |
| ovm_object_wrapper original_type, |
| ovm_object_wrapper override_type); |
| string full_inst_path; |
| |
| if (relative_inst_path == "") |
| full_inst_path = get_full_name(); |
| else |
| full_inst_path = {get_full_name(), ".", relative_inst_path}; |
| |
| factory.set_inst_override_by_type(original_type, override_type, full_inst_path); |
| |
| endfunction |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Hierarchical report configuration interface |
| // |
| //------------------------------------------------------------------------------ |
| |
| // set_report_severity_action_hier |
| // ------------------------------- |
| |
| function void ovm_component::set_report_severity_action_hier( ovm_severity severity, |
| ovm_action action); |
| set_report_severity_action(severity, action); |
| foreach( m_children[c] ) |
| m_children[c].set_report_severity_action_hier(severity, action); |
| endfunction |
| |
| |
| // set_report_id_action_hier |
| // ------------------------- |
| |
| function void ovm_component::set_report_id_action_hier( string id, ovm_action action); |
| set_report_id_action(id, action); |
| foreach( m_children[c] ) |
| m_children[c].set_report_id_action_hier(id, action); |
| endfunction |
| |
| |
| // set_report_severity_id_action_hier |
| // ---------------------------------- |
| |
| function void ovm_component::set_report_severity_id_action_hier( ovm_severity severity, |
| string id, |
| ovm_action action); |
| set_report_severity_id_action(severity, id, action); |
| foreach( m_children[c] ) |
| m_children[c].set_report_severity_id_action_hier(severity, id, action); |
| endfunction |
| |
| |
| // set_report_severity_file_hier |
| // ----------------------------- |
| |
| function void ovm_component::set_report_severity_file_hier( ovm_severity severity, |
| OVM_FILE file); |
| set_report_severity_file(severity, file); |
| foreach( m_children[c] ) |
| m_children[c].set_report_severity_file_hier(severity, file); |
| endfunction |
| |
| |
| // set_report_default_file_hier |
| // ---------------------------- |
| |
| function void ovm_component::set_report_default_file_hier( OVM_FILE file); |
| set_report_default_file(file); |
| foreach( m_children[c] ) |
| m_children[c].set_report_default_file_hier(file); |
| endfunction |
| |
| |
| // set_report_id_file_hier |
| // ----------------------- |
| |
| function void ovm_component::set_report_id_file_hier( string id, OVM_FILE file); |
| set_report_id_file(id, file); |
| foreach( m_children[c] ) |
| m_children[c].set_report_id_file_hier(id, file); |
| endfunction |
| |
| |
| // set_report_severity_id_file_hier |
| // -------------------------------- |
| |
| function void ovm_component::set_report_severity_id_file_hier ( ovm_severity severity, |
| string id, |
| OVM_FILE file); |
| set_report_severity_id_file(severity, id, file); |
| foreach( m_children[c] ) |
| m_children[c].set_report_severity_id_file_hier(severity, id, file); |
| endfunction |
| |
| |
| // set_report_verbosity_level_hier |
| // ------------------------------- |
| |
| function void ovm_component::set_report_verbosity_level_hier(int verbosity); |
| set_report_verbosity_level(verbosity); |
| foreach( m_children[c] ) |
| m_children[c].set_report_verbosity_level_hier(verbosity); |
| endfunction |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Phase interface |
| // |
| //------------------------------------------------------------------------------ |
| |
| |
| // do_func_phase |
| // ------------- |
| |
| function void ovm_component::do_func_phase (ovm_phase phase); |
| // If in build_ph, don't build if already done |
| m_curr_phase = phase; |
| if (!(phase == build_ph && m_build_done)) |
| phase.call_func(this); |
| endfunction |
| |
| |
| // do_task_phase |
| // ------------- |
| |
| task ovm_component::do_task_phase (ovm_phase phase); |
| |
| m_curr_phase = phase; |
| `ifndef INCA |
| |
| //fork |
| //begin |
| m_phase_process = process::self(); |
| phase.call_task(this); |
| @m_kill_request; |
| //end |
| //join |
| |
| `else |
| // don't use fine grained process control |
| fork begin // isolate inner fork so can safely kill via disable fork |
| fork : task_phase |
| // process 1 - call task; if returns, keep alive until kill request |
| begin |
| phase.call_task(this); |
| @m_kill_request; |
| end |
| // process 2 - any kill request will preempt process 1 |
| @m_kill_request; |
| join_any |
| disable fork; |
| end |
| join |
| `endif |
| |
| endtask |
| |
| |
| // do_kill_all |
| // ----------- |
| |
| function void ovm_component::do_kill_all(); |
| foreach(m_children[c]) |
| m_children[c].do_kill_all(); |
| kill(); |
| endfunction |
| |
| |
| |
| // kill |
| // ---- |
| |
| function void ovm_component::kill(); |
| `ifndef INCA |
| if (m_phase_process != null) begin |
| m_phase_process.kill; |
| m_phase_process = null; |
| end |
| `else |
| ->m_kill_request; |
| `endif |
| endfunction |
| |
| |
| // suspend |
| // ------- |
| |
| task ovm_component::suspend(); |
| `ifndef INCA |
| if(m_phase_process != null) |
| m_phase_process.suspend; |
| `else |
| ovm_report_error("UNIMP", "suspend not implemented", OVM_NONE); |
| `endif |
| endtask |
| |
| |
| // resume |
| // ------ |
| |
| task ovm_component::resume(); |
| `ifndef INCA |
| if(m_phase_process!=null) |
| m_phase_process.resume; |
| `else |
| ovm_report_error("UNIMP", "resume not implemented", OVM_NONE); |
| `endif |
| endtask |
| |
| |
| // restart |
| // ------- |
| |
| task ovm_component::restart(); |
| ovm_report_warning("UNIMP", |
| $psprintf("%0s: restart not implemented",this.get_name()), OVM_NONE); |
| endtask |
| |
| |
| // status |
| //------- |
| |
| function string ovm_component::status(); |
| |
| `ifndef INCA |
| process::state ps; |
| |
| if(m_phase_process == null) |
| return "<unknown>"; |
| |
| ps = m_phase_process.status(); |
| |
| return ps.name(); |
| `else |
| ovm_report_error("UNIMP", "status not implemented", OVM_NONE); |
| `endif |
| |
| endfunction |
| |
| |
| // build |
| // ----- |
| |
| function void ovm_component::build(); |
| m_build_done = 1; |
| apply_config_settings(print_config_matches); |
| endfunction |
| |
| |
| // connect |
| // ------- |
| |
| function void ovm_component::connect(); |
| return; |
| endfunction |
| |
| |
| // start_of_simulation |
| // ------------------- |
| |
| function void ovm_component::start_of_simulation(); |
| return; |
| endfunction |
| |
| |
| // end_of_elaboration |
| // ------------------ |
| |
| function void ovm_component::end_of_elaboration(); |
| return; |
| endfunction |
| |
| |
| // run |
| // --- |
| |
| task ovm_component::run(); |
| return; |
| endtask |
| |
| |
| // extract |
| // ------- |
| |
| function void ovm_component::extract(); |
| return; |
| endfunction |
| |
| |
| // check |
| // ----- |
| |
| function void ovm_component::check(); |
| return; |
| endfunction |
| |
| |
| // report |
| // ------ |
| |
| function void ovm_component::report(); |
| return; |
| endfunction |
| |
| |
| // stop |
| // ---- |
| |
| task ovm_component::stop(string ph_name); |
| return; |
| endtask |
| |
| |
| // resolve_bindings |
| // ---------------- |
| |
| function void ovm_component::resolve_bindings(); |
| return; |
| endfunction |
| |
| |
| // do_resolve_bindings |
| // ------------------- |
| |
| function void ovm_component::do_resolve_bindings(); |
| foreach( m_children[s] ) |
| m_children[s].do_resolve_bindings(); |
| resolve_bindings(); |
| endfunction |
| |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Recording interface |
| // |
| //------------------------------------------------------------------------------ |
| |
| // accept_tr |
| // --------- |
| |
| function void ovm_component::accept_tr (ovm_transaction tr, |
| time accept_time=0); |
| ovm_event e; |
| tr.accept_tr(accept_time); |
| do_accept_tr(tr); |
| e = event_pool.get("accept_tr"); |
| if(e!=null) |
| e.trigger(); |
| endfunction |
| |
| // begin_tr |
| // -------- |
| |
| function integer ovm_component::begin_tr (ovm_transaction tr, |
| string stream_name ="main", |
| string label="", |
| string desc="", |
| time begin_time=0); |
| return m_begin_tr(tr, 0, 0, stream_name, label, desc, begin_time); |
| endfunction |
| |
| // begin_child_tr |
| // -------------- |
| |
| function integer ovm_component::begin_child_tr (ovm_transaction tr, |
| integer parent_handle=0, |
| string stream_name="main", |
| string label="", |
| string desc="", |
| time begin_time=0); |
| return m_begin_tr(tr, parent_handle, 1, stream_name, label, desc, begin_time); |
| endfunction |
| |
| // m_begin_tr |
| // ---------- |
| |
| function integer ovm_component::m_begin_tr (ovm_transaction tr, |
| integer parent_handle=0, |
| bit has_parent=0, |
| string stream_name="main", |
| string label="", |
| string desc="", |
| time begin_time=0); |
| ovm_event e; |
| integer stream_h; |
| integer tr_h; |
| integer link_tr_h; |
| string name; |
| |
| tr_h = 0; |
| if(has_parent) |
| link_tr_h = tr.begin_child_tr(begin_time, parent_handle); |
| else |
| link_tr_h = tr.begin_tr(begin_time); |
| |
| if (tr.get_name() != "") |
| name = tr.get_name(); |
| else |
| name = tr.get_type_name(); |
| |
| if(stream_name == "") stream_name="main"; |
| |
| if (ovm_verbosity'(recording_detail) != OVM_NONE) begin |
| |
| if(m_stream_handle.exists(stream_name)) |
| stream_h = m_stream_handle[stream_name]; |
| |
| if (ovm_check_handle_kind("Fiber", stream_h) != 1) |
| begin |
| stream_h = ovm_create_fiber(stream_name, "TVM", get_full_name()); |
| m_stream_handle[stream_name] = stream_h; |
| end |
| |
| if(has_parent == 0) |
| tr_h = ovm_begin_transaction("Begin_No_Parent, Link", |
| stream_h, |
| name, |
| label, |
| desc, |
| begin_time); |
| else begin |
| tr_h = ovm_begin_transaction("Begin_End, Link", |
| stream_h, |
| name, |
| label, |
| desc, |
| begin_time); |
| if(parent_handle!=0) |
| ovm_link_transaction(parent_handle, tr_h, "child"); |
| end |
| |
| m_tr_h[tr] = tr_h; |
| |
| if (ovm_check_handle_kind("Transaction", link_tr_h) == 1) |
| ovm_link_transaction(tr_h,link_tr_h); |
| |
| do_begin_tr(tr,stream_name,tr_h); |
| |
| end |
| |
| e = event_pool.get("begin_tr"); |
| if (e!=null) |
| e.trigger(tr); |
| |
| return tr_h; |
| |
| endfunction |
| |
| |
| // end_tr |
| // ------ |
| |
| function void ovm_component::end_tr (ovm_transaction tr, |
| time end_time=0, |
| bit free_handle=1); |
| ovm_event e; |
| integer tr_h; |
| tr_h = 0; |
| |
| tr.end_tr(end_time,free_handle); |
| |
| if (ovm_verbosity'(recording_detail) != OVM_NONE) begin |
| |
| if (m_tr_h.exists(tr)) begin |
| |
| tr_h = m_tr_h[tr]; |
| |
| do_end_tr(tr, tr_h); // callback |
| |
| m_tr_h.delete(tr); |
| |
| if (ovm_check_handle_kind("Transaction", tr_h) == 1) begin |
| |
| ovm_default_recorder.tr_handle = tr_h; |
| tr.record(ovm_default_recorder); |
| |
| ovm_end_transaction(tr_h,end_time); |
| |
| if (free_handle) |
| ovm_free_transaction_handle(tr_h); |
| |
| end |
| end |
| else begin |
| do_end_tr(tr, tr_h); // callback |
| end |
| |
| end |
| |
| e = event_pool.get("end_tr"); |
| if(e!=null) |
| e.trigger(); |
| |
| endfunction |
| |
| // record_error_tr |
| // --------------- |
| |
| function integer ovm_component::record_error_tr (string stream_name="main", |
| ovm_object info=null, |
| string label="error_tr", |
| string desc="", |
| time error_time=0, |
| bit keep_active=0); |
| string etype; |
| integer stream_h; |
| |
| if(keep_active) etype = "Error, Link"; |
| else etype = "Error"; |
| |
| if(error_time == 0) error_time = $time; |
| |
| stream_h = m_stream_handle[stream_name]; |
| if (ovm_check_handle_kind("Fiber", stream_h) != 1) begin |
| stream_h = ovm_create_fiber(stream_name, "TVM", get_full_name()); |
| m_stream_handle[stream_name] = stream_h; |
| end |
| |
| record_error_tr = ovm_begin_transaction(etype, stream_h, label, |
| label, desc, error_time); |
| if(info!=null) begin |
| ovm_default_recorder.tr_handle = record_error_tr; |
| info.record(ovm_default_recorder); |
| end |
| |
| ovm_end_transaction(record_error_tr,error_time); |
| endfunction |
| |
| |
| // record_event_tr |
| // --------------- |
| |
| function integer ovm_component::record_event_tr (string stream_name="main", |
| ovm_object info=null, |
| string label="event_tr", |
| string desc="", |
| time event_time=0, |
| bit keep_active=0); |
| string etype; |
| integer stream_h; |
| |
| if(keep_active) etype = "Event, Link"; |
| else etype = "Event"; |
| |
| if(event_time == 0) event_time = $time; |
| |
| stream_h = m_stream_handle[stream_name]; |
| if (ovm_check_handle_kind("Fiber", stream_h) != 1) begin |
| stream_h = ovm_create_fiber(stream_name, "TVM", get_full_name()); |
| m_stream_handle[stream_name] = stream_h; |
| end |
| |
| record_event_tr = ovm_begin_transaction(etype, stream_h, label, |
| label, desc, event_time); |
| if(info!=null) begin |
| ovm_default_recorder.tr_handle = record_event_tr; |
| info.record(ovm_default_recorder); |
| end |
| |
| ovm_end_transaction(record_event_tr,event_time); |
| endfunction |
| |
| // do_accept_tr |
| // ------------ |
| |
| function void ovm_component::do_accept_tr (ovm_transaction tr); |
| return; |
| endfunction |
| |
| |
| // do_begin_tr |
| // ----------- |
| |
| function void ovm_component::do_begin_tr (ovm_transaction tr, |
| string stream_name, |
| integer tr_handle); |
| return; |
| endfunction |
| |
| |
| // do_end_tr |
| // --------- |
| |
| function void ovm_component::do_end_tr (ovm_transaction tr, |
| integer tr_handle); |
| return; |
| endfunction |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Configuration interface |
| // |
| //------------------------------------------------------------------------------ |
| |
| |
| // set_config_int |
| // -------------- |
| |
| function void ovm_component::set_config_int (string inst_name, |
| string field_name, |
| ovm_bitstream_t value); |
| ovm_int_config_setting cfg; |
| cfg = new(inst_name, field_name, value, this); |
| m_config_set = 1; |
| m_configuration_table.push_front(cfg); |
| endfunction |
| |
| |
| // set_config_string |
| // ----------------- |
| |
| function void ovm_component::set_config_string (string inst_name, |
| string field_name, |
| string value); |
| ovm_string_config_setting cfg; |
| cfg = new(inst_name, field_name, value, this); |
| m_config_set = 1; |
| m_configuration_table.push_front(cfg); |
| endfunction |
| |
| |
| // set_config_object |
| // ----------------- |
| |
| function void ovm_component::set_config_object (string inst_name, |
| string field_name, |
| ovm_object value, |
| bit clone=1); |
| ovm_object_config_setting cfg; |
| if(clone && (value != null)) begin |
| ovm_object tmp; |
| tmp = value.clone(); |
| |
| // If create not implemented, or clone is attempted on objects that |
| // do not t allow cloning (e.g. components) clone will return null. |
| if(tmp == null) begin |
| ovm_component comp; |
| if ($cast(comp,value)) begin |
| ovm_report_error("INVCLNC", {"Clone failed during set_config_object ", |
| "with an object that is an ovm_component. Components cannot be cloned."}, OVM_NONE); |
| return; |
| end |
| else begin |
| ovm_report_warning("INVCLN", {"Clone failed during set_config_object, ", |
| "the original reference will be used for configuration. Check that ", |
| "the create method for the object type is defined properly."}, OVM_NONE); |
| end |
| end |
| else |
| value = tmp; |
| end |
| |
| cfg = new(inst_name, field_name, value, this, clone); |
| m_config_set = 1; |
| m_configuration_table.push_front(cfg); |
| |
| endfunction |
| |
| |
| // m_component_path |
| // ---------------- |
| |
| function void ovm_component::m_component_path(ref ovm_component path[$]); |
| ovm_component comp; |
| comp = this; |
| `ifdef INCA |
| path.delete(); |
| `else |
| path = '{}; |
| `endif |
| while(comp != null) begin |
| path.push_front(comp); |
| comp = comp.get_parent(); |
| end |
| endfunction |
| |
| |
| // m_get_config_matches |
| // -------------------- |
| |
| function void ovm_component::m_get_config_matches( |
| ref ovm_config_setting cfg_matches[$], |
| input ovm_config_setting::ovm_config_type cfgtype, string field_name); |
| ovm_component comp; |
| static ovm_component stack[$]; |
| static ovm_config_setting comp_matches[$]; |
| |
| comp = this; |
| |
| `ifdef INCA |
| cfg_matches.delete(); |
| `else |
| cfg_matches = '{}; |
| `endif |
| |
| |
| //Get the path up to the root. Since configs are done in groups for a comp, |
| //cache the set of config matches from the last check to reduce searching. |
| if((stack.size() == 0) || (stack[stack.size()-1] != this) || (m_config_set == 1)) begin |
| m_config_set = 0; |
| m_component_path(stack); |
| `ovm_clear_queue(comp_matches); |
| foreach(stack[i]) begin |
| for(int j=0; j<stack[i].m_configuration_table.size(); ++j) begin |
| if(stack[i].m_configuration_table[j].component_match(this)) |
| comp_matches.push_back(stack[i].m_configuration_table[j]); |
| end |
| end |
| end |
| |
| foreach(comp_matches[i]) begin |
| if(comp_matches[i].field_match(field_name) && |
| ((comp_matches[i].get_value_type() == cfgtype) || |
| (cfgtype == ovm_config_setting::OVM_UNDEFINED_TYPE))) |
| begin |
| cfg_matches.push_back(comp_matches[i]); |
| end |
| end |
| |
| endfunction |
| |
| |
| // check_config_usage |
| // ------------------ |
| |
| function void ovm_component::check_config_usage ( bit recurse=1 ); |
| ovm_config_setting cfg; |
| bit found; |
| string fstr, applied_str, cfg_type; |
| |
| found=0; |
| |
| if(recurse) |
| foreach(m_children[i]) begin |
| m_children[i].check_config_usage(recurse); |
| end |
| |
| if(m_configuration_table.size() == 0) return; |
| |
| if(this == ovm_top) |
| fstr = "from the GLOBAL scope"; |
| else |
| fstr = {"from component ", get_full_name(), "(", |
| get_type_name(), ")"}; |
| |
| foreach(m_configuration_table[i]) begin |
| cfg = m_configuration_table[i]; |
| if(cfg.m_used_list.size() == 0 && |
| cfg.m_override_list.size() == 0 ) |
| begin |
| if(cfg.get_value_type() == ovm_config_setting::OVM_INT_TYPE) |
| cfg_type = "int"; |
| else if(cfg.get_value_type() == ovm_config_setting::OVM_STRING_TYPE) |
| cfg_type = "string"; |
| else |
| cfg_type = "object"; |
| ovm_report_warning("CFGNTS", {"No get_config_",cfg_type, |
| "() call ever matched the following set_config_", cfg_type, "() call ", fstr, |
| ": ", cfg.convert2string()}, OVM_NONE); |
| end |
| end |
| |
| //Do not do the lookup work if the CFGOVR action is off |
| if(ovm_report_enabled(OVM_LOW, OVM_INFO, "CFGOVR")) |
| foreach(m_configuration_table[i]) begin |
| cfg = m_configuration_table[i]; |
| if(cfg.m_override_list.size() != 0) |
| begin |
| ovm_report_info("CFGOVR", {"The configuration setting ", cfg.convert2string(), " ", fstr, " was overridden by config setting ", cfg.m_override_list[0].convert2string(), " from component ", cfg.m_override_list[0].m_from.get_full_name(), "(", cfg.m_override_list[0].m_from.get_type_name(), ")"}, OVM_NONE); |
| end |
| end |
| |
| //Do not do the lookup work if the CFGSET action is off |
| if(ovm_report_enabled(OVM_LOW, OVM_INFO, "CFGSET")) |
| foreach(m_configuration_table[i]) begin |
| string cfgstr; |
| cfg = m_configuration_table[i]; |
| if(cfg.m_used_list.size() != 0) |
| begin |
| cfgstr = cfg.convert2string(); |
| applied_str = ""; |
| for(int j=0; j<cfg.m_used_list.size(); ++j) begin |
| ovm_report_info("CFGSET", {"The configuration setting ", cfgstr, " ", fstr, " was applied to component: ", cfg.m_used_list[j].get_full_name(), " (", cfg.m_used_list[j].get_type_name(), ")"}, OVM_NONE); |
| end |
| end |
| end |
| |
| endfunction |
| |
| |
| // get_config_int |
| // -------------- |
| |
| function bit ovm_component::get_config_int (string field_name, |
| inout ovm_bitstream_t value); |
| static ovm_config_setting cfg_matches[$]; |
| ovm_int_config_setting cfg; |
| ovm_component c; |
| //Scan the config tables of each component in the path |
| m_get_config_matches(cfg_matches, ovm_config_setting::OVM_INT_TYPE, field_name); |
| |
| //The first match is the override |
| if(cfg_matches.size()) begin |
| $cast(cfg, cfg_matches[0]); |
| if(print_config_matches) |
| cfg_matches[0].print_match(this, cfg_matches[0].get_from_component(), field_name); |
| cfg_matches[0].set_used(this); |
| for(int i=1; i<cfg_matches.size(); ++i) begin |
| cfg_matches[i].set_override(cfg_matches[0]); |
| end |
| value = cfg.m_value; |
| return 1; |
| end |
| |
| return 0; |
| endfunction |
| |
| |
| // get_config_string |
| // ----------------- |
| |
| function bit ovm_component::get_config_string (string field_name, |
| inout string value); |
| static ovm_config_setting cfg_matches[$]; |
| ovm_string_config_setting cfg; |
| ovm_component c; |
| |
| //Scan the config tables of each component in the path |
| m_get_config_matches(cfg_matches, ovm_config_setting::OVM_STRING_TYPE, field_name); |
| |
| //The first match is the override |
| if(cfg_matches.size()) begin |
| $cast(cfg, cfg_matches[0]); |
| if(print_config_matches) |
| cfg_matches[0].print_match(this, cfg_matches[0].get_from_component(), field_name); |
| cfg_matches[0].set_used(this); |
| for(int i=1; i<cfg_matches.size(); ++i) |
| cfg_matches[i].set_override(cfg_matches[0]); |
| value = cfg.m_value; |
| return 1; |
| end |
| |
| return 0; |
| endfunction |
| |
| |
| // get_config_object |
| // ----------------- |
| |
| function bit ovm_component::get_config_object (string field_name, |
| inout ovm_object value, |
| input bit clone=1); |
| static ovm_config_setting cfg_matches[$]; |
| ovm_object_config_setting cfg; |
| ovm_component c; |
| |
| //Scan the config tables of each component in the path |
| m_get_config_matches(cfg_matches, ovm_config_setting::OVM_OBJECT_TYPE, field_name); |
| |
| //The first match is the override |
| if(cfg_matches.size()) begin |
| $cast(cfg, cfg_matches[0]); |
| if(print_config_matches) |
| cfg_matches[0].print_match(this, cfg_matches[0].get_from_component(), field_name); |
| cfg_matches[0].set_used(this); |
| for(int i=1; i<cfg_matches.size(); ++i) |
| cfg_matches[i].set_override(cfg_matches[0]); |
| if((clone && cfg.m_clone) && (cfg.m_value != null)) |
| value = cfg.m_value.clone(); |
| else |
| value = cfg.m_value; |
| return 1; |
| end |
| |
| return 0; |
| endfunction |
| |
| |
| // apply_config_settings |
| // --------------------- |
| |
| function void ovm_component::apply_config_settings (bit verbose=0); |
| static ovm_component stack[$]; |
| static ovm_config_setting overrides[string]; |
| ovm_config_setting cfg; |
| ovm_int_config_setting cfg_int; |
| ovm_string_config_setting cfg_str; |
| ovm_object_config_setting cfg_obj; |
| ovm_component comp; |
| string match_str; |
| string matched=""; |
| bit has_match=0; |
| if(stack.size() == 0 || stack[stack.size()-1] != this) begin |
| m_component_path(stack); |
| end |
| //apply any override that matches this component. Go bottom up and then back |
| //to front so the last override in the global scope has precedence to the |
| //first override in the parent scope. |
| if (verbose) begin |
| match_str = {"Auto-configuration matches for component ", |
| this.get_full_name()," (",get_type_name(),"). Last entry for a given field takes precedence.\n\n", |
| " Config set from Instance Path Field name Type Value\n", |
| " ------------------------------------------------------------------------------\n"}; |
| end |
| for(int i=stack.size()-1; i>=0; --i) begin |
| comp = stack[i]; |
| if(comp == null) comp = ovm_top; |
| if(comp!=null) begin |
| for(int j=comp.m_configuration_table.size()-1; j>=0; --j) begin |
| cfg = comp.m_configuration_table[j]; |
| if(cfg.component_match(this)) begin |
| if(verbose) |
| matched = cfg.matches_string(this,comp); |
| if($cast(cfg_int, cfg)) |
| set_int_local(cfg_int.m_field, cfg_int.m_value); |
| else if($cast(cfg_str, cfg)) |
| set_string_local(cfg_str.m_field, cfg_str.m_value); |
| else if($cast(cfg_obj, cfg)) begin |
| set_object_local(cfg_obj.m_field, cfg_obj.m_value, cfg_obj.m_clone); |
| if(verbose) |
| matched = {matched, " clone=",(cfg_obj.m_clone==1)?"1":"0"}; |
| end |
| if(verbose) |
| match_str = {match_str, " ", matched,"\n"}; |
| has_match = 1; |
| if(m_sc.status) |
| cfg.m_used_list.push_back(this); |
| end |
| end |
| end |
| end |
| |
| if (verbose && has_match) |
| if(ovm_report_enabled(OVM_MEDIUM, OVM_INFO, "auto-configuration")) |
| ovm_report_info("auto-configuration", {match_str,"\n"}, OVM_MEDIUM); |
| |
| endfunction |
| |
| |
| // print_config_settings |
| // --------------------- |
| |
| function void ovm_component::print_config_settings (string field="", |
| ovm_component comp=null, |
| bit recurse=0); |
| static int depth; |
| static ovm_component stack[$]; |
| ovm_component cc; |
| string all_matches; |
| string v,r; |
| all_matches = ""; |
| |
| if(comp==null) |
| comp = this; |
| |
| comp.m_component_path(stack); |
| while(stack.size() && (stack[stack.size()-1] != comp)) |
| void'(stack.pop_back()); |
| |
| cc = comp; |
| |
| $swrite(v, "%s", cc.get_full_name()); |
| while(v.len()<17) v = {v," "}; |
| foreach(stack[s]) begin |
| comp = stack[s]; |
| for(int i=0; i<comp.m_configuration_table.size(); ++i) begin |
| r = comp.m_configuration_table[i].matches_string(cc, comp); |
| if(r != "") |
| all_matches = {all_matches, v, r, "\n"}; |
| end |
| end |
| |
| // Note- should use ovm_printer for formatting |
| if(((all_matches != "") || (recurse == 1)) && depth == 0) begin |
| $display("Configuration settings for component %s (recurse = %0d)", |
| cc.get_full_name(), recurse); |
| $display("Set to Set from Component match Field name Type Value"); |
| $display("-------------------------------------------------------------------------------"); |
| end |
| if(all_matches == "") |
| $display("%s NONE", v); |
| else |
| $write("%s", all_matches); |
| |
| if(recurse) begin |
| depth++; |
| if(cc.m_children.first(v)) |
| do this.print_config_settings(field, cc.m_children[v], recurse); |
| while(cc.m_children.next(v)); |
| depth--; |
| end |
| endfunction |
| |
| //------------------------------------------------------------------------------ |
| // |
| // DEPRECATED - DO NOT USE |
| // |
| //------------------------------------------------------------------------------ |
| |
| // global_stop_request (static, deprecated) |
| // ------------------- |
| |
| function void ovm_component::global_stop_request(); |
| ovm_root top; |
| top = ovm_root::get(); |
| top.stop_request(); |
| endfunction |
| |
| |
| // post_new (deprecated) |
| // -------- |
| |
| function void ovm_component::post_new(); |
| return; |
| endfunction |
| |
| |
| // export_connections (deprecated) |
| // ------------------ |
| |
| function void ovm_component::export_connections(); |
| return; |
| endfunction |
| |
| |
| // import_connections (deprecated) |
| // ------------------ |
| |
| function void ovm_component::import_connections(); |
| return; |
| endfunction |
| |
| |
| // configure (deprecated) |
| // --------- |
| |
| function void ovm_component::configure(); |
| return; |
| endfunction |
| |
| |
| // pre_run (deprecated) |
| // ------- |
| |
| function void ovm_component::pre_run(); |
| return; |
| endfunction |
| |
| |
| // find_component (deprecated) |
| // -------------- |
| |
| function ovm_component ovm_component::find_component (string comp_match); |
| static bit issued=0; |
| if (!issued) begin |
| issued=1; |
| ovm_top.ovm_report_warning("deprecated", |
| {"ovm_component::find_component() is deprecated and replaced by ", |
| "ovm_top.find()"}, OVM_NONE); |
| end |
| return ovm_top.find(comp_match); |
| endfunction |
| |
| |
| // find_components (deprecated) |
| // --------------- |
| |
| function void ovm_component::find_components (string comp_match, |
| ref ovm_component comps[$]); |
| static bit issued=0; |
| if (!issued) begin |
| issued=1; |
| ovm_top.ovm_report_warning("deprecated", |
| {"ovm_component::find_components() is deprecated and replaced by ", |
| "ovm_top.find_all()"}, OVM_NONE); |
| end |
| ovm_top.find_all(comp_match,comps); |
| endfunction |
| |
| |
| // get_component (deprecated) |
| // ------------- |
| |
| function ovm_component ovm_component::get_component (int ele); |
| ovm_component m__comps[$]; |
| static bit issued=0; |
| if (!issued) begin |
| issued=1; |
| ovm_top.ovm_report_warning("deprecated", |
| {"ovm_component::get_component() is an internal method that has been ", |
| "deprecated. ovm_top's find, find_all, and ovm_component's lookup ", |
| "method provide similar functionality."}, OVM_NONE); |
| end |
| if (m__comps.size()==0) |
| ovm_top.find_all("*",m__comps); |
| if (ele < m__comps.size()) |
| return m__comps[ele]; |
| return null; |
| endfunction |
| |
| |
| // get_num_components (deprecated) |
| // ------------------ |
| |
| function int ovm_component::get_num_components (); |
| ovm_component m__comps[$]; |
| static bit issued=0; |
| if (!issued) begin |
| issued=1; |
| ovm_top.ovm_report_warning("deprecated", |
| {"ovm_component::get_num_components() is an internal method that has ", |
| "been deprecated. The number of components in the testbench can be ", |
| "obtained using the ovm_top.find_all() method."}, OVM_NONE); |
| end |
| while (m__comps.size()!=0) |
| m__comps.delete(0); |
| ovm_top.find_all("*",m__comps); |
| get_num_components = m__comps.size(); |
| endfunction |
| |
