moab_mpe.h

Go to the documentation of this file.

#ifndef MOAB_MPE_H
#define MOAB_MPE_H
 
#include "moab/MOABConfig.h"
#ifdef MOAB_HAVE_LIBMPE
#include "moab_mpi.h"
#include "mpe.h"
#else
 
/* Define dummy logging functions */
 
/* mpe_misc.h */
 
#define MPE_Seq_begin( A, B ) \
 { \
 if( ( A ) || ( B ) ) \
 { \
 } \
 }
 
#define MPE_Seq_end( A, B ) \
 { \
 if( ( A ) || ( B ) ) \
 { \
 } \
 }
 
#define MPE_DelTag( A, B, C, D ) \
 ( \
 { \
 if( ( A ) || ( B ) || ( C ) || ( D ) ) \
 { \
 } \
 }, \
 MPI_SUCCESS )
#define MPE_GetTags( A, B, C, D ) ( ( A ) = *( C ), *( D ) = 0, if( B ){}, MPI_SUCCESS )
#define MPE_ReturnTags( A, B, C ) \
 ( \
 { \
 if( ( A ) || ( B ) || ( C ) ) \
 { \
 } \
 }, \
 0 )
#define MPE_TagsEnd() ( MPI_SUCCESS )
 
#define MPE_IO_Stdout_to_file( A, B ) \
 { \
 if( ( A ) || ( B ) ) \
 { \
 } \
 }
 
#define MPE_GetHostName( A, B ) \
 { \
 if( ( A ) || ( B ) ) \
 { \
 } \
 }
 
#define MPI_Start_debugger()
 
/*
#if (defined(__STDC__) || defined(__cplusplus))
#define MPE_Errors_to_dbx ( MPI_Comm *, int *, ... );
#else
void MPE_Errors_to_dbx ( MPI_Comm *, int *, char *, char *, int * );
#endif
void MPE_Errors_call_debugger ( char *, char *, char ** );
void MPE_Errors_call_xdbx ( char *, char * );
void MPE_Errors_call_dbx_in_xterm ( char *, char * );
void MPE_Signals_call_debugger ( void );
 
int MPE_Decomp1d ( int, int, int, int *, int * );
 
void MPE_Comm_global_rank ( MPI_Comm, int, int * );
*/
 
/* mpe_log.h */
 
#define MPE_LOG_OK 0
#define MPE_Log_OK MPE_LOG_OK
/* no problems */
#define MPE_LOG_LOCKED_OUT 1
#define MPE_Log_LOCKED_OUT MPE_LOG_LOCKED_OUT
/* logs are being worked on, cannot insert any new entries */
#define MPE_LOG_NO_MEMORY 2
#define MPE_Log_NO_MEMORY MPE_LOG_NO_MEMORY
/* could not allocate memory for logging data */
#define MPE_LOG_FILE_PROB 3
#define MPE_Log_FILE_PROB MPE_LOG_FILE_PROB
/* cound not open file for writing out the logged info */
#define MPE_LOG_NOT_INITIALIZED 4
#define MPE_Log_NOT_INITIALIZED MPE_LOG_NOT_INITIALIZED
/* logging not initialized */
#define MPE_LOG_PACK_FAIL 5
#define MPE_Log_PACK_FAIL MPE_LOG_PACK_FAIL
 
#define MPE_Init_log() ( MPI_SUCCESS )
#define MPE_Initialized_logging() 1
 
#define MPE_Describe_state( A, B, C, D ) \
 { \
 if( ( A ) || ( B ) || ( C ) || ( D ) ) \
 { \
 } \
 }
#define MPE_Describe_event( A, B, C ) \
 { \
 if( ( A ) || ( B ) || ( C ) ) \
 { \
 } \
 }
#define MPE_Log_get_event_number()
#define MPE_Log_send( A, B, C ) \
 { \
 if( ( A ) || ( B ) || ( C ) ) \
 { \
 } \
 }
#define MPE_Log_receive( A, B, C ) \
 { \
 if( ( A ) || ( B ) || ( C ) ) \
 { \
 } \
 }
#define MPE_Log_event( A, B, C ) \
 { \
 if( ( A ) || ( B ) || ( C ) ) \
 { \
 } \
 }
#define MPE_Start_log()
#define MPE_Stop_log()
#define MPE_Finish_log( A ) \
 { \
 if( A ) \
 { \
 } \
 }
 
#endif
 
#ifdef __cplusplus
 
namespace moab
{
 
class MPEState
{
 private:
 int sid, eid;
 bool ok;
 
 public:
 MPEState( const char* name, const char* color = 0 )
 : sid( MPE_Log_get_event_number() ), eid( MPE_Log_get_event_number() ), ok( true )
 {
 MPE_Describe_state( sid, eid, name, color ? color : "yellow" );
 }
 
 MPEState() : ok( false ) {}
 bool valid() const
 {
 return ok;
 }
 
 void start( int data = 0, const char* str = 0 )
 {
 MPE_Log_event( sid, data, str );
 }
 void start( const char* str, int data = 0 )
 {
 MPE_Log_event( sid, data, str );
 }
 void start( const char* str, const char* str2 )
 {
 MPE_Log_event( sid, 0, ( std::string( str ).append( str2 ) ).c_str() );
 }
 void end( int data = 0, const char* str = 0 )
 {
 MPE_Log_event( eid, data, str );
 }
 void end( const char* str, int data = 0 )
 {
 MPE_Log_event( eid, data, str );
 }
};
 
class MPEEvent
{
 private:
 int id;
 
 public:
 MPEEvent( const char* name, const char* color = 0 ) : id( MPE_Log_get_event_number() )
 {
 MPE_Describe_event( id, name, color ? color : "red" );
 }
 void log( int data = 0, const char* str = 0 )
 {
 MPE_Log_event( id, data, str );
 }
 void log( const char* str, int data = 0 )
 {
 MPE_Log_event( id, data, str );
 }
};
 
} /* namespace moab */
 
#endif /* __cplusplus */
 
#endif /* MOAB_MPE_H */