std_lib/vmm.sv

Go to the documentation of this file.

// 
// -------------------------------------------------------------
//    Copyright 2004-2008 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.
// -------------------------------------------------------------
//

//
// If you wish to use the parameterized classes version of vmm_channel
// (requires VCS 2008.03 or later), the symbol `VMM_PARAM_CHANNEL must
//  be defined



//---------------------------------------------------------------------
// Functionality that must be provided through DPI/System tasks
//

`ifndef VMM_DPI_
`define VMM_DPI_

//
// $sformatf()
//
// SV-2008 feature that may not be available. $sformat() could be used but
// with lower performance as formatted strings would be always created even
// if never used.
//
// VCS provides a precursor called $psprintf()
//
`ifndef vmm_sformatf
`define vmm_sformatf $psprintf
`endif

//
// String-matching pseudo methods.
//
// Those are built-in VCS and may eventually be part of a revision of the
// SV standard. In the meantime, they can be provided by DPI functions or
// their functionality be disabled. These DPIs are provided by the file
// $VMM_HOME/sv/std_lib/vmm_str_dpi.c
//
// Currently, they are used in vmm_log for name and instance name matching
// and in the XVCs for command parsing and interpretation.
//


`ifdef VCS
`define vmm_str_match(str, regex) str.match(regex)
`define vmm_str_prematch(str)     str.prematch()
`define vmm_str_postmatch(str)    str.postmatch()
`define vmm_str_backref(str, n)   str.backref(n)

`else

`ifdef VMM_NO_STR_DPI

`define vmm_str_match(str, regex) 0
`define vmm_str_prematch(str)     ""
`define vmm_str_postmatch(str)    ""
`define vmm_str_backref(str, n)   ""

`else

import "DPI-C" function int vmm_str_match(input string str1, input string regex);
import "DPI-C" function string vmm_str_prematch();
import "DPI-C" function string vmm_str_postmatch();
import "DPI-C" function string vmm_str_backref(int n);

`define vmm_str_match(str, regex) vmm_str_match(str, regex)
`define vmm_str_prematch(str)     vmm_str_prematch()
`define vmm_str_postmatch(str)    vmm_str_postmatch()
`define vmm_str_backref(str, n)   vmm_str_backref(n+1)

`endif

`endif


`endif // VMM_DPI_


//
// The macros must be defined in a separate guard block to enable
// separate compilation because `define symbols are compilation symbols,
// not SV symbols that end up in the VMM package
//

`ifndef VMM_MACRO_DEFINED
`define VMM_MACRO_DEFINED
  

//---------------------------------------------------------------------
// User customization macros
//


`ifdef VMM_PRE_INCLUDE
`include `VMM_PRE_INCLUDE
`endif


`ifndef VMM_DATA
   `define VMM_DATA                 vmm_data
`endif
`ifndef VMM_DATA_NEW_ARGS
   `define VMM_DATA_NEW_ARGS
   `define VMM_DATA_NEW_EXTERN_ARGS
   `define VMM_DATA_NEW_CALL
`endif
`ifndef VMM_DATA_BASE_NEW_ARGS
   `define VMM_DATA_BASE_NEW_ARGS
   `define VMM_DATA_BASE_NEW_EXTERN_ARGS
`endif
`ifdef VMM_DATA_BASE
   `ifndef VMM_DATA_BASE_NEW_CALL
      `define VMM_DATA_BASE_NEW_CALL
   `endif
`endif
`ifndef VMM_DATA_BASE_METHODS
   `define VMM_DATA_BASE_METHODS
`endif

`ifndef VMM_CHANNEL
   `define VMM_CHANNEL                vmm_channel
`endif
`ifdef VMM_CHANNEL_BASE
   `ifndef VMM_CHANNEL_BASE_NEW_CALL
      `define VMM_CHANNEL_BASE_NEW_CALL
   `endif
`endif
`ifndef VMM_CHANNEL_BASE_METHODS
   `define VMM_CHANNEL_BASE_METHODS
`endif

`ifndef VMM_CONSENSUS
   `define VMM_CONSENSUS                vmm_consensus
`endif
`ifdef VMM_CONSENSUS_BASE
   `ifndef VMM_CONSENSUS_BASE_NEW_CALL
      `define VMM_CONSENSUS_BASE_NEW_CALL
   `endif
`endif
`ifndef VMM_CONSENSUS_BASE_METHODS
   `define VMM_CONSENSUS_BASE_METHODS
`endif

`ifndef VMM_LOG
   `define VMM_LOG                 vmm_log
`endif
`ifdef VMM_LOG_BASE
   `ifndef VMM_LOG_BASE_NEW_CALL
      `define VMM_LOG_BASE_NEW_CALL
   `endif
`endif
`ifndef VMM_LOG_BASE_METHODS
   `define VMM_LOG_BASE_METHODS
`endif

`ifndef VMM_NOTIFY
   `define VMM_NOTIFY                 vmm_notify
`endif
`ifdef VMM_NOTIFY_BASE
   `ifndef VMM_NOTIFY_BASE_NEW_CALL
      `define VMM_NOTIFY_BASE_NEW_CALL
   `endif
`endif
`ifndef VMM_NOTIFY_BASE_METHODS
   `define VMM_NOTIFY_BASE_METHODS
`endif

`ifndef VMM_XACTOR
   `define VMM_XACTOR                 vmm_xactor
`endif
`ifndef VMM_XACTOR_NEW_ARGS
   `define VMM_XACTOR_NEW_ARGS
   `define VMM_XACTOR_NEW_EXTERN_ARGS
   `define VMM_XACTOR_NEW_CALL
`endif
`ifndef VMM_XACTOR_BASE_NEW_ARGS
   `define VMM_XACTOR_BASE_NEW_ARGS
   `define VMM_XACTOR_BASE_NEW_EXTERN_ARGS
`endif
`ifdef VMM_XACTOR_BASE
   `ifndef VMM_XACTOR_BASE_NEW_CALL
      `define VMM_XACTOR_BASE_NEW_CALL
   `endif
`endif
`ifndef VMM_XACTOR_BASE_METHODS
   `define VMM_XACTOR_BASE_METHODS
`endif

`ifndef VMM_SUBENV
   `define VMM_SUBENV                 vmm_subenv
`endif
`ifndef VMM_SUBENV_NEW_ARGS
   `define VMM_SUBENV_NEW_ARGS
   `define VMM_SUBENV_NEW_EXTERN_ARGS
   `define VMM_SUBENV_NEW_CALL
`endif
`ifndef VMM_SUBENV_BASE_NEW_ARGS
   `define VMM_SUBENV_BASE_NEW_ARGS
   `define VMM_SUBENV_BASE_NEW_EXTERN_ARGS
`endif
`ifdef VMM_SUBENV_BASE
   `ifndef VMM_SUBENV_BASE_NEW_CALL
      `define VMM_SUBENV_BASE_NEW_CALL
   `endif
`endif
`ifndef VMM_SUBENV_BASE_METHODS
   `define VMM_SUBENV_BASE_METHODS
`endif

`ifndef VMM_ENV
   `define VMM_ENV                 vmm_env
`endif
`ifndef VMM_ENV_NEW_ARGS
   `define VMM_ENV_NEW_ARGS
   `define VMM_ENV_NEW_EXTERN_ARGS
   `define VMM_ENV_NEW_CALL
`endif
`ifndef VMM_ENV_BASE_NEW_ARGS
   `define VMM_ENV_BASE_NEW_ARGS
   `define VMM_ENV_BASE_NEW_EXTERN_ARGS
`endif
`ifdef VMM_ENV_BASE
   `ifndef VMM_ENV_BASE_NEW_CALL
      `define VMM_ENV_BASE_NEW_CALL
   `endif
`endif
`ifndef VMM_ENV_BASE_METHODS
   `define VMM_ENV_BASE_METHODS
`endif



//---------------------------------------------------------------------
// vmm_log ease-of-use macros
//

`define vmm_warning(log, msg)  \
do \
   if (log.start_msg(vmm_log::FAILURE_TYP, vmm_log::WARNING_SEV)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while(0)

`define vmm_error(log, msg)  \
do \
   if (log.start_msg(vmm_log::FAILURE_TYP, vmm_log::ERROR_SEV)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while (0)

`define vmm_fatal(log, msg)  \
do \
   if (log.start_msg(vmm_log::FAILURE_TYP, vmm_log::FATAL_SEV)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while (0)

//
// If it is necessary to compile-out debug messages to gain every
// milligram of performance, defining this macro will take them out.
//

`ifdef VMM_NULL_LOG_MACROS

`define vmm_trace(log, msg)
`define vmm_debug(log, msg)
`define vmm_verbose(log, msg)
`define vmm_note(log, msg)
`define vmm_report(log, msg)
`define vmm_command(log, msg)
`define vmm_protocol(log, msg)
`define vmm_transaction(log, msg)
`define vmm_cycle(log, msg)
`define vmm_user(n, log, msg)

`else

`define vmm_trace(log, msg)  \
do \
   if (log.start_msg(vmm_log::DEBUG_TYP, vmm_log::TRACE_SEV)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while (0)

`define vmm_debug(log, msg)  \
do \
   if (log.start_msg(vmm_log::DEBUG_TYP, vmm_log::DEBUG_SEV)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while (0)

`define vmm_verbose(log, msg)  \
do \
   if (log.start_msg(vmm_log::DEBUG_TYP, vmm_log::VERBOSE_SEV)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while (0)

`define vmm_note(log, msg)  \
do \
   if (log.start_msg(vmm_log::NOTE_TYP)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while (0)

`define vmm_report(log, msg)  \
do \
   if (log.start_msg(vmm_log::REPORT_TYP)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while (0)

`define vmm_command(log, msg)  \
do \
   if (log.start_msg(vmm_log::COMMAND_TYP)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while (0)

`define vmm_protocol(log, msg)  \
do \
   if (log.start_msg(vmm_log::PROTOCOL_TYP)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while (0)

`define vmm_transaction(log, msg)  \
do \
   if (log.start_msg(vmm_log::TRANSACTION_TYP)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while (0)

`define vmm_cycle(log, msg)  \
do \
   if (log.start_msg(vmm_log::CYCLE_TYP)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while (0)

`define vmm_user(n, log, msg)  \
do \
   if (log.start_msg(vmm_log::USER_TYP_``n)) begin \
      void'(log.text(msg)); \
      log.end_msg(); \
   end \
while (0)

`endif



//---------------------------------------------------------------------
// Transactor callback ease-of-invocation macro
//

`define vmm_callback(facade, call) \
 \
do foreach (this.callbacks[vmm_i]) begin \
   facade cb; \
   if (!$cast(cb, this.callbacks[vmm_i])) continue; \
 \
   cb.call; \
end while (0)



//---------------------------------------------------------------------
// Other macros
//

`include "std_lib/vmm_data_macros.sv"


`ifdef VMM_PARAM_CHANNEL

`define vmm_channel(T) typedef vmm_channel_typed#(T) T``_channel;

`else

`define vmm_channel_(T) T``_channel

`define vmm_channel(T) \
class `vmm_channel_(T) extends vmm_channel; \
 \
   function new(string name, \
                string inst, \
                int    full = 1, \
                int    empty = 0, \
                bit    fill_as_bytes = 0); \
      super.new(name, inst, full, empty, fill_as_bytes); \
   endfunction: new \
 \
   function T unput(int offset = -1); \
      $cast(unput, super.unput(offset)); \
   endfunction: unput \
 \
   task get(output T obj, input int offset = 0); \
      vmm_data o; \
      super.get(o, offset); \
      $cast(obj, o); \
   endtask: get \
 \
   task peek(output T obj, input int offset = 0); \
      vmm_data o; \
      super.peek(o, offset); \
      $cast(obj, o); \
   endtask: peek \
 \
   task activate(output T obj, input int offset = 0); \
      vmm_data o; \
      super.activate(o, offset); \
      $cast(obj, o); \
   endtask: activate \
 \
   function T active_slot(); \
      $cast(active_slot, super.active_slot()); \
   endfunction: active_slot \
 \
   function T start(); \
      $cast(start, super.start()); \
   endfunction: start \
 \
   function T complete(vmm_data status = null); \
      $cast(complete, super.complete(status)); \
   endfunction: complete \
 \
   function T remove(); \
      $cast(remove, super.remove()); \
   endfunction: remove \
 \
   task tee(output T obj); \
      vmm_data o; \
      super.tee(o); \
      $cast(obj, o); \
   endtask: tee \
 \
   function T for_each(bit reset = 0); \
      $cast(for_each, super.for_each(reset)); \
   endfunction: for_each \
endclass

`endif

`include "std_lib/vmm_atomic_gen.sv"
`include "std_lib/vmm_scenario_gen.sv"





`endif // VMM_MACRO_DEFINED


//
// Protect against multiple inclusion of this file
//
`ifndef VMM__SV
`define VMM__SV


`ifdef VMM_IN_PACKAGE


`ifdef VCS
(* _vcs_vmm_pkg = 1 *)
`endif
package vmm_std_lib;
`endif



//---------------------------------------------------------------------
// vmm_version
//

`ifdef VCS
(* _vcs_vmm_class = 1 *)
`endif
class vmm_version;
   extern function int major();
   extern function int minor();
   extern function int patch();
   extern function string vendor();

   extern function void   display(string prefix = "");
   extern function string psdisplay(string prefix = "");
   extern function void   cfdisplay(string prefix = "");
endclass: vmm_version



//---------------------------------------------------------------------
// Forward declarations
//

typedef class vmm_log;
typedef class vmm_data;
typedef class vmm_xactor;
typedef class vmm_notify;


typedef class `VMM_DATA;
`ifdef VMM_DATA_BASE
typedef class `VMM_DATA_BASE;
`endif
`ifdef VMM_CHANNEL_BASE
typedef class `VMM_CHANNEL_BASE;
`endif
`ifdef VMM_CONSENSUS_BASE
typedef class `VMM_CONSENSUS_BASE;
`endif
`ifdef VMM_LOG_BASE
typedef class `VMM_LOG_BASE;
`endif
`ifdef VMM_NOTIFY_BASE
typedef class `VMM_NOTIFY_BASE;
`endif
typedef class `VMM_XACTOR;
`ifdef VMM_XACTOR_BASE
typedef class `VMM_XACTOR_BASE;
`endif
typedef class `VMM_SUBENV;
`ifdef VMM_SUBENV_BASE
typedef class `VMM_SUBENV_BASE;
`endif
typedef class `VMM_ENV;
`ifdef VMM_ENV_BASE
typedef class `VMM_ENV_BASE;
`endif


`ifdef VMM_POST_INCLUDE
`include `VMM_POST_INCLUDE
`endif


//---------------------------------------------------------------------
// vmm_log
//

`ifdef VCS
(* _vcs_vmm_class = 1 *)
`endif
class vmm_log_format;
   extern virtual function string format_msg(string name,
                                             string inst,
                                             string msg_typ,
                                             string severity,
                                             ref string lines[$]);

   extern virtual function string continue_msg(string name,
                                               string inst,
                                               string msg_typ,
                                               string severity,
                                               ref string lines[$]);

   extern virtual function string abort_on_error(int count,
                                                 int limit);

   extern virtual function string pass_or_fail(bit    pass,
                                               string name,
                                               string inst,
                                               int    fatals,
                                               int    errors,
                                               int    warnings,
                                               int    dem_errs,
                                               int    dem_warns);
endclass: vmm_log_format


`ifdef VCS
(* vmm_callback_class, _vcs_vmm_class = 1 *)
`endif
class vmm_log_callbacks;
   virtual function void pre_abort(vmm_log log);
   endfunction

   virtual function void pre_stop(vmm_log log);
   endfunction

   virtual function void pre_debug(vmm_log log);
   endfunction
endclass: vmm_log_callbacks


typedef class vmm_log_below_iter;
typedef class vmm_log_msg;
typedef class vmm_log_modifier;
typedef class vmm_log_watchpoint;

`ifdef VCS
(* _vcs_vmm_class = 1 *)
`endif
class vmm_log
`ifdef VMM_LOG_BASE
   extends `VMM_LOG_BASE
`endif
;

   //
   // Symbolic constants shared by different contexts
   //
   typedef enum int {DEFAULT
                     = -1
                     , UNCHANGED
                     = -2
                     } symbols_e;

   //
   // Symbolic constants for message types
   //
   typedef enum int {FAILURE_TYP     = 'h0001,
                     NOTE_TYP        = 'h0002,
                     DEBUG_TYP       = 'h0004,
                     REPORT_TYP      = 'h0008,
                     NOTIFY_TYP      = 'h0010,
                     TIMING_TYP      = 'h0020,
                     XHANDLING_TYP   = 'h0040,
                     PROTOCOL_TYP    = 'h0080,
                     TRANSACTION_TYP = 'h0100,
                     COMMAND_TYP     = 'h0200,
                     CYCLE_TYP       = 'h0400,
                     USER_TYP_0      = 'h0800,
                     USER_TYP_1      = 'h1000,
                     USER_TYP_2      = 'h2000,
                     INTERNAL_TYP    = 'h4000,
                     DEFAULT_TYP     = -1,
                     ALL_TYPS        = 'hFFFF
                     } types_e;

   //
   // Symbolic values for message severity
   //
   typedef enum int {FATAL_SEV   = 'h0001,
                     ERROR_SEV   = 'h0002,
                     WARNING_SEV = 'h0004,
                     NORMAL_SEV  = 'h0008,
                     TRACE_SEV   = 'h0010,
                     DEBUG_SEV   = 'h0020,
                     VERBOSE_SEV = 'h0040,
                     HIDDEN_SEV  = 'h0080,
                     IGNORE_SEV  = 'h0100,
                     DEFAULT_SEV = -1,
                     ALL_SEVS    = 'hFFFF
                     } severities_e;

   //
   // Symbolic values for simulation handling
   //
   typedef enum int {CONTINUE         = 'h0001,
                     COUNT_ERROR      = 'h0002,
                     DEBUGGER         = 'h0004,
                     DUMP_STACK       = 'h0008,
                     STOP_PROMPT      = 'h0010,
                     ABORT_SIM        = 'h0020,
                     IGNORE           = 'h0040,
                     DEFAULT_HANDLING = -1
                     } handling_e;

   //
   // Pre-defined STDOUT in case the simulator does not already define it
   //
   typedef enum int {STDOUT = 32'h8000_0001} stdout_e;
   
   //
   // Global control parameters
   //
   static local int    error_count = 0;     // Stop when # of errs
   static local int    error_limit = 10;    // Stop when # of errs
   static local string msg_format[$];
   static local string prefix;
   
   //
   // Local control parameters
   //
   static local int dflt_lvl  = NORMAL_SEV; // Default verbosity level
   static local int force_lvl = DEFAULT_SEV; // Forced (global) verbosity level
   static local bit plus_debug;     // +vmm_log_debug was specified!

   local string  name;            // Name for this object
   local string  inst;            // Instance name for this object

   local int n_msg[*];            // # of messages, per severities 
   local int n_demoted[*];        // # of demoted messages 

   //
   // Partial message
   //
   local vmm_log_msg msg;
   local string  msg_txt[$];

   static local int    type_list[$];
   static local string type_images[*];

   static local int    sev_list[$];
   static local string sev_images[*];

   static local vmm_log_modifier modifier_cache[*];
          local int modifier_ids[$];
          local int has_text_modifiers;

   static local vmm_log_watchpoint watchpoint_cache[*];
          local int watchpoint_ids[$];

          local int enabled_typs;  // Filter if type not enableds
          local int log_lvl;       // Filter trace messages > log_lvl

   //
   // Callbacks are global to all instances
   //
   static local vmm_log_format fmt = new;
   static local int in_callbacks = 0;
   static local vmm_log_callbacks callbacks[$];

   //
   // File logging
   //
   local int fp[$];
   
   //
   // Iterator
   //
   local int             is_self;  // Trivial iterator?
   local bit             is_all;   // Trivial iterator?
   static local vmm_log  known[$]; // List of known logs

      /*local*/ vmm_log  below[$]; // Known logs below this one
   static local int      recurse_id = 0;
          local int      visited    = 0;

   static local string pattern[2];
   static local bit    is_pattern[2];
   static local int    known_idx = 0;
   static local int    recurse;
   static local vmm_log_below_iter recurse_stack[$];
   
`ifdef VMM_LOG_BASE_METHODS
   `VMM_LOG_BASE_METHODS
`endif

   extern function new(string name,
                       string inst,
                       vmm_log under = null);
      
   extern virtual function void is_above(vmm_log log);
   extern virtual function vmm_log copy(vmm_log to = null);

   extern virtual function void set_name(string name);
   extern virtual function string get_name();
   extern virtual function void set_instance(string inst);
   extern virtual function string get_instance();

   extern function void reset(string name    = "/./",
                              string inst    = "/./",
                              bit    recurse = 0);
   extern function vmm_log for_each();
   extern virtual function void list(string name     = "/./",
                                     string inst     = "/./",
                                     bit    recurse  = 0);

   extern virtual function void display(string prefix = "");
   extern virtual function string psdisplay(string prefix = "");

   extern virtual function void kill();

   //
   // Formatting
   //
   extern virtual function vmm_log_format set_format(vmm_log_format fmt);
   extern virtual function string set_typ_image(int typ, string  image);
   extern virtual function string set_sev_image(int severity, string  image);

   extern /*local*/ function string typ_image(int typ);
   extern /*local*/ function string sev_image(int severity);
   extern /*local*/ function string handling_image(int handling);
   extern local function int default_handling(int severity);
      
   extern virtual function void report(string name     = "/./",
                                       string inst     = "/./",
                                       bit    recurse  = 0);
      

   //
   // Issue messages
   //
   extern virtual function bit start_msg(int typ,
                                         int severity = DEFAULT_SEV);

   extern virtual function bit text(string msg = "");
   extern virtual function void end_msg();
   extern local function void flush_msg();

   //
   // Message management
   //
   extern virtual function void enable_types(int     typs,
                                             string  name      = "",
                                             string  inst      = "",
                                             bit     recursive = 0);
   extern virtual function void disable_types(int     typs,
                                              string  name      = "",
                                              string  inst      = "",
                                              bit     recursive = 0);
   extern virtual function int modify(string name         = "",
                                      string inst         = "",
                                      bit    recursive    = 0,
                                      int    typ          = ALL_TYPS,
                                      int    severity     = ALL_SEVS,
                                      string text         = "",
                                      int    new_typ      = UNCHANGED,
                                      int    new_severity = UNCHANGED,
                                      int    handling     = UNCHANGED);
   extern virtual function void unmodify(int    modification_id = -1,
                                         string name            = "",
                                         string inst            = "",
                                         bit    recursive       = 0);

   extern local function void promote();
   extern local function void filter();
   extern local function void notify();

   extern virtual function void set_verbosity(int    severity,
                                              string name      = "",
                                              string inst      = "",
                                              bit    recursive = 0);
   extern function int get_verbosity();

   //
   // File logging
   //
   extern virtual function void log_start(int    file,
                                          string name    = "",
                                          string inst    = "",
                                          bit    recurse = 0);
   extern virtual function void log_stop(int    file,
                                         string name    = "",
                                         string inst    = "",
                                         bit    recurse = 0);

   
   //
   // Manage error counts
   //
   extern virtual function void stop_after_n_errors(int n);
   extern virtual function int get_message_count(int    severity = ALL_SEVS,
                                                 string name     = "",
                                                 string inst     = "",
                                                 bit    recurse  = 0);

   //
   // Synchronize with messages
   //
   extern virtual task wait_for_msg(string name     = "",
                                    string inst     = "",
                                    bit    recurse  = 0,
                                    int    typs     = ALL_TYPS,
                                    int    severity = ALL_SEVS,
                                    string text     = "",
                                    logic  issued   = 1'bx,
                                    ref vmm_log_msg msg);

   extern virtual function int create_watchpoint(int    typs     = ALL_TYPS,
                                                 int    severity = ALL_SEVS,
                                                 string text     = "",
                                                 logic  issued   = 1'bx);
   extern virtual function void add_watchpoint(int    watchpoint_id,
                                               string name            = "",
                                               string inst            = "",
                                               bit    recurse         = 0);
   extern virtual function void remove_watchpoint(int    watchpoint_id = -1,
                                                  string name          = "",
                                                  string inst          = "",
                                                  bit    recurse       = 0);
   extern virtual task wait_for_watchpoint(int             watchpoint_id,
                                           ref vmm_log_msg msg);

   //
   // Callback Management
   //
   extern virtual function void prepend_callback(vmm_log_callbacks cb);
   extern virtual function void append_callback(vmm_log_callbacks cb);
   extern virtual function void unregister_callback(vmm_log_callbacks cb);


`ifdef VCS
`ifdef VCS_SMARTLOG 
   static local bit plus_sml = $test$plusargs("smartlog"); // +smartlog was specified!
   static local int unsigned sml_count = 0; // id generator for SmartLog
   local int unsigned sml_id = sml_count++; // Unique id for SmartLog
`endif
  

`endif
endclass: vmm_log


`ifdef VMM_SB_DS_IN_STDLIB
`include "sb/vmm_sb.sv"
(* _vcs_vmm_class = 1 *)
class vmm_sb_ds_registration;
   vmm_sb_ds             sb;
   bit                   is_in;
   bit                   is_out;
   vmm_sb_ds::ordering_e order;
endclass
`endif
         

//---------------------------------------------------------------------
// vmm_notify
//

`ifdef VCS
(* vmm_callback_class, _vcs_vmm_class = 1 *)
`endif
virtual class vmm_notify_callbacks;
   virtual function void indicated(vmm_data status);
   endfunction
endclass

`ifdef VCS
(* _vcs_vmm_class = 1 *)
`endif
virtual class vmm_notification;
   virtual task indicate(ref vmm_data status);
      $write("FATAL: An instance of vmm_notification::indicate() was not overloaded or super.indicate() was called\n");
      $finish;
   endtask
   virtual task reset();
      $write("FATAL: An instance of vmm_notification::reset() was not overloaded or super.reset() was called\n");
      $finish;
   endtask
endclass


typedef class vmm_notification_config;


`ifdef VCS
(* _vcs_vmm_class = 1 *)
`endif
class vmm_notify
`ifdef VMM_NOTIFY_BASE
   extends `VMM_NOTIFY_BASE
`endif
;
   `VMM_LOG log;

   typedef enum int {ONE_SHOT = 2,
                     BLAST    = 3,
                     ON_OFF   = 5
                     } sync_e;

   typedef enum bit {SOFT,
                     HARD} reset_e;
 

   local int last_notification_id = 1000000;
   local vmm_notification_config configs[*];

   extern function new(`VMM_LOG log);

`ifdef VMM_NOTIFY_BASE_METHODS
   `VMM_NOTIFY_BASE_METHODS
`endif

   extern virtual function void display(string prefix = "");
   extern virtual function string psdisplay(string prefix = "");
      
   extern virtual function vmm_notify copy(vmm_notify to = null);
   extern virtual function int configure(int notification_id = -1,
                        sync_e sync = ONE_SHOT);
   extern virtual function int is_configured(int notification_id);

   extern virtual function bit is_on(int notification_id);

   extern virtual task wait_for(int notification_id);
   extern virtual task wait_for_off(int notification_id);
      
   extern virtual function bit is_waited_for(int notification_id);
   extern virtual function void terminated(int notification_id);

   extern virtual function vmm_data status(int notification_id);
   extern virtual function time timestamp(int notification_id);
   extern virtual function void indicate(int notification_id,
                              vmm_data status = null);

   extern virtual function void set_notification(int          notification_id,
                                vmm_notification ntfy = null);
   extern virtual function vmm_notification get_notification(int notification_id);
   extern virtual function void reset(int     notification_id = -1,
                                      reset_e rst_typ         = SOFT);

   extern function void append_callback(int                  notification_id,
                                        vmm_notify_callbacks cbs);
   extern function void unregister_callback(int                  notification_id,
                                            vmm_notify_callbacks cbs);


`ifdef VMM_SB_DS_IN_STDLIB
   extern function void register_vmm_sb_ds(int                   notification_id,
                                           vmm_sb_ds             sb,
                                           vmm_sb_ds::kind_e     kind,
                                           vmm_sb_ds::ordering_e order = vmm_sb_ds::IN_ORDER);
   extern function void unregister_vmm_sb_ds(int       notification_id,
                                             vmm_sb_ds sb);
`endif

endclass


//---------------------------------------------------------------------
// vmm_data
//

`ifdef VCS
(* _vcs_vmm_class = 1 *)
`endif
class vmm_data
`ifdef VMM_DATA_BASE
   extends `VMM_DATA_BASE
`endif
;

   local `VMM_LOG log;

   int stream_id;
   int scenario_id;
   int data_id;

   `VMM_NOTIFY notify;
   typedef enum int {EXECUTE = 999_999,
                     STARTED = 999_998,
                     ENDED = 999_997
                     } notifications_e;

   extern function new(`VMM_LOG log
                       `VMM_DATA_BASE_NEW_ARGS);

`ifdef VMM_DATA_BASE_METHODS
   `VMM_DATA_BASE_METHODS
`endif

   extern function vmm_log set_log(`VMM_LOG log);
   
   extern function void display(string prefix = "");
   extern virtual function string psdisplay(string prefix = "");

   extern virtual function bit is_valid(bit silent = 1,
                                        int kind   = -1);
   extern virtual function vmm_data allocate();
   extern virtual function vmm_data copy(vmm_data to = null);
   extern virtual protected function void copy_data(vmm_data to);

   extern virtual function bit compare(       vmm_data to,
                                       output string   diff,
                                       input  int      kind = -1);

   extern virtual function int unsigned byte_size(int kind = -1);
   extern virtual function int unsigned max_byte_size(int kind = -1);
   extern virtual function int unsigned byte_pack(ref   logic [7:0]  bytes[],
                                                  input int unsigned offset = 0,
                                                  input int          kind   = -1);
   extern virtual function int unsigned byte_unpack(const ref logic [7:0] bytes[],
                                                    input int unsigned    offset = 0,
                                                    input int             len    = -1,
                                                    input int             kind   = -1);
   extern virtual function bit load(int file);
   extern virtual function void save(int file);

   //
   // Methods and members to support the short-hand macros
   //
   protected static string       __vmm_prefix;
   protected static string       __vmm_image;
   protected static vmm_data     __vmm_rhs;
   protected static int          __vmm_kind;
   protected static int          __vmm_offset;
   protected static int          __vmm_len;
   protected static bit [4095:0] __vmm_maxbits;
   protected static bit          __vmm_status;
   protected static logic  [7:0] __vmm_bytes[];
   protected static bit          __vmm_done_user;

   typedef enum {DO_PRINT   ='h001,
                 DO_COPY    ='h002,
                 DO_COMPARE ='h004,
                 DO_PACK    ='h010,
                 DO_UNPACK  ='h020,
       DO_ALL     ='hFFF} do_what_e;

   typedef enum {DO_NOCOPY      ='h001,
                 DO_REFCOPY     ='h002,
                 DO_DEEPCOPY    ='h004,
                 HOW_TO_COPY    ='h007, // OR of all DO_*COPY
                 DO_NOCOMPARE   ='h008,
                 DO_REFCOMPARE  ='h010,
                 DO_DEEPCOMPARE ='h020,
                 HOW_TO_COMPARE ='h038, // OR of all DO_*COMPARE
                 DO_NONE        ='h009, // OR of all DO_NO*
                 DO_REF         ='h012, // OR of all DO_REF*
                 DO_DEEP        ='h024, // OR of all DO_DEEP*
                 _DO_DUMMY} do_how_e;

   function void do_all(          do_what_e   what,
                              ref logic [7:0] pack[],
                        const ref logic [7:0] unpack[]);
   endfunction

   extern virtual function string do_psdisplay(string prefix = "");

   extern virtual function bit do_is_valid(bit silent = 1,
                                           int kind   = -1);
   extern virtual function vmm_data do_allocate();
   extern virtual function vmm_data do_copy(vmm_data to = null);

   extern virtual function bit do_compare(       vmm_data to,
                                          output string   diff,
                                          input  int      kind = -1);

   extern virtual function int unsigned do_byte_size(int kind = -1);
   extern virtual function int unsigned do_max_byte_size(int kind = -1);
   extern virtual function int unsigned do_byte_pack(ref   logic [7:0]  bytes[],
                                                     input int unsigned offset = 0,
                                                     input int          kind   = -1);
   extern virtual function int unsigned do_byte_unpack(const ref logic [7:0] bytes[],
                                                       input int unsigned    offset = 0,
                                                       input int             len    = -1,
                                                       input int             kind   = -1);

`ifdef VCS
   extern function int vmt_hook(vmm_xactor xactor = null,
                 vmm_data   obj    = null);

`endif
endclass: vmm_data


//---------------------------------------------------------------------
// vmm_channel
//

`ifdef VCS
(* _vcs_vmm_class = 1 *)
`endif
class vmm_channel
`ifdef VMM_CHANNEL_BASE
   extends `VMM_CHANNEL_BASE
`endif
;
   `VMM_LOG    log;
   `VMM_NOTIFY notify;

   // Predefined notifications
   typedef enum int unsigned {FULL,
                              EMPTY,
                              PUT,
                              GOT,
                              PEEKED,
                              ACTIVATED,
                              ACT_STARTED,
                              ACT_COMPLETED,
                              ACT_REMOVED,
                              LOCKED,
                              UNLOCKED} notifications_e;

   // Arguments for lock methods
   typedef enum bit [1:0] {SOURCE = 2'b01,
                           SINK   = 2'b10
                           } endpoints_e;

   typedef enum int unsigned {INACTIVE  = 0,
                              PENDING   = 1,
                              STARTED   = 2,
                              COMPLETED = 3
                              } active_status_e;

   static local bit      one_log    = $test$plusargs("vmm_channel_shared_log");
   static local `VMM_LOG shared_log = null;

   local int full    = 0;
   local int empty   = 0;
   local bit is_sunk = 0;

   local vmm_data data[$];