|
// $Id: //dvt/vtech/dev/main/ovm/src/base/ovm_object.sv#41 $ |
|
//---------------------------------------------------------------------- |
|
// 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_object.svh" |
|
typedef class ovm_component; |
|
|
|
|
|
//---------------------------------------------------------------------------- |
|
// |
|
// CLASS- ovm_object |
|
// |
|
//---------------------------------------------------------------------------- |
|
|
|
|
|
// new |
|
// --- |
|
|
|
function ovm_object::new (string name=""); |
|
|
|
m_inst_id = m_inst_count++; |
|
m_leaf_name = name; |
|
m_field_automation (null, OVM_CHECK_FIELDS, ""); |
|
endfunction |
|
|
|
|
|
// reseed |
|
// ------ |
|
|
|
function void ovm_object::reseed (); |
|
if(use_ovm_seeding) |
|
this.srandom(ovm_create_random_seed(get_type_name(), get_full_name())); |
|
endfunction |
|
|
|
|
|
// get type |
|
// -------- |
|
|
|
function ovm_object_wrapper ovm_object::get_type(); |
|
ovm_report_error("NOTYPID", "get_type not implemented in derived class.", OVM_NONE); |
|
return null; |
|
endfunction |
|
|
|
|
|
// get inst_id |
|
// ----------- |
|
|
|
function int ovm_object::get_inst_id(); |
|
return m_inst_id; |
|
endfunction |
|
|
|
|
|
// get_object_type |
|
// --------------- |
|
|
|
function ovm_object_wrapper ovm_object::get_object_type(); |
|
if(get_type_name() == "<unknown>") return null; |
|
return factory.find_by_name(get_type_name()); |
|
endfunction |
|
|
|
|
|
// get inst_count |
|
// -------------- |
|
|
|
function int ovm_object::get_inst_count(); |
|
return m_inst_count; |
|
endfunction |
|
|
|
|
|
// get_name |
|
// -------- |
|
|
|
function string ovm_object::get_name (); |
|
return m_leaf_name; |
|
endfunction |
|
|
|
|
|
// get_full_name |
|
// ------------- |
|
|
|
function string ovm_object::get_full_name (); |
|
return get_name(); |
|
endfunction |
|
|
|
|
|
// set_name |
|
// -------- |
|
|
|
function void ovm_object::set_name (string name); |
|
m_leaf_name = name; |
|
endfunction |
|
|
|
|
|
// print |
|
// ----- |
|
|
|
function void ovm_object::print(ovm_printer printer=null); |
|
|
|
if(printer==null) |
|
printer = ovm_default_printer; |
|
|
|
if(printer.istop()) begin |
|
printer.print_object(get_name(), this); |
|
end |
|
else begin |
|
//do m_field_automation here so user doesn't need to call anything to get |
|
//automation. |
|
ovm_auto_options_object.printer = printer; |
|
m_field_automation(null, OVM_PRINT, ""); |
|
//call user override |
|
do_print(printer); |
|
end |
|
endfunction |
|
|
|
|
|
// sprint |
|
// ------ |
|
|
|
function string ovm_object::sprint(ovm_printer printer=null); |
|
bit p; |
|
|
|
if(printer==null) |
|
printer = ovm_default_printer; |
|
|
|
p = printer.knobs.sprint; |
|
printer.knobs.sprint = 1; |
|
|
|
print(printer); |
|
|
|
printer.knobs.sprint = p; //revert back to regular printing |
|
return printer.m_string; |
|
endfunction |
|
|
|
|
|
// do_sprint (deprecated) |
|
// --------- |
|
|
|
function string ovm_object::do_sprint(ovm_printer printer); |
|
ovm_top.ovm_report_warning("deprecated", |
|
{"ovm_object::do_sprint() is deprecated and replaced by ", |
|
"ovm_object::convert2string()"}, OVM_NONE); |
|
return convert2string(); |
|
endfunction |
|
|
|
|
|
// convert2string (virtual) |
|
// -------------- |
|
|
|
function string ovm_object::convert2string(); |
|
return ""; |
|
endfunction |
|
|
|
|
|
// print_field_match (static) |
|
// ----------------- |
|
|
|
function void ovm_object::print_field_match(string fnc, string match); |
|
string scratch; |
|
|
|
if(m_sc.save_last_field) |
|
m_sc.last_field = m_sc.get_full_scope_arg(); |
|
|
|
if(print_matches) begin |
|
int style; |
|
scratch = { |
|
fnc, ": Matched string ", match, " to field ", m_sc.get_full_scope_arg() |
|
}; |
|
ovm_report_info("STRMTC", scratch, OVM_LOW); |
|
end |
|
endfunction |
|
|
|
// set |
|
// --- |
|
|
|
function void ovm_object::set_int_local (string field_name, |
|
ovm_bitstream_t value, |
|
bit recurse=1); |
|
if(m_sc.scope.in_hierarchy(this)) return; |
|
|
|
this.m_sc.status = 0; |
|
this.m_sc.bitstream = value; |
|
|
|
m_field_automation(null, OVM_SETINT, field_name); |
|
|
|
if(m_sc.warning && !this.m_sc.status) begin |
|
ovm_report_error("NOMTC", $psprintf("did not find a match for field %s", field_name),OVM_NONE); |
|
end |
|
|
|
endfunction |
|
|
|
|
|
// set_object_local |
|
// ---------------- |
|
|
|
function void ovm_object::set_object_local (string field_name, |
|
ovm_object value, |
|
bit clone=1, |
|
bit recurse=1); |
|
ovm_object cc; |
|
if(m_sc.scope.in_hierarchy(this)) return; |
|
|
|
if(clone && (value!=null)) begin |
|
cc = value.clone(); |
|
if(cc != null) cc.set_name(field_name); |
|
value = cc; |
|
end |
|
|
|
this.m_sc.status = 0; |
|
this.m_sc.object = value; |
|
ovm_auto_options_object.clone = clone; |
|
|
|
m_field_automation(null, OVM_SETOBJ, field_name); |
|
|
|
if(m_sc.warning && !this.m_sc.status) begin |
|
ovm_report_error("NOMTC", $psprintf("did not find a match for field %s", field_name), OVM_NONE); |
|
end |
|
|
|
endfunction |
|
|
|
|
|
// set_string_local |
|
// ---------------- |
|
function void ovm_object::set_string_local (string field_name, |
|
string value, |
|
bit recurse=1); |
|
if(m_sc.scope.in_hierarchy(this)) return; |
|
this.m_sc.status = 0; |
|
this.m_sc.stringv = value; |
|
|
|
m_field_automation(null, OVM_SETSTR, field_name); |
|
|
|
if(m_sc.warning && !this.m_sc.status) begin |
|
`ifdef INCA |
|
ovm_report_error("NOMTC", $psprintf("did not find a match for field %s (@%0d)", field_name, this), OVM_NONE); |
|
`else |
|
ovm_report_error("NOMTC", $psprintf("did not find a match for field %s", field_name), OVM_NONE); |
|
`endif |
|
end |
|
endfunction |
|
|
|
|
|
// m_do_set (static) |
|
// ------------ |
|
|
|
// function m_do_set (match, arg, lhs, what, flag) |
|
// Precondition: |
|
// match -- a match string to test against arg to do the set |
|
// arg -- the name of the short name of the lhs object |
|
// lhs -- the lhs to do on (left hand side) |
|
// what -- integer, what to do |
|
// flag -- object flags |
|
// |
|
// ovm_object::m_sc.bitstream -- rhs object used for set/get |
|
// ovm_object::m_sc.status -- return status for set/get calls |
|
// |
|
|
|
|
|
function int ovm_object::m_do_set (string match, |
|
string arg, |
|
inout ovm_bitstream_t lhs, |
|
input int what, |
|
int flag); |
|
|
|
bit matched; |
|
|
|
if (what < OVM_START_FUNCS || what > OVM_END_FUNCS) |
|
return 0; |
|
|
|
matched = ovm_is_match(match, m_sc.scope.get_arg()); |
|
|
|
case (what) |
|
OVM_SETINT: |
|
begin |
|
if(matched) begin |
|
if(flag &OVM_READONLY) begin |
|
ovm_report_warning("RDONLY", $psprintf("Readonly argument match %s is ignored", |
|
m_sc.get_full_scope_arg()), OVM_NONE); |
|
return 0; |
|
end |
|
print_field_match("set_int()", match); |
|
lhs = ovm_object::m_sc.bitstream; |
|
ovm_object::m_sc.status = 1; |
|
return 1; |
|
end |
|
end |
|
default: |
|
begin |
|
if(matched) begin |
|
ovm_report_warning("MTCTYP", $psprintf("matched integral field %s, %s", |
|
m_sc.get_full_scope_arg(), |
|
"but expected a non-integral type"), OVM_NONE); |
|
end |
|
end |
|
endcase |
|
return 0; |
|
endfunction |
|
|
|
|
|
// m_do_set_string (static) |
|
// ------------------- |
|
|
|
// function m_do_set_string (match, arg, lhs, what, flag) |
|
// Precondition: |
|
// match -- a match string to test against arg to do the set |
|
// arg -- the name of the short name of the lhs object |
|
// lhs -- the lhs to do get or set on (left hand side) |
|
// what -- integer, what to do |
|
// flag -- object flags |
|
// |
|
// ovm_object::m_sc.stringv -- rhs object used for set/get |
|
// ovm_object::m_sc.status -- return status for set/get calls |
|
// |
|
|
|
function int ovm_object::m_do_set_string(string match, |
|
string arg, |
|
inout string lhs, |
|
input int what, |
|
int flag); |
|
|
|
bit matched; |
|
string s; |
|
|
|
if (what < OVM_START_FUNCS || what > OVM_END_FUNCS) |
|
return 0; |
|
|
|
matched = ovm_is_match(match, m_sc.scope.get_arg()); |
|
|
|
case (what) |
|
OVM_SETSTR: |
|
begin |
|
if(matched) begin |
|
if(flag &OVM_READONLY) begin |
|
ovm_report_warning("RDONLY", $psprintf("Readonly argument match %s is ignored", |
|
m_sc.get_full_scope_arg()), OVM_NONE); |
|
return 0; |
|
end |
|
print_field_match("set_string()", match); |
|
lhs = ovm_object::m_sc.stringv; |
|
ovm_object::m_sc.status = 1; |
|
return 1; |
|
end |
|
end |
|
default: |
|
begin |
|
if(matched) begin |
|
ovm_report_warning("MTCTYP", $psprintf("matched string field %s, %s", |
|
m_sc.get_full_scope_arg(), |
|
"but expected a non-string type"), OVM_NONE); |
|
end |
|
end |
|
endcase |
|
return 0; |
|
endfunction |
|
|
|
|
|
// m_do_set_object (static) |
|
// ----------------- |
|
|
|
// function m_do_set_object (match, arg, lhsobj, what, flag) |
|
// Precondition: |
|
// match -- a match string to test against arg to do the set |
|
// arg -- the name of the short name of the lhs object |
|
// lhsobj -- the object to do set_object on (left hand side) |
|
// what -- integer, what to do |
|
// flag -- object flags |
|
// |
|
// ovm_object::m_sc.object -- rhs object used for set |
|
// ovm_object::m_sc.status -- return status for set/get calls. set |
|
// always returns 0. |
|
// |
|
// Postcondition: |
|
// Performs the set or get operation on an object. If the object doesn't |
|
// match then the object is recursed. The get* operations return true if |
|
// an index was returned. The set* always return 0. |
|
|
|
function int ovm_object::m_do_set_object (string match, |
|
string arg, |
|
inout ovm_object lhsobj, |
|
input int what, |
|
int flag); |
|
|
|
bit matched; |
|
bit prev; |
|
int cnt; |
|
|
|
if (what < OVM_START_FUNCS || what > OVM_END_FUNCS) |
|
return 0; |
|
|
|
matched = ovm_is_match(match, m_sc.scope.get_arg()); |
|
|
|
case (what) |
|
OVM_SETOBJ: |
|
begin |
|
if(matched) begin |
|
if(flag &OVM_READONLY) begin |
|
ovm_report_warning("RDONLY", $psprintf("Readonly argument match %s is ignored", |
|
m_sc.get_full_scope_arg()), OVM_NONE); |
|
return 0; |
|
end |
|
print_field_match("set_object()", match); |
|
lhsobj = ovm_object::m_sc.object; |
|
ovm_object::m_sc.status = 1; |
|
end |
|
else if(lhsobj==null) return 0; |
|
if(flag &OVM_READONLY) |
|
return 0; |
|
//Only traverse if there is a possible match. |
|
for(cnt=0; cnt<match.len(); ++cnt) begin |
|
if(match[cnt] == "." || match[cnt] == "*") break; |
|
end |
|
if(cnt!=match.len()) |
|
lhsobj.m_field_automation(null, OVM_SETOBJ, match); |
|
return ovm_object::m_sc.status; |
|
end |
|
endcase |
|
|
|
if(matched) begin |
|
ovm_report_warning("MTCTYP", $psprintf("matched object field %s, %s", |
|
m_sc.get_full_scope_arg(), |
|
"but expected a non-object type"), OVM_NONE); |
|
end |
|
if(lhsobj==null) return 0; |
|
lhsobj.m_field_automation(null, what, match); |
|
|
|
return ovm_object::m_sc.status; |
|
|
|
endfunction |
|
|
|
// clone |
|
// ----- |
|
|
|
function ovm_object ovm_object::clone(); |
|
ovm_object tmp; |
|
tmp = this.create(get_name()); |
|
if(tmp == null) begin |
|
// ovm_report_warning("CRFLD", $psprintf("The create method failed for %s, object will be copied using shallow copy", get_name())); |
|
// tmp = new this; |
|
ovm_report_warning("CRFLD", $psprintf("The create method failed for %s, object cannot be cloned", get_name()), OVM_NONE); |
|
end |
|
else begin |
|
tmp.copy(this); |
|
end |
|
|
|
return(tmp); |
|
endfunction |
|
|
|
|
|
// copy |
|
// ---- |
|
|
|
ovm_copy_map ovm_global_copy_map = new; |
|
function void ovm_object::copy (ovm_object rhs); |
|
//For cycle checking |
|
static int depth; |
|
if((rhs !=null) && (ovm_global_copy_map.get(rhs) != null)) begin |
|
return; |
|
end |
|
|
|
if(rhs==null) begin |
|
ovm_report_warning("NULLCP", "A null object was supplied to copy; copy is ignored", OVM_NONE); |
|
return; |
|
end |
|
|
|
ovm_global_copy_map.set(rhs, this); |
|
++depth; |
|
|
|
do_copy(rhs); |
|
m_field_automation(rhs, OVM_COPY, ""); |
|
|
|
--depth; |
|
if(depth==0) begin |
|
ovm_global_copy_map.clear(); |
|
end |
|
endfunction |
|
|
|
|
|
// do_copy |
|
// ------- |
|
|
|
function void ovm_object::do_copy (ovm_object rhs); |
|
return; |
|
endfunction |
|
|
|
|
|
// init_status |
|
// ----------- |
|
|
|
function ovm_status_container ovm_object::init_status(); |
|
if(m_sc==null) m_sc=new; |
|
return m_sc; |
|
endfunction |
|
|
|
|
|
// compare |
|
// ------- |
|
|
|
function bit ovm_object::compare (ovm_object rhs, |
|
ovm_comparer comparer=null); |
|
bit t, dc; |
|
static int style; |
|
bit done; |
|
done = 0; |
|
if(comparer != null) |
|
ovm_auto_options_object.comparer = comparer; |
|
else |
|
ovm_auto_options_object.comparer = ovm_default_comparer; |
|
comparer = ovm_auto_options_object.comparer; |
|
|
|
if(!m_sc.scope.depth()) begin |
|
comparer.compare_map.clear(); |
|
comparer.result = 0; |
|
comparer.miscompares = ""; |
|
comparer.scope = m_sc.scope; |
|
if(get_name() == "") begin |
|
m_sc.scope.down("<object>", this); |
|
end |
|
else |
|
m_sc.scope.down(this.get_name(), this); |
|
end |
|
if(!done && (rhs == null)) begin |
|
if(m_sc.scope.depth()) begin |
|
comparer.print_msg_object(this, rhs); |
|
end |
|
else begin |
|
comparer.print_msg_object(this, rhs); |
|
`ifdef INCA |
|
ovm_report_info("MISCMP", |
|
$psprintf("%0d Miscompare(s) for object %s@%0d vs. @%0d", |
|
comparer.result, get_name(), this, rhs), ovm_auto_options_object.comparer.verbosity); |
|
`else |
|
ovm_report_info("MISCMP", |
|
$psprintf("%0d Miscompare(s) for object %s", |
|
comparer.result, get_name()), ovm_auto_options_object.comparer.verbosity); |
|
`endif |
|
done = 1; |
|
end |
|
end |
|
|
|
if(!done && (comparer.compare_map.get(rhs) != null)) begin |
|
if(comparer.compare_map.get(rhs) != this) begin |
|
comparer.print_msg_object(this, comparer.compare_map.get(rhs)); |
|
end |
|
done = 1; //don't do any more work after this case, but do cleanup |
|
end |
|
|
|
if(!done && comparer.check_type && get_type_name() != rhs.get_type_name()) begin |
|
m_sc.stringv = { "lhs type = \"", get_type_name(), |
|
"\" : rhs type = \"", rhs.get_type_name(), "\""}; |
|
comparer.print_msg(m_sc.stringv); |
|
end |
|
|
|
if(!done) begin |
|
comparer.compare_map.set(rhs, this); |
|
m_field_automation(rhs, OVM_COMPARE, ""); |
|
dc = do_compare(rhs, comparer); |
|
end |
|
|
|
if(m_sc.scope.depth() == 1) begin |
|
m_sc.scope.up(this); |
|
end |
|
|
|
comparer.print_rollup(this, rhs); |
|
return (comparer.result == 0 && dc == 1); |
|
endfunction |
|
|
|
|
|
// do_compare |
|
// ---------- |
|
|
|
function bit ovm_object::do_compare (ovm_object rhs, |
|
ovm_comparer comparer); |
|
return 1; |
|
endfunction |
|
|
|
|
|
// m_field_automation |
|
// -------------- |
|
|
|
function void ovm_object::m_field_automation ( ovm_object tmp_data__, |
|
int what__, |
|
string str__ ); |
|
return; |
|
endfunction |
|
|
|
|
|
// check_fields |
|
// ------------ |
|
|
|
function void ovm_object::m_do_field_check(string field); |
|
if(m_field_array.exists(field) && (m_field_array[field] == 1)) begin |
|
ovm_report_error("MLTFLD", $psprintf("Field %s is defined multiple times in type %s", |
|
field, get_type_name()), OVM_NONE); |
|
end |
|
m_field_array[field]++; |
|
endfunction |
|
|
|
function void ovm_object::m_delete_field_array(); |
|
m_field_array.delete(); |
|
endfunction |
|
|
|
// do_print (virtual override) |
|
// ------------ |
|
|
|
function void ovm_object::do_print(ovm_printer printer); |
|
return; |
|
endfunction |
|
|
|
|
|
// m_pack |
|
// ------ |
|
|
|
function void ovm_object::m_pack (inout ovm_packer packer); |
|
|
|
if(packer!=null) |
|
ovm_auto_options_object.packer = packer; |
|
else |
|
ovm_auto_options_object.packer = ovm_default_packer; |
|
packer = ovm_auto_options_object.packer; |
|
|
|
packer.reset(); |
|
packer.scope.down(get_name(), this); |
|
|
|
m_field_automation(null, OVM_PACK, ""); |
|
do_pack(packer); |
|
|
|
packer.set_packed_size(); |
|
|
|
packer.scope.up(this); |
|
|
|
endfunction |
|
|
|
|
|
// pack |
|
// ---- |
|
|
|
function int ovm_object::pack (ref bit bitstream [], |
|
input ovm_packer packer =null ); |
|
m_pack(packer); |
|
packer.get_bits(bitstream); |
|
return packer.get_packed_size(); |
|
endfunction |
|
|
|
// pack_bytes |
|
// ---------- |
|
|
|
function int ovm_object::pack_bytes (ref byte unsigned bytestream [], |
|
input ovm_packer packer=null ); |
|
m_pack(packer); |
|
packer.get_bytes(bytestream); |
|
return packer.get_packed_size(); |
|
endfunction |
|
|
|
|
|
// pack_ints |
|
// --------- |
|
|
|
function int ovm_object::pack_ints (ref int unsigned intstream [], |
|
input ovm_packer packer=null ); |
|
m_pack(packer); |
|
packer.get_ints(intstream); |
|
return packer.get_packed_size(); |
|
endfunction |
|
|
|
|
|
// do_pack |
|
// ------- |
|
|
|
function void ovm_object::do_pack (ovm_packer packer ); |
|
return; |
|
endfunction |
|
|
|
|
|
// m_unpack_pre |
|
// ------------ |
|
|
|
function void ovm_object::m_unpack_pre (inout ovm_packer packer); |
|
if(packer!=null) |
|
ovm_auto_options_object.packer = packer; |
|
else |
|
ovm_auto_options_object.packer = ovm_default_packer; |
|
packer = ovm_auto_options_object.packer; |
|
packer.reset(); |
|
endfunction |
|
|
|
|
|
// m_unpack_post |
|
// ------------- |
|
|
|
function void ovm_object::m_unpack_post (ovm_packer packer); |
|
|
|
int provided_size; |
|
|
|
provided_size = packer.get_packed_size(); |
|
|
|
//Put this object into the hierarchy |
|
packer.scope.down(get_name(), this); |
|
|
|
m_field_automation(null, OVM_UNPACK, ""); |
|
|
|
do_unpack(packer); |
|
|
|
//Scope back up before leaving |
|
packer.scope.up(this); |
|
|
|
if(packer.get_packed_size() != provided_size) begin |
|
ovm_report_warning("BDUNPK", $psprintf("Unpack operation unsuccessful: unpacked %0d bits from a total of %0d bits", packer.get_packed_size(), provided_size), OVM_NONE); |
|
end |
|
|
|
endfunction |
|
|
|
|
|
// unpack |
|
// ------ |
|
|
|
function int ovm_object::unpack (ref bit bitstream [], |
|
input ovm_packer packer=null); |
|
m_unpack_pre(packer); |
|
packer.put_bits(bitstream); |
|
m_unpack_post(packer); |
|
packer.set_packed_size(); |
|
return packer.get_packed_size(); |
|
endfunction |
|
|
|
|
|
// unpack_bytes |
|
// ------------ |
|
|
|
function int ovm_object::unpack_bytes (ref byte unsigned bytestream [], |
|
input ovm_packer packer=null); |
|
m_unpack_pre(packer); |
|
packer.put_bytes(bytestream); |
|
m_unpack_post(packer); |
|
packer.set_packed_size(); |
|
return packer.get_packed_size(); |
|
endfunction |
|
|
|
|
|
// unpack_ints |
|
// ----------- |
|
|
|
function int ovm_object::unpack_ints (ref int unsigned intstream [], |
|
input ovm_packer packer=null); |
|
m_unpack_pre(packer); |
|
packer.put_ints(intstream); |
|
m_unpack_post(packer); |
|
packer.set_packed_size(); |
|
return packer.get_packed_size(); |
|
endfunction |
|
|
|
|
|
// do_unpack |
|
// --------- |
|
|
|
function void ovm_object::do_unpack (ovm_packer packer); |
|
return; |
|
endfunction |
|
|
|
|
|
// record |
|
// ------ |
|
|
|
function void ovm_object::record (ovm_recorder recorder=null); |
|
//mxg if(!recorder) |
|
if(recorder == null) |
|
recorder = ovm_default_recorder; |
|
|
|
if(!recorder.tr_handle) return; |
|
|
|
ovm_auto_options_object.recorder = recorder; |
|
recorder.recording_depth++; |
|
m_field_automation(null, OVM_RECORD, ""); |
|
do_record(recorder); |
|
|
|
recorder.recording_depth--; |
|
|
|
if(recorder.recording_depth==0) begin |
|
recorder.tr_handle = 0; |
|
end |
|
endfunction |
|
|
|
|
|
// do_record (virtual) |
|
// --------- |
|
|
|
function void ovm_object::do_record (ovm_recorder recorder); |
|
return; |
|
endfunction |
|
|
|
|
|
// m_get_function_type (static) |
|
// ------------------- |
|
|
|
function string ovm_object::m_get_function_type (int what); |
|
case (what) |
|
OVM_COPY: return "copy"; |
|
OVM_COMPARE: return "compare"; |
|
OVM_PRINT: return "print"; |
|
OVM_RECORD: return "record"; |
|
OVM_PACK: return "pack"; |
|
OVM_UNPACK: return "unpack"; |
|
OVM_FLAGS: return "get_flags"; |
|
OVM_SETINT: return "set"; |
|
OVM_SETOBJ: return "set_object"; |
|
OVM_SETSTR: return "set_string"; |
|
default: return "unknown"; |
|
endcase |
|
endfunction |
|
|
|
|
|
// m_get_report_object |
|
// ------------------- |
|
|
|
function ovm_report_object ovm_object::m_get_report_object(); |
|
return null; |
|
endfunction |
|
|
|
|
|
// m_record_field_object (static) |
|
// --------------------- |
|
|
|
function void ovm_object::m_record_field_object (string arg, |
|
ovm_object value, |
|
ovm_recorder recorder =null, |
|
int flag = OVM_DEFAULT); |
|
begin |
|
if(recorder == null) |
|
recorder=ovm_auto_options_object.recorder; |
|
|
|
if((flag&OVM_NORECORD) != 0) return; |
|
|
|
recorder.record_object(arg, value); |
|
|
|
end |
|
endfunction |
|
|
|
|
|
// m_do_data (static) |
|
// --------- |
|
|
|
// function m_do_data (arg, lhs, rhs, what, flag) |
|
// Precondition: |
|
// arg -- the name of the short name of the lhs object |
|
// lhs -- the lhs to do work on (left hand side) |
|
// lhs -- the rhs to do work from (right hand side) |
|
// what -- integer, what to do |
|
// flag -- object flags |
|
|
|
function int ovm_object::m_do_data (string arg, |
|
inout ovm_bitstream_t lhs, |
|
input ovm_bitstream_t rhs, |
|
int what, |
|
int bits, |
|
int flag); |
|
|
|
|
|
if (what > OVM_END_DATA_EXTRA) |
|
return 0; |
|
if(bits > OVM_STREAMBITS) begin |
|
ovm_report_error("FLDTNC",$psprintf("%s is %0d bits; maximum field size is %0d, truncating", |
|
arg, bits, OVM_STREAMBITS), OVM_NONE); |
|
end |
|
case (what) |
|
OVM_COPY: |
|
begin |
|
if(((flag)&OVM_NOCOPY) == 0) begin |
|
ovm_bitstream_t mask; |
|
mask = -1; |
|
mask >>= (OVM_STREAMBITS-bits); |
|
lhs = rhs & mask; |
|
end |
|
return 0; |
|
end |
|
OVM_COMPARE: |
|
begin |
|
if(((flag)&OVM_NOCOMPARE) == 0) begin |
|
bit r; |
|
if(bits <= 64) |
|
r = ovm_auto_options_object.comparer.compare_field_int(arg, lhs, rhs, bits, ovm_radix_enum'(flag&OVM_RADIX)); |
|
else |
|
r = ovm_auto_options_object.comparer.compare_field(arg, lhs, rhs, bits, ovm_radix_enum'(flag&OVM_RADIX)); |
|
end |
|
return 0; |
|
end |
|
OVM_PACK: |
|
begin |
|
if(((flag)&OVM_NOPACK) == 0) begin |
|
if(((flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) || |
|
(!(flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin |
|
if(bits<=64) |
|
ovm_auto_options_object.packer.pack_field_int(lhs, bits); |
|
else |
|
ovm_auto_options_object.packer.pack_field(lhs, bits); |
|
end |
|
end |
|
return 0; |
|
end |
|
OVM_UNPACK: |
|
begin |
|
if(((flag)&OVM_NOPACK) == 0) begin |
|
if(((flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) || |
|
(!(flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin |
|
if(bits<=64) |
|
lhs=ovm_auto_options_object.packer.unpack_field_int(bits); |
|
else |
|
lhs=ovm_auto_options_object.packer.unpack_field(bits); |
|
end |
|
end |
|
return 0; |
|
end |
|
OVM_PRINT: |
|
begin |
|
if(((flag)&OVM_NOPRINT) == 0) |
|
begin |
|
ovm_printer printer; |
|
ovm_radix_enum radix; |
|
radix = ovm_radix_enum'(flag&OVM_RADIX); |
|
printer = ovm_auto_options_object.printer; |
|
printer.print_field(arg, lhs, bits, radix); |
|
end |
|
end |
|
OVM_RECORD: |
|
begin |
|
if(((flag)&OVM_NORECORD) == 0) |
|
begin |
|
integer h; |
|
ovm_radix_enum radix; |
|
|
|
radix = ovm_radix_enum'(flag&OVM_RADIX); |
|
ovm_auto_options_object.recorder.record_field(arg, lhs, bits, radix); |
|
end |
|
end |
|
endcase |
|
return 0; |
|
endfunction |
|
|
|
|
|
// m_do_data_real (static) |
|
// -------------- |
|
|
|
// function m_do_data_real (arg, lhs, rhs, what, flag) |
|
// Precondition: |
|
// arg -- the name of the short name of the lhs object |
|
// lhs -- the lhs to do work on (left hand side) |
|
// lhs -- the rhs to do work from (right hand side) |
|
// what -- integer, what to do |
|
// flag -- object flags |
|
|
|
function int ovm_object::m_do_data_real (string arg, |
|
inout real lhs, |
|
input real rhs, |
|
int what, |
|
int flag); |
|
|
|
|
|
if (what > OVM_END_DATA_EXTRA) |
|
return 0; |
|
case (what) |
|
OVM_COPY: |
|
begin |
|
if(((flag)&OVM_NOCOPY) == 0) begin |
|
lhs = rhs; |
|
end |
|
return 0; |
|
end |
|
OVM_COMPARE: |
|
begin |
|
if(((flag)&OVM_NOCOMPARE) == 0) begin |
|
bit r; |
|
r = ovm_auto_options_object.comparer.compare_field_real(arg, lhs, rhs); |
|
end |
|
return 0; |
|
end |
|
OVM_PACK: |
|
begin |
|
if(((flag)&OVM_NOPACK) == 0) begin |
|
if(((flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) || |
|
(!(flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin |
|
ovm_auto_options_object.packer.pack_field_int($realtobits(lhs), 64); |
|
end |
|
end |
|
return 0; |
|
end |
|
OVM_UNPACK: |
|
begin |
|
if(((flag)&OVM_NOPACK) == 0) begin |
|
if(((flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) || |
|
(!(flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin |
|
lhs=$bitstoreal(ovm_auto_options_object.packer.unpack_field_int(64)); |
|
end |
|
end |
|
return 0; |
|
end |
|
OVM_PRINT: |
|
begin |
|
if(((flag)&OVM_NOPRINT) == 0) |
|
begin |
|
ovm_printer printer; |
|
printer = ovm_auto_options_object.printer; |
|
printer.print_field_real(arg, lhs); |
|
end |
|
end |
|
OVM_RECORD: |
|
begin |
|
if(((flag)&OVM_NORECORD) == 0) |
|
begin |
|
ovm_auto_options_object.recorder.record_field_real(arg, lhs); |
|
end |
|
end |
|
endcase |
|
return 0; |
|
endfunction |
|
|
|
|
|
// m_do_data_object (static) |
|
// ---------------- |
|
|
|
// function m_do_data_object (arg, lhs, rhs, what, flag) |
|
// Precondition: |
|
// arg -- the name of the short name of the lhs object |
|
// lhs -- the lhs to do work on (left hand side) |
|
// lhs -- the rhs to do work from (right hand side) |
|
// what -- integer, what to do |
|
// flag -- object flags |
|
|
|
function int ovm_object::m_do_data_object (string arg, |
|
inout ovm_object lhs, |
|
input ovm_object rhs, |
|
int what, |
|
int flag); |
|
|
|
ovm_object lhs_obj; |
|
|
|
if (what > OVM_END_DATA_EXTRA) |
|
return 0; |
|
|
|
case (what) |
|
OVM_COPY: |
|
begin |
|
int rval; |
|
if(((flag)&OVM_NOCOPY) != 0) begin |
|
return 0; |
|
end |
|
if(rhs == null) begin |
|
lhs = null; |
|
return OVM_REFERENCE; |
|
end |
|
|
|
if(flag & OVM_SHALLOW) begin |
|
rval = OVM_SHALLOW; |
|
end |
|
else if(flag & OVM_REFERENCE) begin |
|
lhs = rhs; |
|
rval = OVM_REFERENCE; |
|
end |
|
else //deepcopy |
|
begin |
|
ovm_object v; |
|
v = ovm_global_copy_map.get(rhs); |
|
if(v != null) begin |
|
lhs = v; |
|
rval = OVM_REFERENCE; |
|
end |
|
else if(lhs==null) begin |
|
lhs = rhs.clone(); |
|
lhs.set_name(arg); |
|
rval = OVM_REFERENCE; |
|
end |
|
else if(rhs == null) begin |
|
rval = OVM_REFERENCE; |
|
end |
|
else begin |
|
//lhs doesn't change for this case, so don't need to copy back |
|
lhs.copy(rhs); |
|
rval = 0; |
|
end |
|
end |
|
return rval; |
|
end |
|
OVM_COMPARE: |
|
begin |
|
bit refcmp; |
|
|
|
if(((flag)&OVM_NOCOMPARE) != 0) begin |
|
return 0; |
|
end |
|
|
|
//if the object are the same then don't need to do a deep compare |
|
if(rhs == lhs) return 0; |
|
|
|
refcmp = (flag & OVM_SHALLOW) && !(ovm_auto_options_object.comparer.policy == OVM_DEEP); |
|
|
|
//do a deep compare here |
|
if(!refcmp && !(ovm_auto_options_object.comparer.policy == OVM_REFERENCE)) |
|
begin |
|
if(((rhs == null) && (lhs != null)) || ((lhs==null) && (rhs!=null))) begin |
|
ovm_auto_options_object.comparer.print_msg_object(lhs, rhs); |
|
return 1; //miscompare |
|
end |
|
if((rhs == null) && (lhs==null)) |
|
return 0; |
|
else begin |
|
bit r; |
|
r = lhs.compare(rhs, ovm_auto_options_object.comparer); |
|
if(r == 0) begin |
|
return 1; |
|
end |
|
else begin |
|
return 0; |
|
end |
|
end |
|
end |
|
else begin //reference compare |
|
if(lhs != rhs) begin |
|
ovm_auto_options_object.comparer.print_msg_object(lhs, rhs); |
|
return 1; |
|
end |
|
end |
|
end |
|
OVM_PACK: |
|
begin |
|
if(((flag&OVM_NOPACK) == 0) && ((flag&OVM_REFERENCE)==0)) begin |
|
if(((flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) || |
|
(!(flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin |
|
ovm_auto_options_object.packer.pack_object(lhs); |
|
end |
|
end |
|
return 0; |
|
end |
|
OVM_UNPACK: |
|
begin |
|
if(((flag&OVM_NOPACK) == 0) && ((flag&OVM_REFERENCE)==0)) begin |
|
if(((flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) || |
|
(!(flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin |
|
ovm_auto_options_object.packer.unpack_object_ext(lhs); |
|
end |
|
end |
|
return 0; |
|
end |
|
OVM_PRINT: |
|
begin |
|
if(((flag)&OVM_NOPRINT) == 0) |
|
begin |
|
if(((flag)&OVM_REFERENCE) || (lhs == null)) begin |
|
int d; |
|
d = ovm_auto_options_object.printer.knobs.depth; |
|
ovm_auto_options_object.printer.knobs.depth = 0; |
|
ovm_auto_options_object.printer.print_object(arg, lhs); |
|
ovm_auto_options_object.printer.knobs.depth = d; |
|
end |
|
else begin |
|
ovm_component obj; |
|
if(lhs != null) begin |
|
if($cast(obj,lhs)) begin |
|
if(ovm_auto_options_object.printer.m_scope.current() == obj.get_parent() ) |
|
ovm_auto_options_object.printer.print_object(arg, lhs); |
|
else |
|
ovm_auto_options_object.printer.print_object_header(arg, lhs); |
|
end |
|
else begin |
|
ovm_auto_options_object.printer.print_object(arg, lhs); |
|
end |
|
end |
|
end |
|
end |
|
end |
|
OVM_RECORD: |
|
begin |
|
if(((flag)&OVM_NORECORD) == 0) |
|
begin |
|
m_sc.scope.up(lhs); //need to scope up since gets scoped down before |
|
if(lhs != null && lhs.get_name()!="") arg = lhs.get_name(); |
|
//If refernce is on then don't want to do cycle check since only |
|
//recording the reference. |
|
if( ((flag) & int'(OVM_REFERENCE)) != 0) |
|
m_record_field_object(arg, lhs, ovm_auto_options_object.recorder,flag); |
|
else begin |
|
if(!m_sc.scope.in_hierarchy(lhs)) |
|
m_record_field_object(arg, lhs, ovm_auto_options_object.recorder,flag); |
|
end |
|
m_sc.scope.down(arg,lhs); //need to scope back dwon |
|
end |
|
end |
|
endcase |
|
return 0; |
|
endfunction |
|
|
|
|
|
// m_do_data_string (static) |
|
// ---------------- |
|
|
|
// function m_do_data_string (arg, lhs, rhs, what, flag) |
|
// Precondition: |
|
// arg -- the name of the short name of the lhs object |
|
// lhs -- the lhs to do work on (left hand side) |
|
// lhs -- the rhs to do work from (right hand side) |
|
// what -- integer, what to do |
|
// flag -- object flags |
|
// |
|
|
|
function int ovm_object::m_do_data_string(string arg, |
|
inout string lhs, |
|
input string rhs, |
|
int what, |
|
int flag); |
|
|
|
if (what > OVM_END_DATA_EXTRA) |
|
return 0; |
|
|
|
case (what) |
|
OVM_COPY: |
|
begin |
|
if(((flag)&OVM_NOCOPY) == 0) begin |
|
lhs = rhs; |
|
end |
|
return 0; |
|
end |
|
OVM_COMPARE: |
|
begin |
|
if(((flag)&OVM_NOCOMPARE) == 0) begin |
|
if(lhs != rhs) begin |
|
m_sc.stringv = { "lhs = \"", lhs, "\" : rhs = \"", rhs, "\""}; |
|
ovm_auto_options_object.comparer.print_msg(m_sc.stringv); |
|
return 1; |
|
end |
|
end |
|
return 0; |
|
end |
|
OVM_PACK: |
|
begin |
|
if(((flag)&OVM_NOPACK) == 0) begin |
|
if(((flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) || |
|
(!(flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin |
|
ovm_auto_options_object.packer.pack_string(lhs); |
|
end |
|
end |
|
return 0; |
|
end |
|
OVM_UNPACK: |
|
begin |
|
if(((flag)&OVM_NOPACK) == 0) begin |
|
if(((flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) || |
|
(!(flag&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin |
|
lhs = ovm_auto_options_object.packer.unpack_string(); |
|
end |
|
end |
|
return 0; |
|
end |
|
OVM_PRINT: |
|
begin |
|
if(((flag)&OVM_NOPRINT) == 0) |
|
begin |
|
ovm_auto_options_object.printer.print_string(arg, lhs); |
|
end |
|
end |
|
OVM_RECORD: |
|
begin |
|
if(((flag)&OVM_NORECORD) == 0) |
|
begin |
|
m_sc.scope.up(null); //need to scope up since gets scoped down before |
|
ovm_auto_options_object.recorder.record_string(arg, lhs); |
|
m_sc.scope.down(arg,null); //need to scope back dwon |
|
end |
|
end |
|
endcase |
|
return 0; |
|
|
|
endfunction |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
// ovm_status_container |
|
// |
|
//----------------------------------------------------------------------------- |
|
|
|
function string ovm_status_container::get_full_scope_arg (); |
|
get_full_scope_arg = scope.get_arg(); |
|
endfunction |
|
|
|
function ovm_scope_stack ovm_status_container::init_scope(); |
|
if(scope==null) scope=new; |
|
return scope; |
|
endfunction |
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
// ovm_options_container |
|
// |
|
//----------------------------------------------------------------------------- |
|
|
|
ovm_options_container ovm_auto_options_object = ovm_options_container::init(); |
|
|
|
function ovm_options_container::new(); |
|
comparer = ovm_default_comparer; |
|
packer = ovm_default_packer; |
|
recorder = ovm_default_recorder; |
|
printer = ovm_default_printer; |
|
endfunction |
|
|
|
function ovm_options_container ovm_options_container::init(); |
|
if(ovm_auto_options_object==null) ovm_auto_options_object=new; |
|
return ovm_auto_options_object; |
|
endfunction |
|
|