LCOV - code coverage report
Current view: top level - src - moab_mpe.h (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 15 15 100.0 %
Date: 2020-12-16 07:07:30 Functions: 6 6 100.0 %
Branches: 7 18 38.9 %

           Branch data     Line data    Source code
       1                 :            : #ifndef MOAB_MPE_H
       2                 :            : #define MOAB_MPE_H
       3                 :            : 
       4                 :            : #include "moab/MOABConfig.h"
       5                 :            : #ifdef MOAB_HAVE_LIBMPE
       6                 :            : # include "moab_mpi.h"
       7                 :            : # include "mpe.h"
       8                 :            : #else
       9                 :            : 
      10                 :            : /* Define dummy logging functions */
      11                 :            : 
      12                 :            : /* mpe_misc.h */
      13                 :            : 
      14                 :            : #define MPE_Seq_begin( A, B ) {if (A || B) {}}
      15                 :            :   
      16                 :            : #define MPE_Seq_end( A, B ) {if (A || B) {}}
      17                 :            : 
      18                 :            : #define MPE_DelTag( A, B, C, D ) ( {if (A || B || C || D) {}}, MPI_SUCCESS)
      19                 :            : #define MPE_GetTags( A, B, C, D ) (A = *C, *D = 0, if (B) {}, MPI_SUCCESS)
      20                 :            : #define MPE_ReturnTags( A, B, C ) ( {if (A || B || C) {}}, 0)
      21                 :            : #define MPE_TagsEnd() (MPI_SUCCESS)
      22                 :            : 
      23                 :            : #define MPE_IO_Stdout_to_file( A, B ) {if (A || B) {}}
      24                 :            : 
      25                 :            : #define MPE_GetHostName( A, B ) {if (A || B) {}}
      26                 :            : 
      27                 :            : #define MPI_Start_debugger()
      28                 :            : 
      29                 :            : /*
      30                 :            : #if (defined(__STDC__) || defined(__cplusplus))
      31                 :            : #define  MPE_Errors_to_dbx ( MPI_Comm *, int *, ... );
      32                 :            : #else
      33                 :            : void MPE_Errors_to_dbx ( MPI_Comm *, int *, char *, char *, int * );
      34                 :            : #endif
      35                 :            : void MPE_Errors_call_debugger ( char *, char *, char ** );
      36                 :            : void MPE_Errors_call_xdbx     ( char *, char * );
      37                 :            : void MPE_Errors_call_dbx_in_xterm ( char *, char * );
      38                 :            : void MPE_Signals_call_debugger ( void );
      39                 :            : 
      40                 :            : int  MPE_Decomp1d ( int, int, int, int *, int * );
      41                 :            : 
      42                 :            : void MPE_Comm_global_rank ( MPI_Comm, int, int * );
      43                 :            : */
      44                 :            : 
      45                 :            : /* mpe_log.h */
      46                 :            : 
      47                 :            : #define MPE_LOG_OK                0
      48                 :            : #define MPE_Log_OK                MPE_LOG_OK
      49                 :            :   /* no problems */
      50                 :            : #define MPE_LOG_LOCKED_OUT        1
      51                 :            : #define MPE_Log_LOCKED_OUT        MPE_LOG_LOCKED_OUT
      52                 :            :   /* logs are being worked on, cannot insert any new entries */
      53                 :            : #define MPE_LOG_NO_MEMORY         2
      54                 :            : #define MPE_Log_NO_MEMORY         MPE_LOG_NO_MEMORY
      55                 :            :   /* could not allocate memory for logging data */
      56                 :            : #define MPE_LOG_FILE_PROB         3
      57                 :            : #define MPE_Log_FILE_PROB         MPE_LOG_FILE_PROB
      58                 :            :   /* cound not open file for writing out the logged info */
      59                 :            : #define MPE_LOG_NOT_INITIALIZED   4
      60                 :            : #define MPE_Log_NOT_INITIALIZED   MPE_LOG_NOT_INITIALIZED
      61                 :            :   /* logging not initialized */
      62                 :            : #define MPE_LOG_PACK_FAIL         5
      63                 :            : #define MPE_Log_PACK_FAIL         MPE_LOG_PACK_FAIL
      64                 :            : 
      65                 :            : #define MPE_Init_log() (MPI_SUCCESS)
      66                 :            : #define MPE_Initialized_logging() 1
      67                 :            : 
      68                 :            : #define MPE_Describe_state( A, B, C, D ) {if (A || B || C || D) {}}
      69                 :            : #define MPE_Describe_event( A, B, C ) {if (A || B || C) {}}
      70                 :            : #define MPE_Log_get_event_number()
      71                 :            : #define MPE_Log_send( A, B, C ) {if (A || B || C) {}}
      72                 :            : #define MPE_Log_receive( A, B, C ) {if (A || B || C) {}}
      73                 :            : #define MPE_Log_event( A, B, C ) {if (A || B || C) {}}
      74                 :            : #define MPE_Start_log()
      75                 :            : #define MPE_Stop_log()
      76                 :            : #define MPE_Finish_log( A ) {if (A) {}}
      77                 :            : 
      78                 :            : #endif
      79                 :            : 
      80                 :            : #ifdef __cplusplus
      81                 :            : 
      82                 :            : namespace moab {
      83                 :            : 
      84                 :            : class MPEState {
      85                 :            : private:
      86                 :            :   int sid,eid;
      87                 :            :   bool ok;
      88                 :            : public:
      89                 :         20 :   MPEState( const char* name, const char* color = 0 )
      90                 :            :     : sid(MPE_Log_get_event_number()),
      91                 :            :       eid(MPE_Log_get_event_number()),
      92                 :         20 :       ok(true)
      93                 :            :   {
      94         [ +  - ]:         20 :     MPE_Describe_state( sid, eid, name, color ? color : "yellow" );
      95                 :         20 :   }
      96                 :            :   
      97                 :        114 :   MPEState( ) : ok(false) {}
      98                 :        156 :   bool valid() const { return ok; }
      99                 :            :   
     100                 :            :   void start( int data = 0, const char* str = 0 ) {
     101                 :            :     MPE_Log_event( sid, data, str );
     102                 :            :   }
     103                 :        224 :   void start( const char* str, int data = 0 ) {
     104                 :        224 :     MPE_Log_event( sid, data, str ); 
     105                 :        224 :   }
     106                 :        816 :   void start( const char* str, const char* str2 ) {
     107 [ +  - ][ +  - ]:        816 :     MPE_Log_event( sid, 0, (std::string(str).append(str2)).c_str() ); 
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
           [ #  #  #  # ]
     108                 :        816 :   }
     109                 :       1040 :   void end( int data = 0, const char* str = 0 ) {
     110                 :       1040 :     MPE_Log_event( eid, data, str );
     111                 :       1040 :   }
     112                 :            :   void end( const char* str, int data = 0 ) {
     113                 :            :     MPE_Log_event( eid, data, str ); 
     114                 :            :   }
     115                 :            : };
     116                 :            : 
     117                 :            : class MPEEvent {
     118                 :            : private:
     119                 :            :   int id;
     120                 :            : public:
     121                 :            :   MPEEvent( const char* name, const char* color = 0 )
     122                 :            :     : id(MPE_Log_get_event_number())
     123                 :            :   {
     124                 :            :     MPE_Describe_event( id, name, color ? color : "red" );
     125                 :            :   }
     126                 :            :   void log( int data = 0, const char* str = 0 ) {
     127                 :            :     MPE_Log_event( id, data, str );
     128                 :            :   }
     129                 :            :   void log( const char* str, int data = 0 ) {
     130                 :            :     MPE_Log_event( id, data, str ); 
     131                 :            :   }
     132                 :            : };
     133                 :            : 
     134                 :            : } /* namespace moab */
     135                 :            : 
     136                 :            : #endif /* __cplusplus */
     137                 :            : 
     138                 :            : #endif /* MOAB_MPE_H */

Generated by: LCOV version 1.11