RuntimeMessage.hpp

Go to the documentation of this file.

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 Sandia Corporation.                     */
/*  Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive   */
/*  license for use of this work by or on behalf of the U.S. Government.  */
/*  Export of this program may require a license from the                 */
/*  United States Government.                                             */
/*------------------------------------------------------------------------*/
 
#ifndef STK_UTIL_ENVIRONMENT_RUNTIMEMESSAGE_HPP
#define STK_UTIL_ENVIRONMENT_RUNTIMEMESSAGE_HPP
 
#include <iosfwd>
#include <vector>
#include <cstddef>
 
#include <stk_util/parallel/Parallel.hpp>
 
namespace stk_classic {
 
 
typedef ptrdiff_t MessageId;
// typedef std::vector<void *>::difference_type MessageId;
 
enum MessageType {
  MSG_WARNING           = 0,                    
  MSG_DOOMED            = 1,                    
  MSG_EXCEPTION         = 2,                    
  MSG_INFORMATION       = 3,                    
 
  MSG_TYPE_MASK         = 0x0FFFFFFF,           
  MSG_SYMMETRIC         = 0x80000000,           
  MSG_DEFERRED          = 0x40000000,           
  MSG_UNUSED0           = 0x20000000,
  MSG_UNUSED1           = 0x10000000
};
 
enum ThrottleGroup {
  MSG_APPLICATION       = 0,
  MSG_TIME_STEP         = 1
};
 
struct Throttle
{
  Throttle(size_t cutoff, int group)
    : m_cutoff(cutoff),
      m_group(group),
      m_count(0)
  {}
  
  size_t        m_cutoff;                       
  int           m_group;                        
  size_t        m_count;                        
};
 
struct MessageCode
{
  MessageCode(size_t throttle_cutoff = 5, int throttle_group = MSG_APPLICATION)
    : m_id(&m_id - (MessageId *) 0),
      m_throttle(throttle_cutoff, throttle_group)
  {}
 
  MessageCode(MessageId message_id, size_t throttle_cutoff, int throttle_group)
    : m_id(message_id),
      m_throttle(throttle_cutoff, throttle_group)
  {}
 
  static MessageCode    s_defaultMessageCode;   
  
  MessageId             m_id;                   
  Throttle              m_throttle;             
};
 
unsigned get_message_count(unsigned message_type);
 
void reset_message_count(unsigned message_type);
 
void set_max_message_count(unsigned message_type, unsigned max_count);
 
unsigned get_max_message_count(unsigned message_type);
 
const std::string &get_message_name(unsigned message_type);
 
void register_message_type(unsigned message_type, unsigned max_count, const char *name);
 
void reset_throttle_group(int throttle_group);
 
void report_message(const char *message, unsigned message_type, const MessageCode &message_code);
 
void add_deferred_message(int message_type, MessageId message_id, size_t throttle_cutoff, int throttle_group, const char *header, const char *aggegrate);
 
void report_deferred_messages(ParallelMachine comm);
 
void aggregate_messages(ParallelMachine comm, std::ostringstream &os, const char *separator = ", ");
 
std::ostream &operator<<(std::ostream &os, const MessageType &message_type);
 
 
} // namespace stk_classic
 
#endif // STK_UTIL_ENVIRONMENT_RUNTIMEMESSAGE_HPP