1 /* 2 Defines profile/logging in PETSc. 3 */ 4 5 #if !defined(PETSCLOG_H) 6 #define PETSCLOG_H 7 #include <petscsys.h> 8 #include <petsctime.h> 9 10 /* General logging of information; different from event logging */ 11 PETSC_EXTERN PetscErrorCode PetscInfo_Private(const char[],PetscObject,const char[],...); 12 #if defined(PETSC_USE_INFO) 13 #define PetscInfo(A,S) PetscInfo_Private(PETSC_FUNCTION_NAME,((PetscObject)A),S) 14 #define PetscInfo1(A,S,a1) PetscInfo_Private(PETSC_FUNCTION_NAME,((PetscObject)A),S,a1) 15 #define PetscInfo2(A,S,a1,a2) PetscInfo_Private(PETSC_FUNCTION_NAME,((PetscObject)A),S,a1,a2) 16 #define PetscInfo3(A,S,a1,a2,a3) PetscInfo_Private(PETSC_FUNCTION_NAME,((PetscObject)A),S,a1,a2,a3) 17 #define PetscInfo4(A,S,a1,a2,a3,a4) PetscInfo_Private(PETSC_FUNCTION_NAME,((PetscObject)A),S,a1,a2,a3,a4) 18 #define PetscInfo5(A,S,a1,a2,a3,a4,a5) PetscInfo_Private(PETSC_FUNCTION_NAME,((PetscObject)A),S,a1,a2,a3,a4,a5) 19 #define PetscInfo6(A,S,a1,a2,a3,a4,a5,a6) PetscInfo_Private(PETSC_FUNCTION_NAME,((PetscObject)A),S,a1,a2,a3,a4,a5,a6) 20 #define PetscInfo7(A,S,a1,a2,a3,a4,a5,a6,a7) PetscInfo_Private(PETSC_FUNCTION_NAME,((PetscObject)A),S,a1,a2,a3,a4,a5,a6,a7) 21 #else 22 #define PetscInfo(A,S) 0 23 #define PetscInfo1(A,S,a1) 0 24 #define PetscInfo2(A,S,a1,a2) 0 25 #define PetscInfo3(A,S,a1,a2,a3) 0 26 #define PetscInfo4(A,S,a1,a2,a3,a4) 0 27 #define PetscInfo5(A,S,a1,a2,a3,a4,a5) 0 28 #define PetscInfo6(A,S,a1,a2,a3,a4,a5,a6) 0 29 #define PetscInfo7(A,S,a1,a2,a3,a4,a5,a6,a7) 0 30 #endif 31 32 /*E 33 PetscInfoCommFlag - Describes the method by which to filter PetscInfo() by communicator size 34 35 Used as an input for PetscInfoSetFilterCommSelf() 36 37 $ PETSC_INFO_COMM_ALL - Default uninitialized value. PetscInfo() will not filter based on communicator size (i.e. will 38 print for all communicators) 39 $ PETSC_INFO_COMM_NO_SELF - PetscInfo() will NOT print for communicators with size = 1 (i.e. *_COMM_SELF) 40 $ PETSC_INFO_COMM_ONLY_SELF - PetscInfo will ONLY print for communicators with size = 1 41 42 Level: intermediate 43 44 .seealso: PetscInfo(), PetscInfoSetFromOptions(), PetscInfoSetFilterCommSelf() 45 E*/ 46 typedef enum { 47 PETSC_INFO_COMM_ALL = -1, 48 PETSC_INFO_COMM_NO_SELF = 0, 49 PETSC_INFO_COMM_ONLY_SELF = 1 50 } PetscInfoCommFlag; 51 52 PETSC_EXTERN const char * const PetscInfoCommFlags[]; 53 PETSC_EXTERN PetscErrorCode PetscInfoDeactivateClass(PetscClassId); 54 PETSC_EXTERN PetscErrorCode PetscInfoActivateClass(PetscClassId); 55 PETSC_EXTERN PetscErrorCode PetscInfoEnabled(PetscClassId, PetscBool *); 56 PETSC_EXTERN PetscErrorCode PetscInfoAllow(PetscBool); 57 PETSC_EXTERN PetscErrorCode PetscInfoSetFile(const char[],const char[]); 58 PETSC_EXTERN PetscErrorCode PetscInfoGetFile(char **,FILE **); 59 PETSC_EXTERN PetscErrorCode PetscInfoSetClasses(PetscBool,PetscInt,const char *const *); 60 PETSC_EXTERN PetscErrorCode PetscInfoGetClass(const char *, PetscBool *); 61 PETSC_EXTERN PetscErrorCode PetscInfoGetInfo(PetscBool *,PetscBool *,PetscBool *,PetscBool *,PetscInfoCommFlag *); 62 PETSC_EXTERN PetscErrorCode PetscInfoProcessClass(const char[],PetscInt,PetscClassId[]); 63 PETSC_EXTERN PetscErrorCode PetscInfoSetFilterCommSelf(PetscInfoCommFlag); 64 PETSC_EXTERN PetscErrorCode PetscInfoSetFromOptions(PetscOptions); 65 PETSC_EXTERN PetscErrorCode PetscInfoDestroy(void); 66 PETSC_EXTERN PetscBool PetscLogPrintInfo; /* if true, indicates PetscInfo() is turned on */ 67 68 /*MC 69 PetscLogEvent - id used to identify PETSc or user events which timed portions (blocks of executable) 70 code. 71 72 Level: intermediate 73 74 .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogEventEnd(), PetscLogStage 75 M*/ 76 typedef int PetscLogEvent; 77 78 /*MC 79 PetscLogStage - id used to identify user stages (phases, sections) of runs - for logging 80 81 Level: intermediate 82 83 .seealso: PetscLogStageRegister(), PetscLogStagePush(), PetscLogStagePop(), PetscLogEvent 84 M*/ 85 typedef int PetscLogStage; 86 87 #define PETSC_EVENT 1311311 88 PETSC_EXTERN PetscLogEvent PETSC_LARGEST_EVENT; 89 90 /* Global flop counter */ 91 PETSC_EXTERN PetscLogDouble petsc_TotalFlops; 92 PETSC_EXTERN PetscLogDouble petsc_tmp_flops; 93 94 /* We must make the following structures available to access the event 95 activation flags in the PetscLogEventBegin/End() macros. These are not part of the PETSc public 96 API and are not intended to be used by other parts of PETSc or by users. 97 98 The code that manipulates these structures is in src/sys/logging/utils. 99 */ 100 typedef struct _n_PetscIntStack *PetscIntStack; 101 102 /* -----------------------------------------------------------------------------------------------------*/ 103 /* 104 PetscClassRegInfo, PetscClassPerfInfo - Each class has two data structures associated with it. The first has 105 static information about it, the second collects statistics on how many objects of the class are created, 106 how much memory they use, etc. 107 108 PetscClassRegLog, PetscClassPerfLog - arrays of the PetscClassRegInfo and PetscClassPerfInfo for all classes. 109 */ 110 typedef struct { 111 char *name; /* The class name */ 112 PetscClassId classid; /* The integer identifying this class */ 113 } PetscClassRegInfo; 114 115 typedef struct { 116 PetscClassId id; /* The integer identifying this class */ 117 int creations; /* The number of objects of this class created */ 118 int destructions; /* The number of objects of this class destroyed */ 119 PetscLogDouble mem; /* The total memory allocated by objects of this class */ 120 PetscLogDouble descMem; /* The total memory allocated by descendents of these objects */ 121 } PetscClassPerfInfo; 122 123 typedef struct _n_PetscClassRegLog *PetscClassRegLog; 124 struct _n_PetscClassRegLog { 125 int numClasses; /* The number of classes registered */ 126 int maxClasses; /* The maximum number of classes */ 127 PetscClassRegInfo *classInfo; /* The structure for class information (classids are monotonicly increasing) */ 128 }; 129 130 typedef struct _n_PetscClassPerfLog *PetscClassPerfLog; 131 struct _n_PetscClassPerfLog { 132 int numClasses; /* The number of logging classes */ 133 int maxClasses; /* The maximum number of classes */ 134 PetscClassPerfInfo *classInfo; /* The structure for class information (classids are monotonicly increasing) */ 135 }; 136 /* -----------------------------------------------------------------------------------------------------*/ 137 /* 138 PetscEventRegInfo, PetscEventPerfInfo - Each event has two data structures associated with it. The first has 139 static information about it, the second collects statistics on how many times the event is used, how 140 much time it takes, etc. 141 142 PetscEventRegLog, PetscEventPerfLog - an array of all PetscEventRegInfo and PetscEventPerfInfo for all events. There is one 143 of these for each stage. 144 145 */ 146 typedef struct { 147 char *name; /* The name of this event */ 148 PetscClassId classid; /* The class the event is associated with */ 149 PetscBool collective; /* Flag this event as collective */ 150 #if defined (PETSC_HAVE_MPE) 151 int mpe_id_begin; /* MPE IDs that define the event */ 152 int mpe_id_end; 153 #endif 154 } PetscEventRegInfo; 155 156 typedef struct { 157 int id; /* The integer identifying this event */ 158 PetscBool active; /* The flag to activate logging */ 159 PetscBool visible; /* The flag to print info in summary */ 160 int depth; /* The nesting depth of the event call */ 161 int count; /* The number of times this event was executed */ 162 PetscLogDouble flops, flops2, flopsTmp; /* The flops and flops^2 used in this event */ 163 PetscLogDouble time, time2, timeTmp; /* The time and time^2 taken for this event */ 164 PetscLogDouble syncTime; /* The synchronization barrier time */ 165 PetscLogDouble dof[8]; /* The number of degrees of freedom associated with this event */ 166 PetscLogDouble errors[8]; /* The errors (user-defined) associated with this event */ 167 PetscLogDouble numMessages; /* The number of messages in this event */ 168 PetscLogDouble messageLength; /* The total message lengths in this event */ 169 PetscLogDouble numReductions; /* The number of reductions in this event */ 170 PetscLogDouble memIncrease; /* How much the resident memory has increased in this event */ 171 PetscLogDouble mallocIncrease;/* How much the maximum malloced space has increased in this event */ 172 PetscLogDouble mallocSpace; /* How much the space was malloced and kept during this event */ 173 PetscLogDouble mallocIncreaseEvent; /* Maximum of the high water mark with in event minus memory available at the end of the event */ 174 #if defined(PETSC_HAVE_VIENNACL) || defined(PETSC_HAVE_CUDA) 175 PetscLogDouble CpuToGpuCount; /* The total number of CPU to GPU copies */ 176 PetscLogDouble GpuToCpuCount; /* The total number of GPU to CPU copies */ 177 PetscLogDouble CpuToGpuSize; /* The total size of CPU to GPU copies */ 178 PetscLogDouble GpuToCpuSize; /* The total size of GPU to CPU copies */ 179 PetscLogDouble GpuFlops; /* The flops done on a GPU in this event */ 180 PetscLogDouble GpuTime; /* The time spent on a GPU in this event */ 181 #endif 182 } PetscEventPerfInfo; 183 184 typedef struct _n_PetscEventRegLog *PetscEventRegLog; 185 struct _n_PetscEventRegLog { 186 int numEvents; /* The number of registered events */ 187 int maxEvents; /* The maximum number of events */ 188 PetscEventRegInfo *eventInfo; /* The registration information for each event */ 189 }; 190 191 typedef struct _n_PetscEventPerfLog *PetscEventPerfLog; 192 struct _n_PetscEventPerfLog { 193 int numEvents; /* The number of logging events */ 194 int maxEvents; /* The maximum number of events */ 195 PetscEventPerfInfo *eventInfo; /* The performance information for each event */ 196 }; 197 /* ------------------------------------------------------------------------------------------------------------*/ 198 /* 199 PetscStageInfo - Contains all the information about a particular stage. 200 201 PetscStageLog - An array of PetscStageInfo for each registered stage. There is a single one of these in the code. 202 */ 203 typedef struct _PetscStageInfo { 204 char *name; /* The stage name */ 205 PetscBool used; /* The stage was pushed on this processor */ 206 PetscEventPerfInfo perfInfo; /* The stage performance information */ 207 PetscEventPerfLog eventLog; /* The event information for this stage */ 208 PetscClassPerfLog classLog; /* The class information for this stage */ 209 } PetscStageInfo; 210 211 typedef struct _n_PetscStageLog *PetscStageLog; 212 struct _n_PetscStageLog { 213 int numStages; /* The number of registered stages */ 214 int maxStages; /* The maximum number of stages */ 215 PetscIntStack stack; /* The stack for active stages */ 216 int curStage; /* The current stage (only used in macros so we don't call PetscIntStackTop) */ 217 PetscStageInfo *stageInfo; /* The information for each stage */ 218 PetscEventRegLog eventLog; /* The registered events */ 219 PetscClassRegLog classLog; /* The registered classes */ 220 }; 221 /* -----------------------------------------------------------------------------------------------------*/ 222 223 PETSC_EXTERN PetscErrorCode PetscLogObjectParent(PetscObject,PetscObject); 224 PETSC_EXTERN PetscErrorCode PetscLogObjectMemory(PetscObject,PetscLogDouble); 225 226 #if defined(PETSC_USE_LOG) /* --- Logging is turned on --------------------------------*/ 227 PETSC_EXTERN PetscStageLog petsc_stageLog; 228 PETSC_EXTERN PetscErrorCode PetscLogGetStageLog(PetscStageLog*); 229 PETSC_EXTERN PetscErrorCode PetscStageLogGetCurrent(PetscStageLog,int*); 230 PETSC_EXTERN PetscErrorCode PetscStageLogGetEventPerfLog(PetscStageLog,int,PetscEventPerfLog*); 231 232 /* 233 Flop counting: We count each arithmetic operation (e.g., addition, multiplication) separately. 234 235 For the complex numbers version, note that 236 1 complex addition = 2 flops 237 1 complex multiplication = 6 flops, 238 where we define 1 flop as that for a double precision scalar. We roughly approximate 239 flop counting for complex numbers by multiplying the total flops by 4; this corresponds 240 to the assumption that we're counting mostly additions and multiplications -- and 241 roughly the same number of each. More accurate counting could be done by distinguishing 242 among the various arithmetic operations. 243 */ 244 245 #if defined(PETSC_USE_COMPLEX) 246 #define PETSC_FLOPS_PER_OP 4.0 247 #else 248 #define PETSC_FLOPS_PER_OP 1.0 249 #endif 250 251 /*@ 252 PetscLogFlops - Log how many flops are performed in a calculation 253 254 Input Paramters: 255 flops - the number of flops 256 257 Notes: 258 To limit the chance of integer overflow when multiplying by a constant, represent the constant as a double, 259 not an integer. Use PetscLogFlops(4.0*n) not PetscLogFlops(4*n) 260 261 Level: intermediate 262 263 .seealso: PetscLogView(), PetscLogGpuFlops() 264 @*/ 265 266 PETSC_STATIC_INLINE PetscErrorCode PetscLogFlops(PetscLogDouble n) 267 { 268 PetscFunctionBegin; 269 #if defined(PETSC_USE_DEBUG) 270 if (n < 0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Cannot log negative flops"); 271 #endif 272 petsc_TotalFlops += PETSC_FLOPS_PER_OP*n; 273 PetscFunctionReturn(0); 274 } 275 276 #if defined(PETSC_HAVE_VIENNACL) || defined(PETSC_HAVE_CUDA) 277 /* Global GPU counters */ 278 PETSC_EXTERN PetscLogDouble petsc_ctog_ct; 279 PETSC_EXTERN PetscLogDouble petsc_gtoc_ct; 280 PETSC_EXTERN PetscLogDouble petsc_ctog_sz; 281 PETSC_EXTERN PetscLogDouble petsc_gtoc_sz; 282 PETSC_EXTERN PetscLogDouble petsc_gflops; 283 PETSC_EXTERN PetscLogDouble petsc_gtime; 284 #if defined(PETSC_USE_DEBUG) 285 PETSC_EXTERN PetscBool petsc_gtime_inuse; 286 #endif 287 288 PETSC_STATIC_INLINE PetscErrorCode PetscLogCpuToGpu(PetscLogDouble size) 289 { 290 PetscFunctionBegin; 291 petsc_ctog_ct += 1; 292 petsc_ctog_sz += size; 293 PetscFunctionReturn(0); 294 } 295 296 PETSC_STATIC_INLINE PetscErrorCode PetscLogGpuToCpu(PetscLogDouble size) 297 { 298 PetscFunctionBegin; 299 petsc_gtoc_ct += 1; 300 petsc_gtoc_sz += size; 301 PetscFunctionReturn(0); 302 } 303 304 /*@ 305 PetscLogGpuFlops - Log how many flops are performed in a calculation on the device 306 307 Input Paramters: 308 flops - the number of flops 309 310 Notes: 311 To limit the chance of integer overflow when multiplying by a constant, represent the constant as a double, 312 not an integer. Use PetscLogFlops(4.0*n) not PetscLogFlops(4*n) 313 314 Level: intermediate 315 316 .seealso: PetscLogView(), PetscLogFlops(), PetscLogGpuTimeBegin(), PetscLogGpuTimeEnd() 317 @*/ 318 PETSC_STATIC_INLINE PetscErrorCode PetscLogGpuFlops(PetscLogDouble n) 319 { 320 PetscFunctionBegin; 321 #if defined(PETSC_USE_DEBUG) 322 if (n < 0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Cannot log negative flops"); 323 #endif 324 petsc_TotalFlops += PETSC_FLOPS_PER_OP*n; 325 petsc_gflops += PETSC_FLOPS_PER_OP*n; 326 PetscFunctionReturn(0); 327 } 328 329 /*@ 330 PetscLogGpuTimeBegin - Start timer for device 331 332 Level: intermediate 333 334 Notes: 335 The timer is run on the CPU, it is just logged separately as time devoted to GPU computations (including kernel launch times). It is used to compute the flop rate on the GPU. 336 .seealso: PetscLogView(), PetscLogGpuFlops(), PetscLogGpuTimeEnd() 337 @*/ 338 PETSC_STATIC_INLINE PetscErrorCode PetscLogGpuTimeBegin() 339 { 340 PetscErrorCode ierr; 341 PetscFunctionBegin; 342 #if defined(PETSC_USE_DEBUG) 343 if (petsc_gtime_inuse) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Forgot to call PetscLogGpuTimeEnd()?"); 344 petsc_gtime_inuse = PETSC_TRUE; 345 #endif 346 ierr = PetscTimeSubtract(&petsc_gtime);CHKERRQ(ierr); 347 PetscFunctionReturn(0); 348 } 349 /*@ 350 PetscLogGpuTimeEnd - Stop timer for device 351 352 Level: intermediate 353 354 .seealso: PetscLogView(), PetscLogGpuFlops(), PetscLogGpuTimeBegin() 355 @*/ 356 PETSC_STATIC_INLINE PetscErrorCode PetscLogGpuTimeEnd() 357 { 358 PetscErrorCode ierr; 359 PetscFunctionBegin; 360 #if defined(PETSC_USE_DEBUG) 361 if (!petsc_gtime_inuse) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Forgot to call PetscLogGpuTimeBegin()?"); 362 petsc_gtime_inuse = PETSC_FALSE; 363 #endif 364 ierr = PetscTimeAdd(&petsc_gtime);CHKERRQ(ierr); 365 PetscFunctionReturn(0); 366 } 367 368 PETSC_STATIC_INLINE PetscErrorCode PetscLogGpuTimeAdd(PetscLogDouble t) 369 { 370 PetscFunctionBegin; 371 petsc_gtime += t; 372 PetscFunctionReturn(0); 373 } 374 #endif 375 376 PETSC_EXTERN PetscErrorCode PetscGetFlops(PetscLogDouble *); 377 378 #if defined (PETSC_HAVE_MPE) 379 PETSC_EXTERN PetscErrorCode PetscLogMPEBegin(void); 380 PETSC_EXTERN PetscErrorCode PetscLogMPEDump(const char[]); 381 #endif 382 383 PETSC_EXTERN PetscErrorCode (*PetscLogPLB)(PetscLogEvent,int,PetscObject,PetscObject,PetscObject,PetscObject); 384 PETSC_EXTERN PetscErrorCode (*PetscLogPLE)(PetscLogEvent,int,PetscObject,PetscObject,PetscObject,PetscObject); 385 PETSC_EXTERN PetscErrorCode (*PetscLogPHC)(PetscObject); 386 PETSC_EXTERN PetscErrorCode (*PetscLogPHD)(PetscObject); 387 388 #define PetscLogObjectParents(p,n,d) 0;do{int _i; for (_i=0; _i<(n); _i++) {ierr = PetscLogObjectParent((PetscObject)(p),(PetscObject)(d)[_i]);CHKERRQ(ierr);}}while (0) 389 #define PetscLogObjectCreate(h) ((PetscLogPHC) ? (*PetscLogPHC)((PetscObject)(h)) : 0) 390 #define PetscLogObjectDestroy(h) ((PetscLogPHD) ? (*PetscLogPHD)((PetscObject)(h)) : 0) 391 PETSC_EXTERN PetscErrorCode PetscLogObjectState(PetscObject, const char[], ...); 392 393 /* Initialization functions */ 394 PETSC_EXTERN PetscErrorCode PetscLogDefaultBegin(void); 395 PETSC_EXTERN PetscErrorCode PetscLogAllBegin(void); 396 PETSC_EXTERN PetscErrorCode PetscLogNestedBegin(void); 397 PETSC_EXTERN PetscErrorCode PetscLogTraceBegin(FILE *); 398 PETSC_EXTERN PetscErrorCode PetscLogActions(PetscBool); 399 PETSC_EXTERN PetscErrorCode PetscLogObjects(PetscBool); 400 PETSC_EXTERN PetscErrorCode PetscLogSetThreshold(PetscLogDouble,PetscLogDouble*); 401 PETSC_EXTERN PetscErrorCode PetscLogSet(PetscErrorCode (*)(int, int, PetscObject, PetscObject, PetscObject, PetscObject), 402 PetscErrorCode (*)(int, int, PetscObject, PetscObject, PetscObject, PetscObject)); 403 404 /* Output functions */ 405 PETSC_EXTERN PetscErrorCode PetscLogView(PetscViewer); 406 PETSC_EXTERN PetscErrorCode PetscLogViewFromOptions(void); 407 PETSC_EXTERN PetscErrorCode PetscLogDump(const char[]); 408 409 /* Stage functions */ 410 PETSC_EXTERN PetscErrorCode PetscLogStageRegister(const char[],PetscLogStage*); 411 PETSC_EXTERN PetscErrorCode PetscLogStagePush(PetscLogStage); 412 PETSC_EXTERN PetscErrorCode PetscLogStagePop(void); 413 PETSC_EXTERN PetscErrorCode PetscLogStageSetActive(PetscLogStage,PetscBool); 414 PETSC_EXTERN PetscErrorCode PetscLogStageGetActive(PetscLogStage,PetscBool*); 415 PETSC_EXTERN PetscErrorCode PetscLogStageSetVisible(PetscLogStage,PetscBool); 416 PETSC_EXTERN PetscErrorCode PetscLogStageGetVisible(PetscLogStage,PetscBool*); 417 PETSC_EXTERN PetscErrorCode PetscLogStageGetId(const char[],PetscLogStage*); 418 419 /* Event functions */ 420 PETSC_EXTERN PetscErrorCode PetscLogEventRegister(const char[],PetscClassId,PetscLogEvent*); 421 PETSC_EXTERN PetscErrorCode PetscLogEventSetCollective(PetscLogEvent,PetscBool); 422 PETSC_EXTERN PetscErrorCode PetscLogEventIncludeClass(PetscClassId); 423 PETSC_EXTERN PetscErrorCode PetscLogEventExcludeClass(PetscClassId); 424 PETSC_EXTERN PetscErrorCode PetscLogEventActivate(PetscLogEvent); 425 PETSC_EXTERN PetscErrorCode PetscLogEventDeactivate(PetscLogEvent); 426 PETSC_EXTERN PetscErrorCode PetscLogEventSetActiveAll(PetscLogEvent,PetscBool); 427 PETSC_EXTERN PetscErrorCode PetscLogEventActivateClass(PetscClassId); 428 PETSC_EXTERN PetscErrorCode PetscLogEventDeactivateClass(PetscClassId); 429 PETSC_EXTERN PetscErrorCode PetscLogEventGetId(const char[],PetscLogEvent*); 430 PETSC_EXTERN PetscErrorCode PetscLogEventGetPerfInfo(int,PetscLogEvent,PetscEventPerfInfo*); 431 PETSC_EXTERN PetscErrorCode PetscLogEventSetDof(PetscLogEvent, PetscInt, PetscLogDouble); 432 PETSC_EXTERN PetscErrorCode PetscLogEventSetError(PetscLogEvent, PetscInt, PetscLogDouble); 433 434 /* Global counters */ 435 PETSC_EXTERN PetscLogDouble petsc_irecv_ct; 436 PETSC_EXTERN PetscLogDouble petsc_isend_ct; 437 PETSC_EXTERN PetscLogDouble petsc_recv_ct; 438 PETSC_EXTERN PetscLogDouble petsc_send_ct; 439 PETSC_EXTERN PetscLogDouble petsc_irecv_len; 440 PETSC_EXTERN PetscLogDouble petsc_isend_len; 441 PETSC_EXTERN PetscLogDouble petsc_recv_len; 442 PETSC_EXTERN PetscLogDouble petsc_send_len; 443 PETSC_EXTERN PetscLogDouble petsc_allreduce_ct; 444 PETSC_EXTERN PetscLogDouble petsc_gather_ct; 445 PETSC_EXTERN PetscLogDouble petsc_scatter_ct; 446 PETSC_EXTERN PetscLogDouble petsc_wait_ct; 447 PETSC_EXTERN PetscLogDouble petsc_wait_any_ct; 448 PETSC_EXTERN PetscLogDouble petsc_wait_all_ct; 449 PETSC_EXTERN PetscLogDouble petsc_sum_of_waits_ct; 450 451 PETSC_EXTERN PetscBool PetscLogMemory; 452 453 PETSC_EXTERN PetscBool PetscLogSyncOn; /* true if logging synchronization is enabled */ 454 PETSC_EXTERN PetscErrorCode PetscLogEventSynchronize(PetscLogEvent, MPI_Comm); 455 456 #define PetscLogEventSync(e,comm) \ 457 (((PetscLogPLB && petsc_stageLog->stageInfo[petsc_stageLog->curStage].perfInfo.active && petsc_stageLog->stageInfo[petsc_stageLog->curStage].eventLog->eventInfo[e].active) ? \ 458 PetscLogEventSynchronize((e),(comm)) : 0)) 459 460 #define PetscLogEventBegin(e,o1,o2,o3,o4) \ 461 (((PetscLogPLB && petsc_stageLog->stageInfo[petsc_stageLog->curStage].perfInfo.active && petsc_stageLog->stageInfo[petsc_stageLog->curStage].eventLog->eventInfo[e].active) ? \ 462 (*PetscLogPLB)((e),0,(PetscObject)(o1),(PetscObject)(o2),(PetscObject)(o3),(PetscObject)(o4)) : 0)) 463 464 #define PetscLogEventEnd(e,o1,o2,o3,o4) \ 465 (((PetscLogPLE && petsc_stageLog->stageInfo[petsc_stageLog->curStage].perfInfo.active && petsc_stageLog->stageInfo[petsc_stageLog->curStage].eventLog->eventInfo[e].active) ? \ 466 (*PetscLogPLE)((e),0,(PetscObject)(o1),(PetscObject)(o2),(PetscObject)(o3),(PetscObject)(o4)) : 0)) 467 468 PETSC_EXTERN PetscErrorCode PetscLogEventGetFlops(PetscLogEvent,PetscLogDouble*); 469 PETSC_EXTERN PetscErrorCode PetscLogEventZeroFlops(PetscLogEvent); 470 471 /* 472 These are used internally in the PETSc routines to keep a count of MPI messages and 473 their sizes. 474 475 This does not work for MPI-Uni because our include/petsc/mpiuni/mpi.h file 476 uses macros to defined the MPI operations. 477 478 It does not work correctly from HP-UX because it processes the 479 macros in a way that sometimes it double counts, hence 480 PETSC_HAVE_BROKEN_RECURSIVE_MACRO 481 482 It does not work with Windows because winmpich lacks MPI_Type_size() 483 */ 484 #if !defined(MPIUNI_H) && !defined(PETSC_HAVE_BROKEN_RECURSIVE_MACRO) && !defined (PETSC_HAVE_MPI_MISSING_TYPESIZE) 485 /* 486 Logging of MPI activities 487 */ 488 PETSC_STATIC_INLINE PetscErrorCode PetscMPITypeSize(PetscInt count,MPI_Datatype type,PetscLogDouble *length) 489 { 490 PetscMPIInt typesize; 491 PetscErrorCode ierr; 492 if (type == MPI_DATATYPE_NULL) return 0; 493 ierr = MPI_Type_size(type,&typesize);CHKERRQ(ierr); 494 *length += (PetscLogDouble) (count*typesize); 495 return 0; 496 } 497 498 PETSC_STATIC_INLINE PetscErrorCode PetscMPITypeSizeComm(MPI_Comm comm,const PetscMPIInt *counts,MPI_Datatype type,PetscLogDouble *length) 499 { 500 PetscMPIInt typesize,size,p; 501 PetscErrorCode ierr; 502 503 if (type == MPI_DATATYPE_NULL) return 0; 504 ierr = MPI_Comm_size(comm,&size);CHKERRQ(ierr); 505 ierr = MPI_Type_size(type,&typesize);CHKERRQ(ierr); 506 for (p=0; p<size; ++p) { 507 *length += (PetscLogDouble) (counts[p]*typesize); 508 } 509 return 0; 510 } 511 512 PETSC_STATIC_INLINE PetscErrorCode PetscMPITypeSizeCount(PetscInt n,const PetscMPIInt *counts,MPI_Datatype type,PetscLogDouble *length) 513 { 514 PetscMPIInt typesize,p; 515 PetscErrorCode ierr; 516 517 if (type == MPI_DATATYPE_NULL) return 0; 518 ierr = MPI_Type_size(type,&typesize);CHKERRQ(ierr); 519 for (p=0; p<n; ++p) { 520 *length += (PetscLogDouble) (counts[p]*typesize); 521 } 522 return 0; 523 } 524 525 /* 526 Returns 1 if the communicator is parallel else zero 527 */ 528 PETSC_STATIC_INLINE int PetscMPIParallelComm(MPI_Comm comm) 529 { 530 PetscMPIInt size; MPI_Comm_size(comm,&size); return size > 1; 531 } 532 533 #define MPI_Irecv(buf,count,datatype,source,tag,comm,request) \ 534 ((petsc_irecv_ct++,0) || PetscMPITypeSize((count),(datatype),&(petsc_irecv_len)) || MPI_Irecv((buf),(count),(datatype),(source),(tag),(comm),(request))) 535 536 #define MPI_Isend(buf,count,datatype,dest,tag,comm,request) \ 537 ((petsc_isend_ct++,0) || PetscMPITypeSize((count),(datatype),&(petsc_isend_len)) || MPI_Isend((buf),(count),(datatype),(dest),(tag),(comm),(request))) 538 539 #define MPI_Startall_irecv(count,datatype,number,requests) \ 540 ((petsc_irecv_ct += (PetscLogDouble)(number),0) || PetscMPITypeSize((count),(datatype),&(petsc_irecv_len)) || ((number) && MPI_Startall((number),(requests)))) 541 542 #define MPI_Startall_isend(count,datatype,number,requests) \ 543 ((petsc_isend_ct += (PetscLogDouble)(number),0) || PetscMPITypeSize((count),(datatype),&(petsc_isend_len)) || ((number) && MPI_Startall((number),(requests)))) 544 545 #define MPI_Start_isend(count,datatype,requests) \ 546 ((petsc_isend_ct++,0) || PetscMPITypeSize((count),(datatype),(&petsc_isend_len)) || MPI_Start((requests))) 547 548 #define MPI_Recv(buf,count,datatype,source,tag,comm,status) \ 549 ((petsc_recv_ct++,0) || PetscMPITypeSize((count),(datatype),(&petsc_recv_len)) || MPI_Recv((buf),(count),(datatype),(source),(tag),(comm),(status))) 550 551 #define MPI_Send(buf,count,datatype,dest,tag,comm) \ 552 ((petsc_send_ct++,0) || PetscMPITypeSize((count),(datatype),(&petsc_send_len)) || MPI_Send((buf),(count),(datatype),(dest),(tag),(comm))) 553 554 #define MPI_Wait(request,status) \ 555 ((petsc_wait_ct++,petsc_sum_of_waits_ct++,0) || MPI_Wait((request),(status))) 556 557 #define MPI_Waitany(a,b,c,d) \ 558 ((petsc_wait_any_ct++,petsc_sum_of_waits_ct++,0) || MPI_Waitany((a),(b),(c),(d))) 559 560 #define MPI_Waitall(count,array_of_requests,array_of_statuses) \ 561 ((petsc_wait_all_ct++,petsc_sum_of_waits_ct += (PetscLogDouble) (count),0) || MPI_Waitall((count),(array_of_requests),(array_of_statuses))) 562 563 #define MPI_Allreduce(sendbuf,recvbuf,count,datatype,op,comm) \ 564 ((petsc_allreduce_ct += PetscMPIParallelComm((comm)),0) || MPI_Allreduce((sendbuf),(recvbuf),(count),(datatype),(op),(comm))) 565 566 #define MPI_Bcast(buffer,count,datatype,root,comm) \ 567 ((petsc_allreduce_ct += PetscMPIParallelComm((comm)),0) || MPI_Bcast((buffer),(count),(datatype),(root),(comm))) 568 569 #define MPI_Reduce_scatter_block(sendbuf,recvbuf,recvcount,datatype,op,comm) \ 570 ((petsc_allreduce_ct += PetscMPIParallelComm((comm)),0) || MPI_Reduce_scatter_block((sendbuf),(recvbuf),(recvcount),(datatype),(op),(comm))) 571 572 #define MPI_Alltoall(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,comm) \ 573 ((petsc_allreduce_ct += PetscMPIParallelComm((comm)),0) || PetscMPITypeSize((sendcount),(sendtype),(&petsc_send_len)) || MPI_Alltoall((sendbuf),(sendcount),(sendtype),(recvbuf),(recvcount),(recvtype),(comm))) 574 575 #define MPI_Alltoallv(sendbuf,sendcnts,sdispls,sendtype,recvbuf,recvcnts,rdispls,recvtype,comm) \ 576 ((petsc_allreduce_ct += PetscMPIParallelComm((comm)),0) || PetscMPITypeSizeComm((comm),(sendcnts),(sendtype),(&petsc_send_len)) || MPI_Alltoallv((sendbuf),(sendcnts),(sdispls),(sendtype),(recvbuf),(recvcnts),(rdispls),(recvtype),(comm))) 577 578 #define MPI_Allgather(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,comm) \ 579 ((petsc_gather_ct += PetscMPIParallelComm((comm)),0) || MPI_Allgather((sendbuf),(sendcount),(sendtype),(recvbuf),(recvcount),(recvtype),(comm))) 580 581 #define MPI_Allgatherv(sendbuf,sendcount,sendtype,recvbuf,recvcount,displs,recvtype,comm) \ 582 ((petsc_gather_ct += PetscMPIParallelComm((comm)),0) || MPI_Allgatherv((sendbuf),(sendcount),(sendtype),(recvbuf),(recvcount),(displs),(recvtype),(comm))) 583 584 #define MPI_Gather(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,root,comm) \ 585 ((petsc_gather_ct++,0) || PetscMPITypeSize((sendcount),(sendtype),(&petsc_send_len)) || MPI_Gather((sendbuf),(sendcount),(sendtype),(recvbuf),(recvcount),(recvtype),(root),(comm))) 586 587 #define MPI_Gatherv(sendbuf,sendcount,sendtype,recvbuf,recvcount,displs,recvtype,root,comm) \ 588 ((petsc_gather_ct++,0) || PetscMPITypeSize((sendcount),(sendtype),(&petsc_send_len)) || MPI_Gatherv((sendbuf),(sendcount),(sendtype),(recvbuf),(recvcount),(displs),(recvtype),(root),(comm))) 589 590 #define MPI_Scatter(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,root,comm) \ 591 ((petsc_scatter_ct++,0) || PetscMPITypeSize((recvcount),(recvtype),(&petsc_recv_len)) || MPI_Scatter((sendbuf),(sendcount),(sendtype),(recvbuf),(recvcount),(recvtype),(root),(comm))) 592 593 #define MPI_Scatterv(sendbuf,sendcount,displs,sendtype,recvbuf,recvcount,recvtype,root,comm) \ 594 ((petsc_scatter_ct++,0) || PetscMPITypeSize((recvcount),(recvtype),(&petsc_recv_len)) || MPI_Scatterv((sendbuf),(sendcount),(displs),(sendtype),(recvbuf),(recvcount),(recvtype),(root),(comm))) 595 596 #define MPI_Ialltoall(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,comm,request) \ 597 ((petsc_allreduce_ct += PetscMPIParallelComm((comm)),0) || PetscMPITypeSize((sendcount),(sendtype),(&petsc_send_len)) || MPI_Ialltoall((sendbuf),(sendcount),(sendtype),(recvbuf),(recvcount),(recvtype),(comm),(request))) 598 599 #define MPI_Ialltoallv(sendbuf,sendcnts,sdispls,sendtype,recvbuf,recvcnts,rdispls,recvtype,comm,request) \ 600 ((petsc_allreduce_ct += PetscMPIParallelComm((comm)),0) || PetscMPITypeSizeComm((comm),(sendcnts),(sendtype),(&petsc_send_len)) || MPI_Ialltoallv((sendbuf),(sendcnts),(sdispls),(sendtype),(recvbuf),(recvcnts),(rdispls),(recvtype),(comm),(request))) 601 602 #define MPI_Iallgather(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,comm,request) \ 603 ((petsc_gather_ct += PetscMPIParallelComm((comm)),0) || MPI_Iallgather((sendbuf),(sendcount),(sendtype),(recvbuf),(recvcount),(recvtype),(comm),(request))) 604 605 #define MPI_Iallgatherv(sendbuf,sendcount,sendtype,recvbuf,recvcount,displs,recvtype,comm,request) \ 606 ((petsc_gather_ct += PetscMPIParallelComm((comm)),0) || MPI_Iallgatherv((sendbuf),(sendcount),(sendtype),(recvbuf),(recvcount),(displs),(recvtype),(comm),(request))) 607 608 #define MPI_Igather(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,root,comm,request) \ 609 ((petsc_gather_ct++,0) || PetscMPITypeSize((sendcount),(sendtype),(&petsc_send_len)) || MPI_Igather((sendbuf),(sendcount),(sendtype),(recvbuf),(recvcount),(recvtype),(root),(comm),(request))) 610 611 #define MPI_Igatherv(sendbuf,sendcount,sendtype,recvbuf,recvcount,displs,recvtype,root,comm,request) \ 612 ((petsc_gather_ct++,0) || PetscMPITypeSize((sendcount),(sendtype),(&petsc_send_len)) || MPI_Igatherv((sendbuf),(sendcount),(sendtype),(recvbuf),(recvcount),(displs),(recvtype),(root),(comm),(request))) 613 614 #define MPI_Iscatter(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype,root,comm,request) \ 615 ((petsc_scatter_ct++,0) || PetscMPITypeSize((recvcount),(recvtype),(&petsc_recv_len)) || MPI_Iscatter((sendbuf),(sendcount),(sendtype),(recvbuf),(recvcount),(recvtype),(root),(comm),(request))) 616 617 #define MPI_Iscatterv(sendbuf,sendcount,displs,sendtype,recvbuf,recvcount,recvtype,root,comm,request) \ 618 ((petsc_scatter_ct++,0) || PetscMPITypeSize((recvcount),(recvtype),(&petsc_recv_len)) || MPI_Iscatterv((sendbuf),(sendcount),(displs),(sendtype),(recvbuf),(recvcount),(recvtype),(root),(comm),(request))) 619 620 /* We treat MPI_Ineighbor_alltoallv as a set of isend/irecv instead of a traditional MPI collective. 621 OpenMPI-3.0 ran into error with outdegree = indegree = 0, so we use ((outdegree) || (indegree)) as a workaround. 622 */ 623 #define MPI_Start_ineighbor_alltoallv(outdegree,indegree,sendbuf,sendcnts,sdispls,sendtype,recvbuf,recvcnts,rdispls,recvtype,comm,request) \ 624 ((petsc_isend_ct += (PetscLogDouble)(outdegree),0) || (petsc_irecv_ct += (PetscLogDouble)(indegree),0) || PetscMPITypeSizeCount((outdegree),(sendcnts),(sendtype),(&petsc_isend_len)) || PetscMPITypeSizeCount((indegree),(recvcnts),(recvtype),(&petsc_irecv_len)) || (((outdegree) || (indegree)) && MPI_Ineighbor_alltoallv((sendbuf),(sendcnts),(sdispls),(sendtype),(recvbuf),(recvcnts),(rdispls),(recvtype),(comm),(request)))) 625 626 #define MPI_Start_neighbor_alltoallv(outdegree,indegree,sendbuf,sendcnts,sdispls,sendtype,recvbuf,recvcnts,rdispls,recvtype,comm) \ 627 ((petsc_isend_ct += (PetscLogDouble)(outdegree),0) || (petsc_irecv_ct += (PetscLogDouble)(indegree),0) || PetscMPITypeSizeCount((outdegree),(sendcnts),(sendtype),(&petsc_isend_len)) || PetscMPITypeSizeCount((indegree),(recvcnts),(recvtype),(&petsc_irecv_len)) || (((outdegree) || (indegree)) && MPI_Neighbor_alltoallv((sendbuf),(sendcnts),(sdispls),(sendtype),(recvbuf),(recvcnts),(rdispls),(recvtype),(comm)))) 628 629 #else 630 631 #define MPI_Startall_irecv(count,datatype,number,requests) \ 632 ((number) && MPI_Startall((number),(requests))) 633 634 #define MPI_Startall_isend(count,datatype,number,requests) \ 635 ((number) && MPI_Startall((number),(requests))) 636 637 #define MPI_Start_isend(count,datatype,requests) \ 638 (MPI_Start((requests))) 639 640 #define MPI_Start_ineighbor_alltoallv(outdegree,indegree,sendbuf,sendcnts,sdispls,sendtype,recvbuf,recvcnts,rdispls,recvtype,comm,request) \ 641 (((outdegree) || (indegree)) && MPI_Ineighbor_alltoallv((sendbuf),(sendcnts),(sdispls),(sendtype),(recvbuf),(recvcnts),(rdispls),(recvtype),(comm),(request))) 642 643 #define MPI_Start_neighbor_alltoallv(outdegree,indegree,sendbuf,sendcnts,sdispls,sendtype,recvbuf,recvcnts,rdispls,recvtype,comm) \ 644 (((outdegree) || (indegree)) && MPI_Neighbor_alltoallv((sendbuf),(sendcnts),(sdispls),(sendtype),(recvbuf),(recvcnts),(rdispls),(recvtype),(comm))) 645 #endif /* !MPIUNI_H && ! PETSC_HAVE_BROKEN_RECURSIVE_MACRO */ 646 647 #else /* ---Logging is turned off --------------------------------------------*/ 648 649 #define PetscLogMemory PETSC_FALSE 650 651 #define PetscLogFlops(n) 0 652 #define PetscGetFlops(a) (*(a) = 0.0,0) 653 654 #define PetscLogStageRegister(a,b) 0 655 #define PetscLogStagePush(a) 0 656 #define PetscLogStagePop() 0 657 #define PetscLogStageSetActive(a,b) 0 658 #define PetscLogStageGetActive(a,b) 0 659 #define PetscLogStageGetVisible(a,b) 0 660 #define PetscLogStageSetVisible(a,b) 0 661 #define PetscLogStageGetId(a,b) (*(b)=0,0) 662 663 #define PetscLogEventRegister(a,b,c) 0 664 #define PetscLogEventSetCollective(a,b) 0 665 #define PetscLogEventIncludeClass(a) 0 666 #define PetscLogEventExcludeClass(a) 0 667 #define PetscLogEventActivate(a) 0 668 #define PetscLogEventDeactivate(a) 0 669 #define PetscLogEventActivateClass(a) 0 670 #define PetscLogEventDeactivateClass(a) 0 671 #define PetscLogEventSetActiveAll(a,b) 0 672 #define PetscLogEventGetId(a,b) (*(b)=0,0) 673 #define PetscLogEventGetPerfInfo(a,b,c) 0 674 #define PetscLogEventSetDof(a,b,c) 0 675 #define PetscLogEventSetError(a,b,c) 0 676 677 #define PetscLogPLB 0 678 #define PetscLogPLE 0 679 #define PetscLogPHC 0 680 #define PetscLogPHD 0 681 682 #define PetscLogObjectParents(p,n,c) 0 683 #define PetscLogObjectCreate(h) 0 684 #define PetscLogObjectDestroy(h) 0 685 PETSC_EXTERN PetscErrorCode PetscLogObjectState(PetscObject,const char[],...); 686 687 #define PetscLogDefaultBegin() 0 688 #define PetscLogAllBegin() 0 689 #define PetscLogNestedBegin() 0 690 #define PetscLogTraceBegin(file) 0 691 #define PetscLogActions(a) 0 692 #define PetscLogObjects(a) 0 693 #define PetscLogSetThreshold(a,b) 0 694 #define PetscLogSet(lb,le) 0 695 696 #define PetscLogView(viewer) 0 697 #define PetscLogViewFromOptions() 0 698 #define PetscLogDump(c) 0 699 700 #define PetscLogEventSync(e,comm) 0 701 #define PetscLogEventBegin(e,o1,o2,o3,o4) 0 702 #define PetscLogEventEnd(e,o1,o2,o3,o4) 0 703 704 #if defined(PETSC_HAVE_VIENNACL) || defined(PETSC_HAVE_CUDA) 705 #define PetscLogCpuToGpu(a) 0 706 #define PetscLogGpuToCpu(a) 0 707 #define PetscLogGpuFlops(a) 0 708 #define PetscLogGpuTimeBegin() 0 709 #define PetscLogGpuTimeEnd() 0 710 #define PetscLogGpuTimeAdd(a) 0 711 #endif 712 713 /* If PETSC_USE_LOG is NOT defined, these still need to be! */ 714 #define MPI_Startall_irecv(count,datatype,number,requests) ((number) && MPI_Startall(number,requests)) 715 #define MPI_Startall_isend(count,datatype,number,requests) ((number) && MPI_Startall(number,requests)) 716 #define MPI_Start_isend(count,datatype,requests) MPI_Start(requests) 717 #define MPI_Start_ineighbor_alltoallv(outdegree,indegree,sendbuf,sendcnts,sdispls,sendtype,recvbuf,recvcnts,rdispls,recvtype,comm,request) \ 718 (((outdegree) || (indegree)) && MPI_Ineighbor_alltoallv((sendbuf),(sendcnts),(sdispls),(sendtype),(recvbuf),(recvcnts),(rdispls),(recvtype),(comm),(request))) 719 #define MPI_Start_neighbor_alltoallv(outdegree,indegree,sendbuf,sendcnts,sdispls,sendtype,recvbuf,recvcnts,rdispls,recvtype,comm) \ 720 (((outdegree) || (indegree)) && MPI_Neighbor_alltoallv((sendbuf),(sendcnts),(sdispls),(sendtype),(recvbuf),(recvcnts),(rdispls),(recvtype),(comm))) 721 722 #endif /* PETSC_USE_LOG */ 723 724 #define PetscPreLoadBegin(flag,name) \ 725 do {\ 726 PetscBool PetscPreLoading = flag;\ 727 int PetscPreLoadMax,PetscPreLoadIt;\ 728 PetscLogStage _stageNum;\ 729 PetscErrorCode _3_ierr; \ 730 _3_ierr = PetscOptionsGetBool(NULL,NULL,"-preload",&PetscPreLoading,NULL);CHKERRQ(_3_ierr); \ 731 PetscPreLoadMax = (int)(PetscPreLoading);\ 732 PetscPreLoadingUsed = PetscPreLoading ? PETSC_TRUE : PetscPreLoadingUsed;\ 733 for (PetscPreLoadIt=0; PetscPreLoadIt<=PetscPreLoadMax; PetscPreLoadIt++) {\ 734 PetscPreLoadingOn = PetscPreLoading;\ 735 _3_ierr = PetscBarrier(NULL);CHKERRQ(_3_ierr);\ 736 if (PetscPreLoadIt>0) {\ 737 _3_ierr = PetscLogStageGetId(name,&_stageNum);CHKERRQ(_3_ierr);\ 738 } else {\ 739 _3_ierr = PetscLogStageRegister(name,&_stageNum);CHKERRQ(_3_ierr); \ 740 }\ 741 _3_ierr = PetscLogStageSetActive(_stageNum,(PetscBool)(!PetscPreLoadMax || PetscPreLoadIt));\ 742 _3_ierr = PetscLogStagePush(_stageNum);CHKERRQ(_3_ierr); 743 744 #define PetscPreLoadEnd() \ 745 _3_ierr = PetscLogStagePop();CHKERRQ(_3_ierr);\ 746 PetscPreLoading = PETSC_FALSE;\ 747 }\ 748 } while (0) 749 750 #define PetscPreLoadStage(name) do { \ 751 _3_ierr = PetscLogStagePop();CHKERRQ(_3_ierr); \ 752 if (PetscPreLoadIt>0) { \ 753 _3_ierr = PetscLogStageGetId(name,&_stageNum);CHKERRQ(_3_ierr); \ 754 } else { \ 755 _3_ierr = PetscLogStageRegister(name,&_stageNum);CHKERRQ(_3_ierr); \ 756 } \ 757 _3_ierr = PetscLogStageSetActive(_stageNum,(PetscBool)(!PetscPreLoadMax || PetscPreLoadIt)); \ 758 _3_ierr = PetscLogStagePush(_stageNum);CHKERRQ(_3_ierr); \ 759 } while (0) 760 761 /* some vars for logging */ 762 PETSC_EXTERN PetscBool PetscPreLoadingUsed; /* true if we are or have done preloading */ 763 PETSC_EXTERN PetscBool PetscPreLoadingOn; /* true if we are currently in a preloading calculation */ 764 765 #endif 766