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