Subversion Repositories uart2bus_testbench

//

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

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

`define UVM_REPORT_MESSAGE_SVH

typedef class uvm_report_server;

typedef class uvm_report_handler;

typedef class uvm_root;

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

//

// CLASS: uvm_report_message_element_base

//

// Base class for report message element. Defines common interface.

//

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

virtual class uvm_report_message_element_base;

   protected uvm_action _action;

   protected string          _name;

   // Function: get_name

   //

   virtual function string get_name();

     return _name;

   endfunction

   // Function: set_name

   //

   // Get or set the name of the element

   //

   virtual function void set_name(string name);

     _name = name;

   endfunction

   // Function: get_action

   //

   virtual function uvm_action get_action();

     return _action;

   endfunction

   // Function: set_action

   //

   // Get or set the authorized action for the element

   //

   virtual function void set_action(uvm_action action);

     _action = action;

   endfunction

   function void print(uvm_printer printer);

      if (_action & (UVM_LOG | UVM_DISPLAY))

        do_print(printer);

   endfunction : print

   function void record(uvm_recorder recorder);

      if (_action & UVM_RM_RECORD)

        do_record(recorder);

   endfunction : record

   function void copy(uvm_report_message_element_base rhs);

      do_copy(rhs);

   endfunction : copy

   function uvm_report_message_element_base clone();

      return do_clone();

   endfunction : clone

   pure virtual function void do_print(uvm_printer printer);

   pure virtual function void do_record(uvm_recorder recorder);

   pure virtual function void do_copy(uvm_report_message_element_base rhs);

   pure virtual function uvm_report_message_element_base do_clone();

endclass : uvm_report_message_element_base

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

//

// CLASS: uvm_report_message_int_element

//

// Message element class for integral type

//

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

class uvm_report_message_int_element extends uvm_report_message_element_base;

   typedef uvm_report_message_int_element this_type;

   protected uvm_bitstream_t _val;

   protected int             _size;

   protected uvm_radix_enum  _radix;

   // Function: get_value

   //

   virtual function uvm_bitstream_t get_value(output int size,

                                              output uvm_radix_enum radix);

     size = _size;

     radix = _radix;

     return _val;

   endfunction

   // Function: set_value

   //

   // Get or set the value (integral type) of the element, with size and radix

   //

   virtual function void set_value(uvm_bitstream_t value,

                              int size,

                              uvm_radix_enum radix);

     _size = size;

     _radix = radix;

     _val = value;

   endfunction

   virtual function void do_print(uvm_printer printer);

      printer.print_int(_name, _val, _size, _radix);

   endfunction : do_print

   virtual function void do_record(uvm_recorder recorder);

      recorder.record_field(_name, _val, _size, _radix);

   endfunction : do_record

   virtual function void do_copy(uvm_report_message_element_base rhs);

      this_type _rhs;

      $cast(_rhs, rhs);

      _name = _rhs._name;

      _val = _rhs._val;

      _size = _rhs._size;

      _radix = _rhs._radix;

      _action = rhs._action;

   endfunction : do_copy

   virtual function uvm_report_message_element_base do_clone();

     this_type tmp = new;

     tmp.copy(this);

     return tmp;

   endfunction : do_clone

endclass : uvm_report_message_int_element

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

//

// CLASS: uvm_report_message_string_element

//

// Message element class for string type

//

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

class uvm_report_message_string_element extends uvm_report_message_element_base;

   typedef uvm_report_message_string_element this_type;

   protected string  _val;

   // Function: get_value

   //

   virtual function string get_value();

     return _val;

   endfunction

   // Function: set_value

   //

   // Get or set the value (string type) of the element

   //

   virtual function void set_value(string value);

     _val = value;

   endfunction

   virtual function void do_print(uvm_printer printer);

      printer.print_string(_name, _val);

   endfunction : do_print

   virtual function void do_record(uvm_recorder recorder);

      recorder.record_string(_name, _val);

   endfunction : do_record

   virtual function void do_copy(uvm_report_message_element_base rhs);

      this_type _rhs;

      $cast(_rhs, rhs);

      _name = _rhs._name;

      _val = _rhs._val;

      _action = rhs._action;

   endfunction : do_copy

   virtual function uvm_report_message_element_base do_clone();

     this_type tmp = new;

     tmp.copy(this);

     return tmp;

   endfunction : do_clone

endclass : uvm_report_message_string_element

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

//

// CLASS: uvm_report_message_object_element

//

// Message element class for object type

//

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

class uvm_report_message_object_element extends uvm_report_message_element_base;

   typedef uvm_report_message_object_element this_type;

   protected uvm_object _val;

   // Function: get_value

   //

   // Get the value (object reference) of the element

   //

   virtual function uvm_object get_value();

     return _val;

   endfunction

   // Function: set_value

   //

   // Get or set the value (object reference) of the element

   //

   virtual function void set_value(uvm_object value);

     _val = value;

   endfunction

   virtual function void do_print(uvm_printer printer);

      printer.print_object(_name, _val);

   endfunction : do_print

   virtual function void do_record(uvm_recorder recorder);

      recorder.record_object(_name, _val);

   endfunction : do_record

   virtual function void do_copy(uvm_report_message_element_base rhs);

      this_type _rhs;

      $cast(_rhs, rhs);

      _name = _rhs._name;

      _val = _rhs._val;

      _action = rhs._action;

   endfunction : do_copy

   virtual function uvm_report_message_element_base do_clone();

     this_type tmp = new;

     tmp.copy(this);

     return tmp;

   endfunction : do_clone

endclass : uvm_report_message_object_element

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

//

// CLASS: uvm_report_message_element_container

//

// A container used by report message to contain the dynamically added elements,

// with APIs to add and delete the elements.

//

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

class uvm_report_message_element_container extends uvm_object;

  protected uvm_report_message_element_base elements[$];

  `uvm_object_utils(uvm_report_message_element_container)

  // Function: new

  //

  // Create a new uvm_report_message_element_container object

  //

  function new(string name = "element_container");

    super.new(name);

  endfunction

  // Function: size

  //

  // Returns the size of the container, i.e. the number of elements

  //

  virtual function int size();

    return elements.size();

  endfunction

  // Function: delete

  //

  // Delete the ~index~-th element in the container

  //

  virtual function void delete(int index);

    elements.delete(index);

  endfunction

  // Function: delete_elements

  //

  // Delete all the elements in the container

  //

  virtual function void delete_elements();

    elements.delete();

  endfunction

  // Function: get_elements

  //

  // Get all the elements from the container and put them in a queue

  //

  typedef uvm_report_message_element_base queue_of_element[$];

  virtual function queue_of_element get_elements();

    return elements;

  endfunction

  // Function: add_int

  //

  // This method adds an integral type of the name ~name~ and value ~value~ to

  // the container.  The required ~size~ field indicates the size of ~value~.

  // The required ~radix~ field determines how to display and

  // record the field. The optional print/record bit is to specify whether

  // the element will be printed/recorded.

  //

  virtual function void add_int(string name, uvm_bitstream_t value,

                                int size, uvm_radix_enum radix,

                                uvm_action action = (UVM_LOG|UVM_RM_RECORD));

     process p;

     string rand_state;

     uvm_report_message_int_element urme;

     p = process::self();

     if (p != null)

       rand_state = p.get_randstate();

     urme = new();

     if (p != null)

       p.set_randstate(rand_state);

     urme.set_name(name);

     urme.set_value(value, size, radix);

     urme.set_action(action);

     elements.push_back(urme);

  endfunction

  // Function: add_string

  //

  // This method adds a string of the name ~name~ and value ~value~ to the

  // message. The optional print/record bit is to specify whether

  // the element will be printed/recorded.

  //

  virtual function void add_string(string name, string value,

                                   uvm_action action = (UVM_LOG|UVM_RM_RECORD));

     process p;

     string rand_state;

     uvm_report_message_string_element urme;

     p = process::self();

     if (p != null)

       rand_state = p.get_randstate();

     urme = new();

     if (p != null)

       p.set_randstate(rand_state);

     urme.set_name(name);

     urme.set_value(value);

     urme.set_action(action);

     elements.push_back(urme);

  endfunction

  // Function: add_object

  //

  // This method adds a uvm_object of the name ~name~ and reference ~obj~ to

  // the message. The optional print/record bit is to specify whether

  // the element will be printed/recorded.

  //

  virtual function void add_object(string name, uvm_object obj,

                                   uvm_action action = (UVM_LOG|UVM_RM_RECORD));

     process p;

     string rand_state;

     uvm_report_message_object_element urme;

     p = process::self();

     if (p != null)

       rand_state = p.get_randstate();

     urme = new();

     if (p != null)

       p.set_randstate(rand_state);

     urme.set_name(name);

     urme.set_value(obj);

     urme.set_action(action);

     elements.push_back(urme);

  endfunction

  virtual function void do_print(uvm_printer printer);

    super.do_print(printer);

    for(int i = 0; i < elements.size(); i++) begin

       elements[i].print(printer);

    end

  endfunction

  virtual function void do_record(uvm_recorder recorder);

    super.do_record(recorder);

    for(int i = 0; i < elements.size(); i++) begin

       elements[i].record(recorder);

    end

  endfunction

  virtual function void do_copy(uvm_object rhs);

    uvm_report_message_element_container urme_container;

    super.do_copy(rhs);

    if(!$cast(urme_container, rhs) || (rhs==null))

      return;

    delete_elements();

    foreach (urme_container.elements[i])

      elements.push_back(urme_container.elements[i].clone());

  endfunction

endclass

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

//

// CLASS: uvm_report_message

//

// The uvm_report_message is the basic UVM object message class.  It provides

// the fields that are common to all messages.  It also has a message element

// container and provides the APIs necessary to add integral types, strings and

// uvm_objects to the container. The report message object can be initialized

// with the common fields, and passes through the whole reporting system (i.e.

// report object, report handler, report server, report catcher, etc) as an

// object. The additional elements can be added/deleted to/from the message

// object anywhere in the reporting system, and can be printed or recorded

// along with the common fields.

//

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

class uvm_report_message extends uvm_object;

  protected uvm_report_object _report_object;

  protected uvm_report_handler _report_handler;

  protected uvm_report_server _report_server;

  protected uvm_severity _severity;

  protected string _id;

  protected string _message;

  protected int _verbosity;

  protected string _filename;

  protected int _line;

  protected string _context_name;

  protected uvm_action _action;

  protected UVM_FILE _file;

  // Not documented.

  protected uvm_report_message_element_container _report_message_element_container;

  // Function: new

  //

  // Creates a new uvm_report_message object.

  //

  function new(string name = "uvm_report_message");

    super.new(name);

    _report_message_element_container = new();

  endfunction

  // Function: new_report_message

  //

  // Creates a new uvm_report_message object.

  // This function is the same as new(), but keeps the random stability.

  //

  static function uvm_report_message new_report_message(string name = "uvm_report_message");

    process p;

    string rand_state;

    p = process::self();

    if (p != null)

      rand_state = p.get_randstate();

    new_report_message = new(name);

    if (p != null)

      p.set_randstate(rand_state);

  endfunction

  // Function: print

  //

  // The uvm_report_message implements  such that

  // ~print~ method provides UVM printer formatted output

  // of the message.  A snippet of example output is shown here:

  //

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

  //| Name                Type               Size  Value

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

  //| uvm_report_message  uvm_report_message  -     @532

  //|   severity          uvm_severity        2     UVM_INFO

  //|   id                string              10    TEST_ID

  //|   message           string              12    A message...

  //|   verbosity         uvm_verbosity       32    UVM_LOW

  //|   filename          string              7     test.sv

  //|   line              integral            32    'd58

  //|   context_name      string              0     ""

  //|   color             string              3     red

  //|   my_int            integral            32    'd5

  //|   my_string         string              3     foo

  //|   my_obj            my_class            -     @531

  //|     foo             integral            32    'd3

  //|     bar             string              8     hi there

  virtual function void do_print(uvm_printer printer);

    uvm_verbosity l_verbosity;

    super.do_print(printer);

    printer.print_generic("severity", "uvm_severity",

                          $bits(_severity), _severity.name());

    printer.print_string("id", _id);

    printer.print_string("message",_message);

    if ($cast(l_verbosity, _verbosity))

      printer.print_generic("verbosity", "uvm_verbosity",

                            $bits(l_verbosity), l_verbosity.name());

    else

      printer.print_int("verbosity", _verbosity, $bits(_verbosity), UVM_HEX);

    printer.print_string("filename", _filename);

    printer.print_int("line", _line, $bits(_line), UVM_UNSIGNED);

    printer.print_string("context_name", _context_name);

    if (_report_message_element_container.size() != 0)

      _report_message_element_container.print(printer);

  endfunction

  `uvm_object_utils(uvm_report_message)

  // do_pack() not needed

  // do_unpack() not needed

  // do_compare() not needed

  // Not documented.

  virtual function void do_copy (uvm_object rhs);

    uvm_report_message report_message;

    super.do_copy(rhs);

    if(!$cast(report_message, rhs) || (rhs==null))

      return;

    _report_object = report_message.get_report_object();

    _report_handler = report_message.get_report_handler();

    _report_server = report_message.get_report_server();

    _context_name = report_message.get_context();

    _file = report_message.get_file();

    _filename = report_message.get_filename();

    _line = report_message.get_line();

    _action = report_message.get_action();

    _severity = report_message.get_severity();

    _id = report_message.get_id();

    _message = report_message.get_message();

    _verbosity = report_message.get_verbosity();

    _report_message_element_container.copy(report_message._report_message_element_container);

  endfunction

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

  // Group:  Infrastructure References

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

  // Function: get_report_object

  virtual function uvm_report_object get_report_object();

    return _report_object;

  endfunction

  // Function: set_report_object

  //

  // Get or set the uvm_report_object that originated the message.

  virtual function void set_report_object(uvm_report_object ro);

    _report_object = ro;

  endfunction

  // Function: get_report_handler

  virtual function uvm_report_handler get_report_handler();

    return _report_handler;

  endfunction

  // Function: set_report_handler

  //

  // Get or set the uvm_report_handler that is responsible for checking

  // whether the message is enabled, should be upgraded/downgraded, etc.

  virtual function void set_report_handler(uvm_report_handler rh);

    _report_handler = rh;

  endfunction

  // Function: get_report_server

  virtual function uvm_report_server get_report_server();

    return _report_server;

  endfunction

  // Function: set_report_server

  //

  // Get or set the uvm_report_server that is responsible for servicing

  // the message's actions.

  virtual function void set_report_server(uvm_report_server rs);

    _report_server = rs;

  endfunction

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

  // Group:  Message Fields

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

  // Function: get_severity

  virtual function uvm_severity get_severity();

    return _severity;

  endfunction

  // Function: set_severity

  //

  // Get or set the severity (UVM_INFO, UVM_WARNING, UVM_ERROR or

  // UVM_FATAL) of the message.  The value of this field is determined via

  // the API used (`uvm_info(), `uvm_waring(), etc.) and populated for the user.

  virtual function void set_severity(uvm_severity sev);

    _severity = sev;

  endfunction

  // Function: get_id

  virtual function string get_id();

    return _id;

  endfunction

  // Function: set_id

  //

  // Get or set the id of the message.  The value of this field is

  // completely under user discretion.  Users are recommended to follow a

  // consistent convention.  Settings in the uvm_report_handler allow various

  // messaging controls based on this field.  See .

  virtual function void set_id(string id);

    _id = id;

  endfunction

  // Function: get_message

  virtual function string get_message();

    return _message;

  endfunction

  // Function: set_message

  //

  // Get or set the user message content string.

  virtual function void set_message(string msg);

    _message = msg;

  endfunction

  // Function: get_verbosity

  virtual function int get_verbosity();

    return _verbosity;

  endfunction

  // Function: set_verbosity

  //

  // Get or set the message threshold value.  This value is compared

  // against settings in the  to determine whether this

  // message should be executed.

  virtual function void set_verbosity(int ver);

    _verbosity = ver;

  endfunction

  // Function: get_filename

  virtual function string get_filename();

    return _filename;

  endfunction

  // Function: set_filename

  //

  // Get or set the file from which the message originates.  This value

  // is automatically populated by the messaging macros.

  virtual function void set_filename(string fname);

    _filename = fname;

  endfunction

  // Function: get_line

  virtual function int get_line();

    return _line;

  endfunction

  // Function: set_line

  //

  // Get or set the line in the ~file~ from which the message originates.

  // This value is automatically populate by the messaging macros.

  virtual function void set_line(int ln);

    _line = ln;

  endfunction

  // Function: get_context

  virtual function string get_context();

    return _context_name;

  endfunction

  // Function: set_context

  //

  // Get or set the optional user-supplied string that is meant to convey

  // the context of the message.  It can be useful in scopes that are not

  // inherently UVM like modules, interfaces, etc.

  virtual function void set_context(string cn);

    _context_name = cn;

  endfunction

  // Function: get_action

  virtual function uvm_action get_action();

    return _action;

  endfunction

  // Function: set_action

  //

  // Get or set the action(s) that the uvm_report_server should perform

  // for this message.  This field is populated by the uvm_report_handler during

  // message execution flow.

  virtual function void set_action(uvm_action act);

    _action = act;

  endfunction

  // Function: get_file

  virtual function UVM_FILE get_file();

    return _file;

  endfunction

  // Function: set_file

  //

  // Get or set the file that the message is to be written to when the

  // message's action is UVM_LOG.  This field is populated by the

  // uvm_report_handler during message execution flow.

  virtual function void set_file(UVM_FILE fl);

    _file = fl;

  endfunction

  // Function: get_element_container

  //

  // Get the element_container of the message

  virtual function uvm_report_message_element_container get_element_container();

    return _report_message_element_container;

  endfunction

  // Function: set_report_message

  //

  // Set all the common fields of the report message in one shot.

  //

  virtual function void set_report_message(uvm_severity severity,

                                           string id,

                                           string message,

                                           int verbosity,

                                           string filename,

                                           int line,

                                           string context_name);

    this._context_name = context_name;

    this._filename = filename;

    this._line = line;

    this._severity = severity;

    this._id = id;

    this._message = message;

    this._verbosity = verbosity;

  endfunction

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

  // Group-  Message Recording

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

  // Not documented.

  virtual function void m_record_message(uvm_recorder recorder);

    recorder.record_string("message", _message);

  endfunction

  // Not documented.

  virtual function void m_record_core_properties(uvm_recorder recorder);

    string l_string;

    uvm_verbosity l_verbosity;

    if (_context_name != "")

      recorder.record_string("context_name", _context_name);

    recorder.record_string("filename", _filename);

    recorder.record_field("line", _line, $bits(_line), UVM_UNSIGNED);

    recorder.record_string("severity", _severity.name());

    if ($cast(l_verbosity, _verbosity))

      recorder.record_string("verbosity", l_verbosity.name());

    else begin

      l_string.itoa(_verbosity);

      recorder.record_string("verbosity", l_string);

    end

    recorder.record_string("id", _id);

    m_record_message(recorder);

  endfunction

  // Not documented.

  virtual function void do_record(uvm_recorder recorder);

    super.do_record(recorder);

    m_record_core_properties(recorder);

    _report_message_element_container.record(recorder);

  endfunction

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

  // Group:  Message Element APIs

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

  // Function: add_int

  //

  // This method adds an integral type of the name ~name~ and value ~value~ to

  // the message.  The required ~size~ field indicates the size of ~value~.

  // The required ~radix~ field determines how to display and

  // record the field. The optional print/record bit is to specify whether

  // the element will be printed/recorded.

  //

  virtual function void add_int(string name, uvm_bitstream_t value,

                                int size, uvm_radix_enum radix,

                                uvm_action action = (UVM_LOG|UVM_RM_RECORD));

    _report_message_element_container.add_int(name, value, size, radix, action);

  endfunction

  // Function: add_string

  //

  // This method adds a string of the name ~name~ and value ~value~ to the

  // message. The optional print/record bit is to specify whether

  // the element will be printed/recorded.

  //

  virtual function void add_string(string name, string value,

                                   uvm_action action = (UVM_LOG|UVM_RM_RECORD));

    _report_message_element_container.add_string(name, value, action);

  endfunction

  // Function: add_object

  //

  // This method adds a uvm_object of the name ~name~ and reference ~obj~ to

  // the message. The optional print/record bit is to specify whether

  // the element will be printed/recorded.

  //

  virtual function void add_object(string name, uvm_object obj,

                                   uvm_action action = (UVM_LOG|UVM_RM_RECORD));

    _report_message_element_container.add_object(name, obj, action);

  endfunction

endclass

`endif