1 /* 2 Defines profile/logging in PETSc. 3 */ 4 5 #if !defined(__PetscLog_H) 6 #define __PetscLog_H 7 #include "petscsys.h" 8 9 /*MC 10 PetscLogEvent - id used to identify PETSc or user events which timed portions (blocks of executable) 11 code. 12 13 Level: intermediate 14 15 .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogEventEnd(), PetscLogStage 16 M*/ 17 typedef int PetscLogEvent; 18 19 /*MC 20 PetscLogStage - id used to identify user stages (phases, sections) of runs - for logging 21 22 Level: intermediate 23 24 .seealso: PetscLogStageRegister(), PetscLogStageBegin(), PetscLogStageEnd(), PetscLogEvent 25 M*/ 26 typedef int PetscLogStage; 27 28 #define PETSC_EVENT 1311311 29 PETSC_EXTERN PetscLogEvent PETSC_LARGEST_EVENT; 30 31 /* Global flop counter */ 32 PETSC_EXTERN PetscLogDouble petsc_TotalFlops; 33 PETSC_EXTERN PetscLogDouble petsc_tmp_flops; 34 35 /* General logging of information; different from event logging */ 36 PETSC_EXTERN PetscErrorCode PetscInfo_Private(const char[],void*,const char[],...); 37 #if defined(PETSC_USE_INFO) 38 #define PetscInfo(A,S) PetscInfo_Private(PETSC_FUNCTION_NAME,A,S) 39 #define PetscInfo1(A,S,a1) PetscInfo_Private(PETSC_FUNCTION_NAME,A,S,a1) 40 #define PetscInfo2(A,S,a1,a2) PetscInfo_Private(PETSC_FUNCTION_NAME,A,S,a1,a2) 41 #define PetscInfo3(A,S,a1,a2,a3) PetscInfo_Private(PETSC_FUNCTION_NAME,A,S,a1,a2,a3) 42 #define PetscInfo4(A,S,a1,a2,a3,a4) PetscInfo_Private(PETSC_FUNCTION_NAME,A,S,a1,a2,a3,a4) 43 #define PetscInfo5(A,S,a1,a2,a3,a4,a5) PetscInfo_Private(PETSC_FUNCTION_NAME,A,S,a1,a2,a3,a4,a5) 44 #define PetscInfo6(A,S,a1,a2,a3,a4,a5,a6) PetscInfo_Private(PETSC_FUNCTION_NAME,A,S,a1,a2,a3,a4,a5,a6) 45 #define PetscInfo7(A,S,a1,a2,a3,a4,a5,a6,a7) PetscInfo_Private(PETSC_FUNCTION_NAME,A,S,a1,a2,a3,a4,a5,a6,a7) 46 #else 47 #define PetscInfo(A,S) 0 48 #define PetscInfo1(A,S,a1) 0 49 #define PetscInfo2(A,S,a1,a2) 0 50 #define PetscInfo3(A,S,a1,a2,a3) 0 51 #define PetscInfo4(A,S,a1,a2,a3,a4) 0 52 #define PetscInfo5(A,S,a1,a2,a3,a4,a5) 0 53 #define PetscInfo6(A,S,a1,a2,a3,a4,a5,a6) 0 54 #define PetscInfo7(A,S,a1,a2,a3,a4,a5,a6,a7) 0 55 #endif 56 PETSC_EXTERN PetscErrorCode PetscInfoDeactivateClass(PetscClassId); 57 PETSC_EXTERN PetscErrorCode PetscInfoActivateClass(PetscClassId); 58 PETSC_EXTERN PetscBool PetscLogPrintInfo; /* if true, indicates PetscInfo() is turned on */ 59 60 /* We must make the following structures available to access the event 61 activation flags in the PetscLogEventBegin/End() macros. These are not part of the PETSc public 62 API and are not intended to be used by other parts of PETSc or by users. 63 64 The code that manipulates these structures is in src/sys/plog/utils. 65 */ 66 typedef struct _n_PetscIntStack *PetscIntStack; 67 68 /* 69 PetscClassRegInfo, PetscClassPerfInfo - Each class has two data structures associated with it. The first has 70 static information about it, the second collects statistics on how many objects of the class are created, 71 how much memory they use, etc. 72 73 PetscClassRegLog, PetscClassPerfLog - arrays of the PetscClassRegInfo and PetscClassPerfInfo for all classes. 74 */ 75 typedef struct { 76 char *name; /* The class name */ 77 PetscClassId classid; /* The integer identifying this class */ 78 } PetscClassRegInfo; 79 80 typedef struct { 81 PetscClassId id; /* The integer identifying this class */ 82 int creations; /* The number of objects of this class created */ 83 int destructions; /* The number of objects of this class destroyed */ 84 PetscLogDouble mem; /* The total memory allocated by objects of this class */ 85 PetscLogDouble descMem; /* The total memory allocated by descendents of these objects */ 86 } PetscClassPerfInfo; 87 88 typedef struct _n_PetscClassRegLog *PetscClassRegLog; 89 struct _n_PetscClassRegLog { 90 int numClasses; /* The number of classes registered */ 91 int maxClasses; /* The maximum number of classes */ 92 PetscClassRegInfo *classInfo; /* The structure for class information (classids are monotonicly increasing) */ 93 }; 94 95 typedef struct _n_PetscClassPerfLog *PetscClassPerfLog; 96 struct _n_PetscClassPerfLog { 97 int numClasses; /* The number of logging classes */ 98 int maxClasses; /* The maximum number of classes */ 99 PetscClassPerfInfo *classInfo; /* The structure for class information (classids are monotonicly increasing) */ 100 }; 101 /* -----------------------------------------------------------------------------------------------------*/ 102 /* 103 PetscEventRegInfo, PetscEventPerfInfo - Each event has two data structures associated with it. The first has 104 static information about it, the second collects statistics on how many times the event is used, how 105 much time it takes, etc. 106 107 PetscEventRegLog, PetscEventPerfLog - an array of all PetscEventRegInfo and PetscEventPerfInfo for all events. There is one 108 of these for each stage. 109 110 */ 111 typedef struct { 112 char *name; /* The name of this event */ 113 PetscClassId classid; /* The class the event is associated with */ 114 #if defined (PETSC_HAVE_MPE) 115 int mpe_id_begin; /* MPE IDs that define the event */ 116 int mpe_id_end; 117 #endif 118 } PetscEventRegInfo; 119 120 typedef struct { 121 int id; /* The integer identifying this event */ 122 PetscBool active; /* The flag to activate logging */ 123 PetscBool visible; /* The flag to print info in summary */ 124 int depth; /* The nesting depth of the event call */ 125 int count; /* The number of times this event was executed */ 126 PetscLogDouble flops; /* The flops used in this event */ 127 PetscLogDouble time; /* The time taken for this event */ 128 PetscLogDouble numMessages; /* The number of messages in this event */ 129 PetscLogDouble messageLength; /* The total message lengths in this event */ 130 PetscLogDouble numReductions; /* The number of reductions in this event */ 131 } PetscEventPerfInfo; 132 133 typedef struct _n_PetscEventRegLog *PetscEventRegLog; 134 struct _n_PetscEventRegLog { 135 int numEvents; /* The number of registered events */ 136 int maxEvents; /* The maximum number of events */ 137 PetscEventRegInfo *eventInfo; /* The registration information for each event */ 138 }; 139 140 typedef struct _n_PetscEventPerfLog *PetscEventPerfLog; 141 struct _n_PetscEventPerfLog { 142 int numEvents; /* The number of logging events */ 143 int maxEvents; /* The maximum number of events */ 144 PetscEventPerfInfo *eventInfo; /* The performance information for each event */ 145 }; 146 /* ------------------------------------------------------------------------------------------------------------*/ 147 /* 148 PetscStageInfo - Contains all the information about a particular stage. 149 150 PetscStageLog - An array of PetscStageInfo for each registered stage. There is a single one of these in the code. 151 */ 152 typedef struct _PetscStageInfo { 153 char *name; /* The stage name */ 154 PetscBool used; /* The stage was pushed on this processor */ 155 PetscEventPerfInfo perfInfo; /* The stage performance information */ 156 PetscEventPerfLog eventLog; /* The event information for this stage */ 157 PetscClassPerfLog classLog; /* The class information for this stage */ 158 } PetscStageInfo; 159 160 typedef struct _n_PetscStageLog *PetscStageLog; 161 PETSC_EXTERN PetscStageLog petsc_stageLog; 162 struct _n_PetscStageLog { 163 int numStages; /* The number of registered stages */ 164 int maxStages; /* The maximum number of stages */ 165 PetscIntStack stack; /* The stack for active stages */ 166 int curStage; /* The current stage (only used in macros so we don't call PetscIntStackTop) */ 167 PetscStageInfo *stageInfo; /* The information for each stage */ 168 PetscEventRegLog eventLog; /* The registered events */ 169 PetscClassRegLog classLog; /* The registered classes */ 170 }; 171 172 #if defined(PETSC_USE_LOG) /* --- Logging is turned on --------------------------------*/ 173 174 /* 175 Flop counting: We count each arithmetic operation (e.g., addition, multiplication) separately. 176 177 For the complex numbers version, note that 178 1 complex addition = 2 flops 179 1 complex multiplication = 6 flops, 180 where we define 1 flop as that for a double precision scalar. We roughly approximate 181 flop counting for complex numbers by multiplying the total flops by 4; this corresponds 182 to the assumption that we're counting mostly additions and multiplications -- and 183 roughly the same number of each. More accurate counting could be done by distinguishing 184 among the various arithmetic operations. 185 */ 186 187 #if defined(PETSC_USE_COMPLEX) 188 #define PETSC_FLOPS_PER_OP 4.0 189 #else 190 #define PETSC_FLOPS_PER_OP 1.0 191 #endif 192 193 #if defined(PETSC_USE_DEBUG) 194 #define PetscLogFlops(n) (petsc_tmp_flops = (PETSC_FLOPS_PER_OP*((PetscLogDouble)n)), ((petsc_tmp_flops < 0) ? PETSC_ERR_FLOP_COUNT : (petsc_TotalFlops += petsc_tmp_flops,0))) 195 #define PetscLogFlopsNoError(n) (petsc_TotalFlops += PETSC_FLOPS_PER_OP*((PetscLogDouble)n)) 196 #else 197 #define PetscLogFlops(n) (petsc_TotalFlops += PETSC_FLOPS_PER_OP*((PetscLogDouble)n),0) 198 #define PetscLogFlopsNoError(n) (petsc_TotalFlops += PETSC_FLOPS_PER_OP*((PetscLogDouble)n)) 199 #endif 200 201 #if defined (PETSC_HAVE_MPE) 202 #include "mpe.h" 203 PETSC_EXTERN PetscErrorCode PetscLogMPEBegin(void); 204 PETSC_EXTERN PetscErrorCode PetscLogMPEDump(const char[]); 205 PETSC_EXTERN PetscBool UseMPE; 206 #define PETSC_LOG_EVENT_MPE_BEGIN(e) \ 207 ((UseMPE && petsc_stageLog->stageInfo[petsc_stageLog->curStage].eventLog->eventInfo[e].active) ? \ 208 MPE_Log_event(petsc_stageLog->eventLog->eventInfo[e].mpe_id_begin,0,NULL) : 0) 209 210 #define PETSC_LOG_EVENT_MPE_END(e) \ 211 ((UseMPE && petsc_stageLog->stageInfo[petsc_stageLog->curStage].eventLog->eventInfo[e].active) ? \ 212 MPE_Log_event(petsc_stageLog->eventLog->eventInfo[e].mpe_id_end,0,NULL) : 0) 213 214 #else 215 #define PETSC_LOG_EVENT_MPE_BEGIN(e) 0 216 #define PETSC_LOG_EVENT_MPE_END(e) 0 217 #endif 218 219 PETSC_EXTERN PetscErrorCode (*PetscLogPLB)(PetscLogEvent,int,PetscObject,PetscObject,PetscObject,PetscObject); 220 PETSC_EXTERN PetscErrorCode (*PetscLogPLE)(PetscLogEvent,int,PetscObject,PetscObject,PetscObject,PetscObject); 221 PETSC_EXTERN PetscErrorCode (*PetscLogPHC)(PetscObject); 222 PETSC_EXTERN PetscErrorCode (*PetscLogPHD)(PetscObject); 223 224 #define PetscLogObjectParent(p,c) \ 225 (c && p && (((PetscObject)(c))->parent = (PetscObject)(p),((PetscObject)(c))->parentid = ((PetscObject)p)->id,0)) 226 227 #define PetscLogObjectParents(p,n,d) 0;{int _i; for (_i=0; _i<n; _i++) {ierr = PetscLogObjectParent(p,(d)[_i]);CHKERRQ(ierr);}} 228 #define PetscLogObjectCreate(h) ((PetscLogPHC) ? (*PetscLogPHC)((PetscObject)h) : 0) 229 #define PetscLogObjectDestroy(h) ((PetscLogPHD) ? (*PetscLogPHD)((PetscObject)h) : 0) 230 #define PetscLogObjectMemory(p,m) (((PetscObject)(p))->mem += (m),0) 231 /* Initialization functions */ 232 PETSC_EXTERN PetscErrorCode PetscLogBegin(void); 233 PETSC_EXTERN PetscErrorCode PetscLogAllBegin(void); 234 PETSC_EXTERN PetscErrorCode PetscLogTraceBegin(FILE *); 235 PETSC_EXTERN PetscErrorCode PetscLogActions(PetscBool); 236 PETSC_EXTERN PetscErrorCode PetscLogObjects(PetscBool); 237 /* General functions */ 238 PETSC_EXTERN PetscErrorCode PetscLogGetRGBColor(const char*[]); 239 PETSC_EXTERN PetscErrorCode PetscLogDestroy(void); 240 PETSC_EXTERN PetscErrorCode PetscLogSet(PetscErrorCode (*)(int, int, PetscObject, PetscObject, PetscObject, PetscObject), 241 PetscErrorCode (*)(int, int, PetscObject, PetscObject, PetscObject, PetscObject)); 242 PETSC_EXTERN PetscErrorCode PetscLogObjectState(PetscObject, const char[], ...); 243 /* Output functions */ 244 PETSC_EXTERN PetscErrorCode PetscLogView(PetscViewer); 245 PETSC_EXTERN PetscErrorCode PetscLogViewPython(PetscViewer); 246 PETSC_EXTERN PetscErrorCode PetscLogPrintDetailed(MPI_Comm, const char[]); 247 PETSC_EXTERN PetscErrorCode PetscLogDump(const char[]); 248 249 PETSC_EXTERN PetscErrorCode PetscGetFlops(PetscLogDouble *); 250 251 PETSC_EXTERN PetscErrorCode PetscLogStageRegister(const char[],PetscLogStage*); 252 PETSC_EXTERN PetscErrorCode PetscLogStagePush(PetscLogStage); 253 PETSC_EXTERN PetscErrorCode PetscLogStagePop(void); 254 PETSC_EXTERN PetscErrorCode PetscLogStageSetActive(PetscLogStage, PetscBool ); 255 PETSC_EXTERN PetscErrorCode PetscLogStageGetActive(PetscLogStage, PetscBool *); 256 PETSC_EXTERN PetscErrorCode PetscLogStageSetVisible(PetscLogStage, PetscBool ); 257 PETSC_EXTERN PetscErrorCode PetscLogStageGetVisible(PetscLogStage, PetscBool *); 258 PETSC_EXTERN PetscErrorCode PetscLogStageGetId(const char [], PetscLogStage *); 259 /* Event functions */ 260 PETSC_EXTERN PetscErrorCode PetscLogEventRegister(const char[], PetscClassId,PetscLogEvent*); 261 PETSC_EXTERN PetscErrorCode PetscLogEventActivate(PetscLogEvent); 262 PETSC_EXTERN PetscErrorCode PetscLogEventDeactivate(PetscLogEvent); 263 PETSC_EXTERN PetscErrorCode PetscLogEventSetActiveAll(PetscLogEvent, PetscBool ); 264 PETSC_EXTERN PetscErrorCode PetscLogEventActivateClass(PetscClassId); 265 PETSC_EXTERN PetscErrorCode PetscLogEventDeactivateClass(PetscClassId); 266 267 268 /* Global counters */ 269 PETSC_EXTERN PetscLogDouble petsc_irecv_ct; 270 PETSC_EXTERN PetscLogDouble petsc_isend_ct; 271 PETSC_EXTERN PetscLogDouble petsc_recv_ct; 272 PETSC_EXTERN PetscLogDouble petsc_send_ct; 273 PETSC_EXTERN PetscLogDouble petsc_irecv_len; 274 PETSC_EXTERN PetscLogDouble petsc_isend_len; 275 PETSC_EXTERN PetscLogDouble petsc_recv_len; 276 PETSC_EXTERN PetscLogDouble petsc_send_len; 277 PETSC_EXTERN PetscLogDouble petsc_allreduce_ct; 278 PETSC_EXTERN PetscLogDouble petsc_gather_ct; 279 PETSC_EXTERN PetscLogDouble petsc_scatter_ct; 280 PETSC_EXTERN PetscLogDouble petsc_wait_ct; 281 PETSC_EXTERN PetscLogDouble petsc_wait_any_ct; 282 PETSC_EXTERN PetscLogDouble petsc_wait_all_ct; 283 PETSC_EXTERN PetscLogDouble petsc_sum_of_waits_ct; 284 285 #define PetscLogEventBarrierBegin(e,o1,o2,o3,o4,cm) \ 286 (((PetscLogPLB && petsc_stageLog->stageInfo[petsc_stageLog->curStage].perfInfo.active && petsc_stageLog->stageInfo[petsc_stageLog->curStage].eventLog->eventInfo[e].active) ? \ 287 (PetscLogEventBegin((e),o1,o2,o3,o4) || MPI_Barrier(cm) || PetscLogEventEnd((e),o1,o2,o3,o4)) : 0 ) || \ 288 PetscLogEventBegin((e)+1,o1,o2,o3,o4)) 289 290 #define PetscLogEventBegin(e,o1,o2,o3,o4) \ 291 (((PetscLogPLB && petsc_stageLog->stageInfo[petsc_stageLog->curStage].perfInfo.active && petsc_stageLog->stageInfo[petsc_stageLog->curStage].eventLog->eventInfo[e].active) ? \ 292 (*PetscLogPLB)((e),0,(PetscObject)(o1),(PetscObject)(o2),(PetscObject)(o3),(PetscObject)(o4)) : 0 ) || \ 293 PETSC_LOG_EVENT_MPE_BEGIN(e)) 294 295 #define PetscLogEventBarrierEnd(e,o1,o2,o3,o4,cm) PetscLogEventEnd(e+1,o1,o2,o3,o4) 296 297 #define PetscLogEventEnd(e,o1,o2,o3,o4) \ 298 (((PetscLogPLE && petsc_stageLog->stageInfo[petsc_stageLog->curStage].perfInfo.active && petsc_stageLog->stageInfo[petsc_stageLog->curStage].eventLog->eventInfo[e].active) ? \ 299 (*PetscLogPLE)((e),0,(PetscObject)(o1),(PetscObject)(o2),(PetscObject)(o3),(PetscObject)(o4)) : 0 ) || \ 300 PETSC_LOG_EVENT_MPE_END(e)) 301 302 PETSC_EXTERN PetscErrorCode PetscLogEventGetFlops(PetscLogEvent, PetscLogDouble*); 303 PETSC_EXTERN PetscErrorCode PetscLogEventZeroFlops(PetscLogEvent); 304 305 /* 306 These are used internally in the PETSc routines to keep a count of MPI messages and 307 their sizes. 308 309 This does not work for MPI-Uni because our include/mpiuni/mpi.h file 310 uses macros to defined the MPI operations. 311 312 It does not work correctly from HP-UX because it processes the 313 macros in a way that sometimes it double counts, hence 314 PETSC_HAVE_BROKEN_RECURSIVE_MACRO 315 316 It does not work with Windows because winmpich lacks MPI_Type_size() 317 */ 318 #if !defined(__MPIUNI_H) && !defined(PETSC_HAVE_BROKEN_RECURSIVE_MACRO) && !defined (PETSC_HAVE_MPI_MISSING_TYPESIZE) 319 /* 320 Logging of MPI activities 321 */ 322 PETSC_STATIC_INLINE PetscErrorCode PetscMPITypeSize(PetscLogDouble *buff,PetscMPIInt count,MPI_Datatype type) 323 { 324 PetscMPIInt mysize; return (MPI_Type_size(type,&mysize) || ((*buff += (PetscLogDouble) (count*mysize)),0)); 325 } 326 327 PETSC_STATIC_INLINE PetscErrorCode PetscMPITypeSizeComm(MPI_Comm comm, PetscLogDouble *buff,PetscMPIInt *counts,MPI_Datatype type) 328 { 329 PetscMPIInt mysize, commsize, p; 330 PetscErrorCode _myierr; 331 332 _myierr = MPI_Comm_size(comm,&commsize);CHKERRQ(_myierr); 333 _myierr = MPI_Type_size(type,&mysize);CHKERRQ(_myierr); 334 for(p = 0; p < commsize; ++p) { 335 *buff += (PetscLogDouble) (counts[p]*mysize); 336 } 337 return 0; 338 } 339 340 #define MPI_Irecv(buf,count,datatype,source,tag,comm,request) \ 341 ((petsc_irecv_ct++,0) || PetscMPITypeSize(&petsc_irecv_len,count,datatype) || MPI_Irecv(buf,count,datatype,source,tag,comm,request)) 342 343 #define MPI_Isend(buf,count,datatype,dest,tag,comm,request) \ 344 ((petsc_isend_ct++,0) || PetscMPITypeSize(&petsc_isend_len,count,datatype) || MPI_Isend(buf,count,datatype,dest,tag,comm,request)) 345 346 #define MPI_Startall_irecv(count,number,requests) \ 347 ((petsc_irecv_ct += (PetscLogDouble)(number),0) || PetscMPITypeSize(&petsc_irecv_len,count,MPIU_SCALAR) || MPI_Startall(number,requests)) 348 349 #define MPI_Startall_isend(count,number,requests) \ 350 ((petsc_isend_ct += (PetscLogDouble)(number),0) || PetscMPITypeSize(&petsc_isend_len,count,MPIU_SCALAR) || MPI_Startall(number,requests)) 351 352 #define MPI_Start_isend(count,requests) \ 353 ((petsc_isend_ct++,0) || PetscMPITypeSize(&petsc_isend_len,count,MPIU_SCALAR) || MPI_Start(requests)) 354 355 #define MPI_Recv(buf,count,datatype,source,tag,comm,status) \ 356 ((petsc_recv_ct++,0) || PetscMPITypeSize(&petsc_recv_len,count,datatype) || MPI_Recv(buf,count,datatype,source,tag,comm,status)) 357 358 #define MPI_Send(buf,count,datatype,dest,tag,comm) \ 359 ((petsc_send_ct++,0) || PetscMPITypeSize(&petsc_send_len,count,datatype) || MPI_Send(buf,count,datatype,dest,tag,comm)) 360 361 #define MPI_Wait(request,status) \ 362 ((petsc_wait_ct++,petsc_sum_of_waits_ct++,0) || MPI_Wait(request,status)) 363 364 #define MPI_Waitany(a,b,c,d) \ 365 ((petsc_wait_any_ct++,petsc_sum_of_waits_ct++,0) || MPI_Waitany(a,b,c,d)) 366 367 #define MPI_Waitall(count,array_of_requests,array_of_statuses) \ 368 ((petsc_wait_all_ct++,petsc_sum_of_waits_ct += (PetscLogDouble) (count),0) || MPI_Waitall(count,array_of_requests,array_of_statuses)) 369 370 #define MPI_Allreduce(sendbuf,recvbuf,count,datatype,op,comm) \ 371 ((petsc_allreduce_ct++,0) || MPI_Allreduce(sendbuf,recvbuf,count,datatype,op,comm)) 372 373 #define MPI_Alltoall(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,comm) \ 374 ((petsc_allreduce_ct++,0) || PetscMPITypeSize(&petsc_send_len,sendcount,sendtype) || MPI_Alltoall(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,comm)) 375 376 #define MPI_Alltoallv(sendbuf,sendcnts,sdispls,sendtype,recvbuf,recvcnts,rdispls,recvtype,comm) \ 377 ((petsc_allreduce_ct++,0) || PetscMPITypeSizeComm(comm,&petsc_send_len,sendcnts,sendtype) || MPI_Alltoallv(sendbuf,sendcnts,sdispls,sendtype,recvbuf,recvcnts,rdispls,recvtype,comm)) 378 379 #define MPI_Allgather(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,comm) \ 380 ((petsc_gather_ct++,0) || MPI_Allgather(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,comm)) 381 382 #define MPI_Allgatherv(sendbuf,sendcount,sendtype,recvbuf,recvcount,displs,recvtype,comm) \ 383 ((petsc_gather_ct++,0) || MPI_Allgatherv(sendbuf,sendcount,sendtype,recvbuf,recvcount,displs,recvtype,comm)) 384 385 #define MPI_Gather(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,root,comm) \ 386 ((petsc_gather_ct++,0) || PetscMPITypeSize(&petsc_send_len,sendcount,sendtype) || MPI_Gather(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,root,comm)) 387 388 #define MPI_Gatherv(sendbuf,sendcount,sendtype,recvbuf,recvcount,displs,recvtype,root,comm) \ 389 ((petsc_gather_ct++,0) || PetscMPITypeSize(&petsc_send_len,sendcount,sendtype) || MPI_Gatherv(sendbuf,sendcount,sendtype,recvbuf,recvcount,displs,recvtype,root,comm)) 390 391 #define MPI_Scatter(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,root,comm) \ 392 ((petsc_scatter_ct++,0) || PetscMPITypeSize(&petsc_recv_len,recvcount,recvtype) || MPI_Scatter(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,root,comm)) 393 394 #define MPI_Scatterv(sendbuf,sendcount,displs,sendtype,recvbuf,recvcount,recvtype,root,comm) \ 395 ((petsc_scatter_ct++,0) || PetscMPITypeSize(&petsc_recv_len,recvcount,recvtype) || MPI_Scatterv(sendbuf,sendcount,displs,sendtype,recvbuf,recvcount,recvtype,root,comm)) 396 397 #else 398 399 #define MPI_Startall_irecv(count,number,requests) \ 400 (MPI_Startall(number,requests)) 401 402 #define MPI_Startall_isend(count,number,requests) \ 403 (MPI_Startall(number,requests)) 404 405 #define MPI_Start_isend(count,requests) \ 406 (MPI_Start(requests)) 407 408 #endif /* !__MPIUNI_H && ! PETSC_HAVE_BROKEN_RECURSIVE_MACRO */ 409 410 #else /* ---Logging is turned off --------------------------------------------*/ 411 412 #define PetscLogFlops(n) 0 413 #define PetscLogFlopsNoError(n) 414 415 /* 416 With logging turned off, then MPE has to be turned off 417 */ 418 #define PetscLogMPEBegin() 0 419 #define PetscLogMPEDump(a) 0 420 421 #define PetscLogEventActivate(a) 0 422 #define PetscLogEventDeactivate(a) 0 423 424 #define PetscLogEventActivateClass(a) 0 425 #define PetscLogEventDeactivateClass(a) 0 426 #define PetscLogEventSetActiveAll(a,b) 0 427 428 #define PetscLogPLB 0 429 #define PetscLogPLE 0 430 #define PetscLogPHC 0 431 #define PetscLogPHD 0 432 #define PetscGetFlops(a) (*(a) = 0.0,0) 433 #define PetscLogEventBegin(e,o1,o2,o3,o4) 0 434 #define PetscLogEventEnd(e,o1,o2,o3,o4) 0 435 #define PetscLogEventBarrierBegin(e,o1,o2,o3,o4,cm) 0 436 #define PetscLogEventBarrierEnd(e,o1,o2,o3,o4,cm) 0 437 #define PetscLogObjectParent(p,c) 0 438 #define PetscLogObjectParents(p,n,c) 0 439 #define PetscLogObjectCreate(h) 0 440 #define PetscLogObjectDestroy(h) 0 441 #define PetscLogObjectMemory(p,m) 0 442 #define PetscLogDestroy() 0 443 #define PetscLogStagePush(a) 0 444 #define PetscLogStagePop() 0 445 #define PetscLogStageRegister(a,b) 0 446 #define PetscLogStagePrint(a,flg) 0 447 #define PetscLogView(viewer) 0 448 #define PetscLogViewPython(viewer) 0 449 #define PetscLogPrintDetailed(comm,file) 0 450 #define PetscLogBegin() 0 451 #define PetscLogTraceBegin(file) 0 452 #define PetscLogSet(lb,le) 0 453 #define PetscLogAllBegin() 0 454 #define PetscLogDump(c) 0 455 #define PetscLogEventRegister(a,b,c) 0 456 #define PetscLogObjects(a) 0 457 #define PetscLogActions(a) 0 458 PETSC_EXTERN PetscErrorCode PetscLogObjectState(PetscObject,const char[],...); 459 460 /* If PETSC_USE_LOG is NOT defined, these still need to be! */ 461 #define MPI_Startall_irecv(count,number,requests) MPI_Startall(number,requests) 462 #define MPI_Startall_isend(count,number,requests) MPI_Startall(number,requests) 463 #define MPI_Start_isend(count,requests) MPI_Start(requests) 464 #define PetscLogStageGetId(a,b) (*(b)=0,0) 465 #define PetscLogStageSetActive(a,b) 0 466 #define PetscLogStageGetActive(a,b) 0 467 #define PetscLogStageGetVisible(a,b) 0 468 #define PetscLogStageSetVisible(a,b) 0 469 470 #endif /* PETSC_USE_LOG */ 471 472 PETSC_EXTERN PetscErrorCode PetscIntStackCreate(PetscIntStack *); 473 PETSC_EXTERN PetscErrorCode PetscIntStackDestroy(PetscIntStack); 474 PETSC_EXTERN PetscErrorCode PetscIntStackPush(PetscIntStack, int); 475 PETSC_EXTERN PetscErrorCode PetscIntStackPop(PetscIntStack, int *); 476 PETSC_EXTERN PetscErrorCode PetscIntStackTop(PetscIntStack, int *); 477 PETSC_EXTERN PetscErrorCode PetscIntStackEmpty(PetscIntStack, PetscBool *); 478 479 #undef __FUNCT__ 480 #define __FUNCT__ "PetscLogGetStageLog" 481 /*@C 482 PetscLogGetStageLog - This function returns the default stage logging object. 483 484 Not collective 485 486 Output Parameter: 487 . stageLog - The default PetscStageLog 488 489 Level: developer 490 491 Developer Notes: Inline since called for EACH PetscEventLogBeginDefault() and PetscEventLogEndDefault() 492 493 .keywords: log, stage 494 .seealso: PetscStageLogCreate() 495 @*/ 496 PETSC_STATIC_INLINE PetscErrorCode PetscLogGetStageLog(PetscStageLog *stageLog) 497 { 498 PetscFunctionBegin; 499 PetscValidPointer(stageLog,1); 500 if (!petsc_stageLog) { 501 fprintf(stderr, "PETSC ERROR: Logging has not been enabled.\nYou might have forgotten to call PetscInitialize().\n"); 502 MPI_Abort(MPI_COMM_WORLD, PETSC_ERR_SUP); 503 } 504 *stageLog = petsc_stageLog; 505 PetscFunctionReturn(0); 506 } 507 508 #undef __FUNCT__ 509 #define __FUNCT__ "PetscStageLogGetCurrent" 510 /*@C 511 PetscStageLogGetCurrent - This function returns the stage from the top of the stack. 512 513 Not Collective 514 515 Input Parameter: 516 . stageLog - The PetscStageLog 517 518 Output Parameter: 519 . stage - The current stage 520 521 Notes: 522 If no stage is currently active, stage is set to -1. 523 524 Level: developer 525 526 Developer Notes: Inline since called for EACH PetscEventLogBeginDefault() and PetscEventLogEndDefault() 527 528 .keywords: log, stage 529 .seealso: PetscStageLogPush(), PetscStageLogPop(), PetscLogGetStageLog() 530 @*/ 531 PETSC_STATIC_INLINE PetscErrorCode PetscStageLogGetCurrent(PetscStageLog stageLog, int *stage) 532 { 533 PetscBool empty; 534 PetscErrorCode ierr; 535 536 PetscFunctionBegin; 537 ierr = PetscIntStackEmpty(stageLog->stack, &empty);CHKERRQ(ierr); 538 if (empty) { 539 *stage = -1; 540 } else { 541 ierr = PetscIntStackTop(stageLog->stack, stage);CHKERRQ(ierr); 542 } 543 #ifdef PETSC_USE_DEBUG 544 if (*stage != stageLog->curStage) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_PLIB, "Inconsistency in stage log: stage %d should be %d", *stage, stageLog->curStage); 545 #endif 546 PetscFunctionReturn(0); 547 } 548 549 #undef __FUNCT__ 550 #define __FUNCT__ "PetscStageLogGetEventPerfLog" 551 /*@C 552 PetscStageLogGetEventPerfLog - This function returns the PetscEventPerfLog for the given stage. 553 554 Not Collective 555 556 Input Parameters: 557 + stageLog - The PetscStageLog 558 - stage - The stage 559 560 Output Parameter: 561 . eventLog - The PetscEventPerfLog 562 563 Level: developer 564 565 Developer Notes: Inline since called for EACH PetscEventLogBeginDefault() and PetscEventLogEndDefault() 566 567 .keywords: log, stage 568 .seealso: PetscStageLogPush(), PetscStageLogPop(), PetscLogGetStageLog() 569 @*/ 570 PETSC_STATIC_INLINE PetscErrorCode PetscStageLogGetEventPerfLog(PetscStageLog stageLog, int stage, PetscEventPerfLog *eventLog) 571 { 572 PetscFunctionBegin; 573 PetscValidPointer(eventLog,3); 574 if ((stage < 0) || (stage >= stageLog->numStages)) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages); 575 *eventLog = stageLog->stageInfo[stage].eventLog; 576 PetscFunctionReturn(0); 577 } 578 579 /* Special support for C++ */ 580 #if defined(PETSC_CLANGUAGE_CXX) && !defined(PETSC_USE_EXTERN_CXX) 581 #include <petsclog.hh> 582 #endif 583 584 #define PetscPreLoadBegin(flag,name) \ 585 do {\ 586 PetscBool PetscPreLoading = flag;\ 587 int PetscPreLoadMax,PetscPreLoadIt;\ 588 PetscLogStage _stageNum;\ 589 PetscErrorCode _3_ierr; \ 590 _3_ierr = PetscOptionsGetBool(PETSC_NULL,"-preload",&PetscPreLoading,PETSC_NULL);CHKERRQ(_3_ierr);\ 591 PetscPreLoadMax = (int)(PetscPreLoading);\ 592 PetscPreLoadingUsed = PetscPreLoading ? PETSC_TRUE : PetscPreLoadingUsed;\ 593 for (PetscPreLoadIt=0; PetscPreLoadIt<=PetscPreLoadMax; PetscPreLoadIt++) {\ 594 PetscPreLoadingOn = PetscPreLoading;\ 595 _3_ierr = PetscBarrier(PETSC_NULL);CHKERRQ(_3_ierr);\ 596 if (PetscPreLoadIt>0) {\ 597 _3_ierr = PetscLogStageGetId(name,&_stageNum);CHKERRQ(_3_ierr);\ 598 } else {\ 599 _3_ierr = PetscLogStageRegister(name,&_stageNum);CHKERRQ(_3_ierr); \ 600 }\ 601 _3_ierr = PetscLogStageSetActive(_stageNum,(PetscBool)(!PetscPreLoadMax || PetscPreLoadIt));\ 602 _3_ierr = PetscLogStagePush(_stageNum);CHKERRQ(_3_ierr); 603 604 #define PetscPreLoadEnd() \ 605 _3_ierr = PetscLogStagePop();CHKERRQ(_3_ierr);\ 606 PetscPreLoading = PETSC_FALSE;\ 607 }\ 608 } while (0) 609 610 #define PetscPreLoadStage(name) do { \ 611 _3_ierr = PetscLogStagePop();CHKERRQ(_3_ierr); \ 612 if (PetscPreLoadIt>0) { \ 613 _3_ierr = PetscLogStageGetId(name,&_stageNum);CHKERRQ(_3_ierr); \ 614 } else { \ 615 _3_ierr = PetscLogStageRegister(name,&_stageNum);CHKERRQ(_3_ierr); \ 616 } \ 617 _3_ierr = PetscLogStageSetActive(_stageNum,(PetscBool)(!PetscPreLoadMax || PetscPreLoadIt)); \ 618 _3_ierr = PetscLogStagePush(_stageNum);CHKERRQ(_3_ierr); \ 619 } while (0) 620 621 #endif 622