//
//------------------------------------------------------------------------------
// Copyright 2007-2010 Mentor Graphics Corporation
// Copyright 2007-2011 Cadence Design Systems, Inc.
// Copyright 2010 Synopsys, 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.
//------------------------------------------------------------------------------
`ifndef UVM_REPORT_CLIENT_SVH
`define UVM_REPORT_CLIENT_SVH
typedef class [docs]uvm_component;
typedef class [docs]uvm_env;
typedef class [docs]uvm_root;
//------------------------------------------------------------------------------
//
// CLASS: uvm_report_object
//
//------------------------------------------------------------------------------
//
// The uvm_report_object provides an interface to the UVM reporting facility.
// Through this interface, components issue the various messages that occur
// during simulation. Users can configure what actions are taken and what
// file(s) are output for individual messages from a particular component
// or for all messages from all components in the environment. Defaults are
// applied where there is no explicit configuration.
//
// Most methods in uvm_report_object are delegated to an internal instance of a
// <uvm_report_handler>, which stores the reporting configuration and determines
// whether an issued message should be displayed based on that configuration.
// Then, to display a message, the report handler delegates the actual
// formatting and production of messages to a central <uvm_report_server>.
//
// A report consists of an id string, severity, verbosity level, and the textual
// message itself. They may optionally include the filename and line number from
// which the message came. If the verbosity level of a report is greater than the
// configured maximum verbosity level of its report object, it is ignored.
// If a report passes the verbosity filter in effect, the report's action is
// determined. If the action includes output to a file, the configured file
// descriptor(s) are determined.
//
// Actions - can be set for (in increasing priority) severity, id, and
// (severity,id) pair. They include output to the screen <UVM_DISPLAY>,
// whether the message counters should be incremented <UVM_COUNT>, and
// whether a $finish should occur <UVM_EXIT>.
//
// Default Actions - The following provides the default actions assigned to
// each severity. These can be overridden by any of the ~set_*_action~ methods.
//| UVM_INFO - UVM_DISPLAY
//| UVM_WARNING - UVM_DISPLAY
//| UVM_ERROR - UVM_DISPLAY | UVM_COUNT
//| UVM_FATAL - UVM_DISPLAY | UVM_EXIT
//
// File descriptors - These can be set by (in increasing priority) default,
// severity level, an id, or (severity,id) pair. File descriptors are
// standard SystemVerilog file descriptors; they may refer to more than one file.
// It is the user's responsibility to open and close them.
//
// Default file handle - The default file handle is 0, which means that reports
// are not sent to a file even if a UVM_LOG attribute is set in the action
// associated with the report. This can be overridden by any of the ~set_*_file~
// methods.
//
//------------------------------------------------------------------------------
class [docs]uvm_report_object extends uvm_object;
uvm_report_handler m_rh;
// Function: new
//
// Creates a new report object with the given name. This method also creates
// a new <uvm_report_handler> object to which most tasks are delegated.
function [docs]new(string name = "");
super.new(name);
m_rh = uvm_report_handler::type_id::create(name);
endfunction
//----------------------------------------------------------------------------
// Group: Reporting
//----------------------------------------------------------------------------
// Function: uvm_get_report_object
//
// Returns the nearest uvm_report_object when called. From inside a
// uvm_component, the method simply returns ~this~.
//
// See also the global version of <uvm_get_report_object>.
function uvm_report_object [docs]uvm_get_report_object();
return this;
endfunction
// Function: uvm_report_enabled
//
// Returns 1 if the configured verbosity for this severity/id is greater than
// or equal to ~verbosity~ else returns 0.
//
// See also <get_report_verbosity_level> and the global version of
// <uvm_report_enabled>.
function int [docs]uvm_report_enabled(int verbosity,
uvm_severity severity = UVM_INFO, string id = "");
if (get_report_verbosity_level(severity, id) < verbosity)
return 0;
return 1;
endfunction
// Function: uvm_report
virtual function void [docs]uvm_report( uvm_severity severity,
string id,
string message,
int verbosity = (severity == uvm_severity'(UVM_ERROR)) ? UVM_LOW :
(severity == uvm_severity'(UVM_FATAL)) ? UVM_NONE : UVM_MEDIUM,
string filename = "",
int line = 0,
string context_name = "",
bit report_enabled_checked =0);
uvm_report_message l_report_message;
if (report_enabled_checked == 0) begin
if (!uvm_report_enabled(verbosity, severity, id))
return;
end
l_report_message = uvm_report_message::new_report_message();
l_report_message.set_report_message(severity, id, message,
verbosity, filename, line, context_name);
uvm_process_report_message(l_report_message);
endfunction
// Function: uvm_report_info
virtual function void [docs]uvm_report_info( string id,
string message,
int verbosity = UVM_MEDIUM,
string filename = "",
int line = 0,
string context_name = "",
bit report_enabled_checked = 0);
uvm_report (UVM_INFO, id, message, verbosity,
filename, line, context_name, report_enabled_checked);
endfunction
// Function: uvm_report_warning
virtual function void [docs]uvm_report_warning( string id,
string message,
int verbosity = UVM_MEDIUM,
string filename = "",
int line = 0,
string context_name = "",
bit report_enabled_checked = 0);
uvm_report (UVM_WARNING, id, message, verbosity,
filename, line, context_name, report_enabled_checked);
endfunction
// Function: uvm_report_error
virtual function void [docs]uvm_report_error( string id,
string message,
int verbosity = UVM_LOW,
string filename = "",
int line = 0,
string context_name = "",
bit report_enabled_checked = 0);
uvm_report (UVM_ERROR, id, message, verbosity,
filename, line, context_name, report_enabled_checked);
endfunction
// Function: uvm_report_fatal
//
// These are the primary reporting methods in the UVM. Using these instead
// of ~$display~ and other ad hoc approaches ensures consistent output and
// central control over where output is directed and any actions that
// result. All reporting methods have the same arguments, although each has
// a different default verbosity:
//
// id - a unique id for the report or report group that can be used
// for identification and therefore targeted filtering. You can
// configure an individual report's actions and output file(s)
// using this id string.
//
// message - the message body, preformatted if necessary to a single
// string.
//
// verbosity - the verbosity of the message, indicating its relative
// importance. If this number is less than or equal to the
// effective verbosity level, see <set_report_verbosity_level>,
// then the report is issued, subject to the configured action
// and file descriptor settings. Verbosity is ignored for
// warnings, errors, and fatals. However, if a warning, error
// or fatal is demoted to an info message using the
// <uvm_report_catcher>, then the verbosity is taken into
// account.
//
// filename/line - (Optional) The location from which the report was issued.
// Use the predefined macros, `__FILE__ and `__LINE__.
// If specified, it is displayed in the output.
//
// context_name - (Optional) The string context from where the message is
// originating. This can be the %m of a module, a specific
// method, etc.
//
// report_enabled_checked - (Optional) This bit indicates whether the
// currently provided message has been checked as to whether
// the message should be processed. If it hasn't been checked,
// it will be checked inside the uvm_report function.
virtual function void [docs]uvm_report_fatal( string id,
string message,
int verbosity = UVM_NONE,
string filename = "",
int line = 0,
string context_name = "",
bit report_enabled_checked = 0);
uvm_report (UVM_FATAL, id, message, verbosity,
filename, line, context_name, report_enabled_checked);
endfunction
// Function: uvm_process_report_message
//
// This method takes a preformed uvm_report_message, populates it with
// the report object and passes it to the report handler for processing.
// It is expected to be checked for verbosity and populated.
virtual function void [docs]uvm_process_report_message(uvm_report_message report_message);
report_message.set_report_object(this);
m_rh.process_report_message(report_message);
endfunction
//----------------------------------------------------------------------------
// Group: Verbosity Configuration
//----------------------------------------------------------------------------
// Function: get_report_verbosity_level
//
// Gets the verbosity level in effect for this object. Reports issued
// with verbosity greater than this will be filtered out. The severity
// and tag arguments check if the verbosity level has been modified for
// specific severity/tag combinations.
function int [docs]get_report_verbosity_level(uvm_severity severity=UVM_INFO, string id="");
return m_rh.get_verbosity_level(severity, id);
endfunction
// Function: get_report_max_verbosity_level
//
// Gets the maximum verbosity level in effect for this report object.
// Any report from this component whose verbosity exceeds this maximum will
// be ignored.
function int [docs]get_report_max_verbosity_level();
return m_rh.m_max_verbosity_level;
endfunction
// Function: set_report_verbosity_level
//
// This method sets the maximum verbosity level for reports for this component.
// Any report from this component whose verbosity exceeds this maximum will
// be ignored.
function void [docs]set_report_verbosity_level (int verbosity_level);
m_rh.set_verbosity_level(verbosity_level);
endfunction
// Function: set_report_id_verbosity
//
function void [docs]set_report_id_verbosity (string id, int verbosity);
m_rh.set_id_verbosity(id, verbosity);
endfunction
// Function: set_report_severity_id_verbosity
//
// These methods associate the specified verbosity threshold with reports of the
// given ~severity~, ~id~, or ~severity-id~ pair. This threshold is compared with
// the verbosity originally assigned to the report to decide whether it gets
// processed. A verbosity threshold associated with a particular ~severity-id~
// pair takes precedence over a verbosity threshold associated with ~id~, which
// takes precedence over a verbosity threshold associated with a ~severity~.
//
// The ~verbosity~ argument can be any integer, but is most commonly a
// predefined <uvm_verbosity> value, <UVM_NONE>, <UVM_LOW>, <UVM_MEDIUM>,
// <UVM_HIGH>, <UVM_FULL>.
function void [docs]set_report_severity_id_verbosity (uvm_severity severity,
string id, int verbosity);
m_rh.set_severity_id_verbosity(severity, id, verbosity);
endfunction
//----------------------------------------------------------------------------
// Group: Action Configuration
//----------------------------------------------------------------------------
// Function: get_report_action
//
// Gets the action associated with reports having the given ~severity~
// and ~id~.
function int [docs]get_report_action(uvm_severity severity, string id);
return m_rh.get_action(severity,id);
endfunction
// Function: set_report_severity_action
//
function void [docs]set_report_severity_action (uvm_severity severity,
uvm_action action);
m_rh.set_severity_action(severity, action);
endfunction
// Function: set_report_id_action
//
function void [docs]set_report_id_action (string id, uvm_action action);
m_rh.set_id_action(id, action);
endfunction
// Function: set_report_severity_id_action
//
// These methods associate the specified action or actions with reports of the
// given ~severity~, ~id~, or ~severity-id~ pair. An action associated with a
// particular ~severity-id~ pair takes precedence over an action associated with
// ~id~, which takes precedence over an action associated with a ~severity~.
//
// The ~action~ argument can take the value <UVM_NO_ACTION>, or it can be a
// bitwise OR of any combination of <UVM_DISPLAY>, <UVM_LOG>, <UVM_COUNT>,
// <UVM_STOP>, <UVM_EXIT>, and <UVM_CALL_HOOK>.
function void [docs]set_report_severity_id_action (uvm_severity severity,
string id, uvm_action action);
m_rh.set_severity_id_action(severity, id, action);
endfunction
//----------------------------------------------------------------------------
// Group: File Configuration
//----------------------------------------------------------------------------
// Function: get_report_file_handle
//
// Gets the file descriptor associated with reports having the given
// ~severity~ and ~id~.
function int [docs]get_report_file_handle(uvm_severity severity, string id);
return m_rh.get_file_handle(severity,id);
endfunction
// Function: set_report_default_file
function void [docs]set_report_default_file (UVM_FILE file);
m_rh.set_default_file(file);
endfunction
// Function: set_report_id_file
function void [docs]set_report_id_file (string id, UVM_FILE file);
m_rh.set_id_file(id, file);
endfunction
// Function: set_report_severity_file
//
function void [docs]set_report_severity_file (uvm_severity severity, UVM_FILE file);
m_rh.set_severity_file(severity, file);
endfunction
// Function: set_report_severity_id_file
//
// These methods configure the report handler to direct some or all of its
// output to the given file descriptor. The ~file~ argument must be a
// multi-channel descriptor (mcd) or file id compatible with $fdisplay.
//
// A FILE descriptor can be associated with reports of
// the given ~severity~, ~id~, or ~severity-id~ pair. A FILE associated with
// a particular ~severity-id~ pair takes precedence over a FILE associated
// with ~id~, which take precedence over an a FILE associated with a
// ~severity~, which takes precedence over the default FILE descriptor.
//
// When a report is issued and its associated action has the UVM_LOG bit
// set, the report will be sent to its associated FILE descriptor.
// The user is responsible for opening and closing these files.
function void [docs]set_report_severity_id_file (uvm_severity severity, string id,
UVM_FILE file);
m_rh.set_severity_id_file(severity, id, file);
endfunction
//----------------------------------------------------------------------------
// Group: Override Configuration
//----------------------------------------------------------------------------
// Function: set_report_severity_override
//
function void [docs]set_report_severity_override(uvm_severity cur_severity,
uvm_severity new_severity);
m_rh.set_severity_override(cur_severity, new_severity);
endfunction
// Function: set_report_severity_id_override
//
// These methods provide the ability to upgrade or downgrade a message in
// terms of severity given ~severity~ and ~id~. An upgrade or downgrade for
// a specific ~id~ takes precedence over an upgrade or downgrade associated
// with a ~severity~.
function void [docs]set_report_severity_id_override(uvm_severity cur_severity,
string id,
uvm_severity new_severity);
m_rh.set_severity_id_override(cur_severity, id, new_severity);
endfunction
//----------------------------------------------------------------------------
// Group: Report Handler Configuration
//----------------------------------------------------------------------------
// Function: set_report_handler
//
// Sets the report handler, overwriting the default instance. This allows
// more than one component to share the same report handler.
function void [docs]set_report_handler(uvm_report_handler handler);
m_rh = handler;
endfunction
// Function: get_report_handler
//
// Returns the underlying report handler to which most reporting tasks
// are delegated.
function uvm_report_handler [docs]get_report_handler();
return m_rh;
endfunction
// Function: reset_report_handler
//
// Resets the underlying report handler to its default settings. This clears
// any settings made with the ~set_report_*~ methods (see below).
function void [docs]reset_report_handler;
m_rh.initialize();
endfunction
`ifndef UVM_NO_DEPRECATED
//----------------------------------------------------------------------------
// Group- Callbacks
//----------------------------------------------------------------------------
// Function- report_info_hook
//
//
virtual function bit [docs]report_info_hook(
string id, string message, int verbosity, string filename, int line);
return 1;
endfunction
// Function- report_error_hook
//
//
virtual function bit [docs]report_error_hook(
string id, string message, int verbosity, string filename, int line);
return 1;
endfunction
// Function- report_warning_hook
//
//
virtual function bit [docs]report_warning_hook(
string id, string message, int verbosity, string filename, int line);
return 1;
endfunction
// Function- report_fatal_hook
//
//
virtual function bit [docs]report_fatal_hook(
string id, string message, int verbosity, string filename, int line);
return 1;
endfunction
// Function- report_hook
//
// These hook methods can be defined in derived classes to perform additional
// actions when reports are issued. They are called only if the <UVM_CALL_HOOK>
// bit is specified in the action associated with the report. The default
// implementations return 1, which allows the report to be processed. If an
// override returns 0, then the report is not processed.
//
// First, the ~report_hook~ method is called, followed by the severity-specific
// hook (<report_info_hook>, etc.). If either hook method
// returns 0 then the report is not processed further.
virtual function bit [docs]report_hook(
string id, string message, int verbosity, string filename, int line);
return 1;
endfunction
// Function- report_header
//
// Prints version and copyright information. This information is sent to the
// command line if ~file~ is 0, or to the file descriptor ~file~ if it is not 0.
// The <uvm_root::run_test> task calls this method just before it component
// phasing begins.
//
// Use <uvm_root::report_header()>
virtual function void [docs]report_header(UVM_FILE file = 0);
uvm_root l_root;
uvm_coreservice_t cs;
cs = uvm_coreservice_t::get();
l_root = cs.get_root();
l_root.report_header(file);
endfunction
// Function- report_summarize
//
// Outputs statistical information on the reports issued by the central report
// server. This information will be sent to the command line if ~file~ is 0, or
// to the file descriptor ~file~ if it is not 0.
//
// The <run_test> method in uvm_top calls this method.
//
// Use:
// uvm_report_server rs =uvm_report_server::get_server();
// rs.report_summarize();
virtual function void [docs]report_summarize(UVM_FILE file = 0);
uvm_report_server l_rs = uvm_report_server::get_server();
l_rs.report_summarize(file);
endfunction
// Function- die
//
// This method is called by the report server if a report reaches the maximum
// quit count or has a UVM_EXIT action associated with it, e.g., as with
// fatal errors.
//
// Calls the <uvm_component::pre_abort()> method
// on the entire <uvm_component> hierarchy in a bottom-up fashion.
// It then call calls <report_summarize> and terminates the simulation
// with ~$finish~.
//
// Use:
// uvm_report_server rs =uvm_report_server::get_server();
// rs.die()
virtual function void [docs]die();
uvm_root l_root;
uvm_coreservice_t cs;
cs = uvm_coreservice_t::get();
l_root = cs.get_root();
l_root.die();
endfunction
// Function- set_report_max_quit_count
//
// Sets the maximum quit count in the report handler to ~max_count~. When the
// number of UVM_COUNT actions reaches ~max_count~, the <die> method is called.
//
// The default value of 0 indicates that there is no upper limit to the number
// of UVM_COUNT reports.
//
// Use:
// uvm_report_server rs =uvm_report_server::get_server();
// rs.set_max_quit_count()
function void [docs]set_report_max_quit_count(int max_count);
uvm_report_server l_rs = uvm_report_server::get_server();
l_rs.set_max_quit_count(max_count);
endfunction
// Function- get_report_server
//
// Returns the <uvm_report_server> instance associated with this report object.
//
// Use <uvm_report_server::get_server()>
function uvm_report_server [docs]get_report_server();
uvm_report_server l_rs = uvm_report_server::get_server();
return l_rs;
endfunction
// Function- dump_report_state
//
// This method dumps the internal state of the report handler. This includes
// information about the maximum quit count, the maximum verbosity, and the
// action and files associated with severities, ids, and (severity, id) pairs.
//
// Use:
// uvm_report_handler rh =get_report_handler();
// rh.print().
function void [docs]dump_report_state();
m_rh.dump_state();
endfunction
//----------------------------------------------------------------------------
// PRIVATE or PSUEDO-PRIVATE members
// *** Do not call directly ***
// Implementation and even existence are subject to change.
//----------------------------------------------------------------------------
protected virtual function uvm_report_object m_get_report_object();
return this;
endfunction
`endif
endclass
`endif // UVM_REPORT_CLIENT_SVH