Actual source code: petsclog.h

  1: /*
  2:     Defines profile/logging in PETSc.
  3: */

 7:  #include petsc.h
  9: /*
 10:   Each PETSc object class has it's own cookie (internal integer in the 
 11:   data structure used for error checking). These are all defined by an offset 
 12:   from the lowest one, PETSC_COOKIE.
 13: */
 14: #define PETSC_COOKIE 1211211
 16: #define PETSC_EVENT  1311311

 19: /* Events for the Petsc standard library */

 22: /* Global flop counter */

 25: /* General logging of information; different from event logging */
 26: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogInfo_Private(void*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3);
 27: #if defined(PETSC_USE_DEBUG)
 28: #define PetscLogInfo(A)      PetscLogInfo_Private A
 29: #else 
 30: #define PetscLogInfo(A)      0
 31: #endif
 32: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogInfoDeactivateClass(PetscCookie);
 33: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogInfoActivateClass(PetscCookie);

 36: #if defined(PETSC_USE_LOG)  /* --- Logging is turned on --------------------------------*/

 38: /* 
 39:    Flop counting:  We count each arithmetic operation (e.g., addition, multiplication) separately.

 41:    For the complex numbers version, note that
 42:        1 complex addition = 2 flops
 43:        1 complex multiplication = 6 flops,
 44:    where we define 1 flop as that for a double precision scalar.  We roughly approximate
 45:    flop counting for complex numbers by multiplying the total flops by 4; this corresponds
 46:    to the assumption that we're counting mostly additions and multiplications -- and
 47:    roughly the same number of each.  More accurate counting could be done by distinguishing
 48:    among the various arithmetic operations.
 49:  */

 51: #if defined(PETSC_USE_COMPLEX)
 52: #define PetscLogFlops(n) (_TotalFlops += (4*n),0)
 53: #else
 54: #define PetscLogFlops(n) (_TotalFlops += (n),0)
 55: #endif

 57: #if defined (PETSC_HAVE_MPE)
 58: #include "mpe.h"
 59: EXTERN PetscErrorCode PETSC_DLLEXPORT        PetscLogMPEBegin(void);
 60: EXTERN PetscErrorCode PETSC_DLLEXPORT        PetscLogMPEDump(const char[]);
 62: #define PETSC_LOG_EVENT_MPE_BEGIN(e) \
 63:   ((UseMPE && _stageLog->stageInfo[_stageLog->curStage].eventLog->eventInfo[e].active) ? \
 64:    MPE_Log_event(_stageLog->eventLog->eventInfo[e].mpe_id_begin,0,(char*)"") : 0)

 66: #define PETSC_LOG_EVENT_MPE_END(e) \
 67:   ((UseMPE && _stageLog->stageInfo[_stageLog->curStage].eventLog->eventInfo[e].active) ? \
 68:    MPE_Log_event(_stageLog->eventLog->eventInfo[e].mpe_id_end,0,(char*)"") : 0)

 70: #else 
 71: #define PETSC_LOG_EVENT_MPE_BEGIN(e) 0 
 72: #define PETSC_LOG_EVENT_MPE_END(e)   0
 73: #endif

 75: EXTERN PETSC_DLLEXPORT PetscErrorCode (*_PetscLogPLB)(PetscEvent,int,PetscObject,PetscObject,PetscObject,PetscObject);
 76: EXTERN PETSC_DLLEXPORT PetscErrorCode (*_PetscLogPLE)(PetscEvent,int,PetscObject,PetscObject,PetscObject,PetscObject);
 77: EXTERN PETSC_DLLEXPORT PetscErrorCode (*_PetscLogPHC)(PetscObject);
 78: EXTERN PETSC_DLLEXPORT PetscErrorCode (*_PetscLogPHD)(PetscObject);

 80: #define PetscLogObjectParent(p,c) \
 81:   ((c && p) ? ((PetscObject)(c))->parent = (PetscObject)(p),((PetscObject)(c))->parentid = ((PetscObject)p)->id : 0, 0)

 83: #define PetscLogObjectParents(p,n,d)  0;{int _i; for (_i=0; _i<n; _i++) {PetscLogObjectParent(p,(d)[_i]);}}
 84: #define PetscLogObjectCreate(h)      ((_PetscLogPHC) ? (*_PetscLogPHC)((PetscObject)h) : 0)
 85: #define PetscLogObjectDestroy(h)     ((_PetscLogPHD) ? (*_PetscLogPHD)((PetscObject)h) : 0)
 86: #define PetscLogObjectMemory(p,m)    (((PetscObject)(p))->mem += (m),0)
 87: /* Initialization functions */
 88: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogBegin(void);
 89: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogAllBegin(void);
 90: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogTraceBegin(FILE *);
 91: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogActions(PetscTruth);
 92: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogObjects(PetscTruth);
 93: /* General functions */
 94: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogGetRGBColor(const char*[]);
 95: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogDestroy(void);
 96: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogSet(PetscErrorCode (*)(int, int, PetscObject, PetscObject, PetscObject, PetscObject),
 97:                    PetscErrorCode (*)(int, int, PetscObject, PetscObject, PetscObject, PetscObject));
 98: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogObjectState(PetscObject, const char[], ...)  PETSC_PRINTF_FORMAT_CHECK(2,3);
 99: /* Output functions */
100: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogPrintSummary(MPI_Comm, const char[]);
101: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogDump(const char[]);
102: /* Counter functions */
103: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetFlops(PetscLogDouble *);
104: /* Stage functions */
105: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogStageRegister(int*, const char[]);
106: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogStagePush(int);
107: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogStagePop(void);
108: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogStageSetActive(int, PetscTruth);
109: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogStageGetActive(int, PetscTruth *);
110: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogStageSetVisible(int, PetscTruth);
111: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogStageGetVisible(int, PetscTruth *);
112: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogStageGetId(const char [], int *);
113: /* Event functions */
114: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogEventRegister(PetscEvent*, const char[], PetscCookie);
115: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogEventActivate(PetscEvent);
116: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogEventDeactivate(PetscEvent);
117: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogEventSetActiveAll(PetscEvent, PetscTruth);
118: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogEventActivateClass(PetscCookie);
119: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogEventDeactivateClass(PetscCookie);
120: /* Class functions */
121: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogClassRegister(PetscCookie*, const char []);

123: /* Global counters */

140: /* We must make these structures available if we are to access the event
141:    activation flags in the PetscLogEventBegin/End() macros. If we forced a
142:    function call each time, we could leave these structures in plog.h
143: */
144: /* Default log */
145: typedef struct _StageLog *StageLog;

148: /* A simple stack (should replace) */
149: typedef struct _IntStack *IntStack;

151: /* The structures for logging performance */
152: typedef struct _EventPerfInfo {
153:   int            id;            /* The integer identifying this section */
154:   PetscTruth     active;        /* The flag to activate logging */
155:   PetscTruth     visible;       /* The flag to print info in summary */
156:   int            depth;         /* The nesting depth of the event call */
157:   int            count;         /* The number of times this section was executed */
158:   PetscLogDouble flops;         /* The flops used in this section */
159:   PetscLogDouble time;          /* The time taken for this section */
160:   PetscLogDouble numMessages;   /* The number of messages in this section */
161:   PetscLogDouble messageLength; /* The total message lengths in this section */
162:   PetscLogDouble numReductions; /* The number of reductions in this section */
163: } EventPerfInfo;

165: typedef struct _ClassPerfInfo {
166:   int            id;           /* The integer identifying this class */
167:   int            creations;    /* The number of objects of this class created */
168:   int            destructions; /* The number of objects of this class destroyed */
169:   PetscLogDouble mem;          /* The total memory allocated by objects of this class */
170:   PetscLogDouble descMem;      /* The total memory allocated by descendents of these objects */
171: } ClassPerfInfo;

173: /* The structures for logging registration */
174: typedef struct _ClassRegInfo {
175:   char            *name;   /* The class name */
176:   PetscCookie cookie; /* The integer identifying this class */
177: } ClassRegInfo;

179: typedef struct _EventRegInfo {
180:   char            *name;   /* The name of this event */
181:   PetscCookie cookie; /* The class id for this event (should maybe give class ID instead) */
182: #if defined (PETSC_HAVE_MPE)
183:   int             mpe_id_begin; /* MPE IDs that define the event */
184:   int             mpe_id_end;
185: #endif
186: } EventRegInfo;

188: typedef struct _EventRegLog *EventRegLog;
189: struct _EventRegLog {
190:   int           numEvents; /* The number of registered events */
191:   int           maxEvents; /* The maximum number of events */
192:   EventRegInfo *eventInfo; /* The registration information for each event */
193: };

195: typedef struct _EventPerfLog *EventPerfLog;
196: struct _EventPerfLog {
197:   int            numEvents; /* The number of logging events */
198:   int            maxEvents; /* The maximum number of events */
199:   EventPerfInfo *eventInfo; /* The performance information for each event */
200: };

202: /* The structure for logging class information */
203: typedef struct _ClassRegLog *ClassRegLog;
204: struct _ClassRegLog {
205:   int           numClasses; /* The number of classes registered */
206:   int           maxClasses; /* The maximum number of classes */
207:   ClassRegInfo *classInfo;  /* The structure for class information (cookies are monotonicly increasing) */
208: };

210: typedef struct _ClassPerfLog *ClassPerfLog;
211: struct _ClassPerfLog {
212:   int            numClasses; /* The number of logging classes */
213:   int            maxClasses; /* The maximum number of classes */
214:   ClassPerfInfo *classInfo;  /* The structure for class information (cookies are monotonicly increasing) */
215: };

217: /* The structures for logging in stages */
218: typedef struct _StageInfo {
219:   char         *name;     /* The stage name */
220:   PetscTruth    used;     /* The stage was pushed on this processor */
221:   EventPerfInfo perfInfo; /* The stage performance information */
222:   EventPerfLog  eventLog; /* The event information for this stage */
223:   ClassPerfLog  classLog; /* The class information for this stage */
224: } StageInfo;

226: struct _StageLog {
227:   /* Size information */
228:   int         numStages; /* The number of registered stages */
229:   int         maxStages; /* The maximum number of stages */
230:   /* Runtime information */
231:   IntStack    stack;     /* The stack for active stages */
232:   int         curStage;  /* The current stage (only used in macros so we don't call StackTop) */
233:   /* Stage specific information */
234:   StageInfo  *stageInfo; /* The information for each stage */
235:   EventRegLog eventLog;  /* The registered events */
236:   ClassRegLog classLog;  /* The registered classes */
237: };

239: #define PetscLogEventBarrierBegin(e,o1,o2,o3,o4,cm) \
240:   (((_PetscLogPLB && _stageLog->stageInfo[_stageLog->curStage].perfInfo.active &&  _stageLog->stageInfo[_stageLog->curStage].eventLog->eventInfo[e].active) ? \
241:     (PetscLogEventBegin((e),o1,o2,o3,o4) || MPI_Barrier(cm) || PetscLogEventEnd((e),o1,o2,o3,o4)) : 0 ) || \
242:    PetscLogEventBegin((e)+1,o1,o2,o3,o4))

244: #define PetscLogEventBegin(e,o1,o2,o3,o4) \
245:   (((_PetscLogPLB && _stageLog->stageInfo[_stageLog->curStage].perfInfo.active && _stageLog->stageInfo[_stageLog->curStage].eventLog->eventInfo[e].active) ? \
246:     (*_PetscLogPLB)((e),0,(PetscObject)(o1),(PetscObject)(o2),(PetscObject)(o3),(PetscObject)(o4)) : 0 ) || \
247:   PETSC_LOG_EVENT_MPE_BEGIN(e))

249: #define PetscLogEventBarrierEnd(e,o1,o2,o3,o4,cm) PetscLogEventEnd(e+1,o1,o2,o3,o4)

251: #define PetscLogEventEnd(e,o1,o2,o3,o4) \
252:   (((_PetscLogPLE && _stageLog->stageInfo[_stageLog->curStage].perfInfo.active && _stageLog->stageInfo[_stageLog->curStage].eventLog->eventInfo[e].active) ? \
253:     (*_PetscLogPLE)((e),0,(PetscObject)(o1),(PetscObject)(o2),(PetscObject)(o3),(PetscObject)(o4)) : 0 ) || \
254:   PETSC_LOG_EVENT_MPE_END(e))

256: /* Creation and destruction functions */
257: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogCreate(StageLog *);
258: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogDestroy(StageLog);
259: /* Registration functions */
260: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogRegister(StageLog, const char [], int *);
261: /* Runtime functions */
262: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogGetStageLog(StageLog *);
263: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogPush(StageLog, int);
264: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogPop(StageLog);
265: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogGetCurrent(StageLog, int *);
266: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogSetActive(StageLog, int, PetscTruth);
267: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogGetActive(StageLog, int, PetscTruth *);
268: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogSetVisible(StageLog, int, PetscTruth);
269: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogGetVisible(StageLog, int, PetscTruth *);
270: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogGetStage(StageLog, const char [], int *);
271: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogGetClassRegLog(StageLog, ClassRegLog *);
272: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogGetEventRegLog(StageLog, EventRegLog *);
273: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogGetClassPerfLog(StageLog, int, ClassPerfLog *);
274: EXTERN PetscErrorCode PETSC_DLLEXPORT StageLogGetEventPerfLog(StageLog, int, EventPerfLog *);

276: /*
277:      This does not work for MPI-Uni because our include/mpiuni/mpi.h file
278:    uses macros to defined the MPI operations. 

280:      It does not work correctly from HP-UX because it processes the 
281:    macros in a way that sometimes it double counts, hence 
282:    PETSC_HAVE_BROKEN_RECURSIVE_MACRO

284:      It does not work with Windows because winmpich lacks MPI_Type_size()
285: */
286: #if !defined(_petsc_mpi_uni) && !defined(PETSC_HAVE_BROKEN_RECURSIVE_MACRO) && !defined (PETSC_HAVE_MPI_MISSING_TYPESIZE)
287: /*
288:    Logging of MPI activities
289: */
290: #define TypeSize(buff,count,type) \
291:  (MPI_Type_size(type,&PETSC_DUMMY_SIZE) || (buff += (PetscLogDouble) ((count)*PETSC_DUMMY_SIZE),0))

293: #define MPI_Irecv(buf,count,datatype,source,tag,comm,request) \
294:  ((PETSC_DUMMY_COUNT = count,irecv_ct++,0) || TypeSize(irecv_len,PETSC_DUMMY_COUNT,datatype) || MPI_Irecv(buf,PETSC_DUMMY_COUNT,datatype,source,tag,comm,request))

296: #define MPI_Isend(buf,count,datatype,dest,tag,comm,request) \
297:  ((PETSC_DUMMY_COUNT = count,isend_ct++,0) || TypeSize(isend_len,PETSC_DUMMY_COUNT,datatype) || MPI_Isend(buf,PETSC_DUMMY_COUNT,datatype,dest,tag,comm,request))

299: #define MPI_Startall_irecv(count,number,requests) \
300:  ((irecv_ct += (PetscLogDouble)(number),0) || TypeSize(irecv_len,count,MPIU_SCALAR) || MPI_Startall(number,requests))

302: #define MPI_Startall_isend(count,number,requests) \
303:  ((isend_ct += (PetscLogDouble)(number),0) || TypeSize(isend_len,count,MPIU_SCALAR) || MPI_Startall(number,requests))

305: #define MPI_Start_isend(count,requests) \
306:  ((isend_ct++,0) || TypeSize(isend_len,count,MPIU_SCALAR) || MPI_Start(requests))

308: #define MPI_Recv(buf,count,datatype,source,tag,comm,status) \
309:  ((PETSC_DUMMY_COUNT = count,recv_ct++,0) || TypeSize(recv_len,PETSC_DUMMY_COUNT,datatype) || MPI_Recv(buf,PETSC_DUMMY_COUNT,datatype,source,tag,comm,status))

311: #define MPI_Send(buf,count,datatype,dest,tag,comm) \
312:  ((PETSC_DUMMY_COUNT = count,send_ct++,0) || TypeSize(send_len,PETSC_DUMMY_COUNT,datatype) || MPI_Send(buf,PETSC_DUMMY_COUNT,datatype,dest,tag,comm))

314: #define MPI_Wait(request,status) \
315:  ((wait_ct++,sum_of_waits_ct++,0) || MPI_Wait(request,status))
316: 
317: #define MPI_Waitany(a,b,c,d) \
318:  ((wait_any_ct++,sum_of_waits_ct++,0) || MPI_Waitany(a,b,c,d))

320: #define MPI_Waitall(count,array_of_requests,array_of_statuses) \
321:  ((PETSC_DUMMY_COUNT = count,wait_all_ct++,sum_of_waits_ct += (PetscLogDouble) (PETSC_DUMMY_COUNT),0) || MPI_Waitall(PETSC_DUMMY_COUNT,array_of_requests,array_of_statuses))
322: 
323: #define MPI_Allreduce(sendbuf,recvbuf,count,datatype,op,comm) \
324:  ((allreduce_ct++,0) || MPI_Allreduce(sendbuf,recvbuf,count,datatype,op,comm))

326: #else

328: #define MPI_Startall_irecv(count,number,requests) \
329:  (MPI_Startall(number,requests))

331: #define MPI_Startall_isend(count,number,requests) \
332:  (MPI_Startall(number,requests))

334: #define MPI_Start_isend(count,requests) \
335:  (MPI_Start(requests))

337: #endif /* !_petsc_mpi_uni && ! PETSC_HAVE_BROKEN_RECURSIVE_MACRO */

339: #else  /* ---Logging is turned off --------------------------------------------*/

341: #define PetscLogFlops(n) 0

343: /*
344:      With logging turned off, then MPE has to be turned off
345: */
346: #define PetscLogMPEBegin()         0
347: #define PetscLogMPEDump(a)         0

349: #define PetscLogEventActivate(a)   0
350: #define PetscLogEventDeactivate(a) 0

352: #define PetscLogEventActivateClass(a)   0
353: #define PetscLogEventDeactivateClass(a) 0

355: #define _PetscLogPLB                        0
356: #define _PetscLogPLE                        0
357: #define _PetscLogPHC                        0
358: #define _PetscLogPHD                        0
359: #define PetscGetFlops(a)                (*(a) = 0.0,0)
360: #define PetscLogEventBegin(e,o1,o2,o3,o4)   0
361: #define PetscLogEventEnd(e,o1,o2,o3,o4)     0
362: #define PetscLogEventBarrierBegin(e,o1,o2,o3,o4,cm) 0
363: #define PetscLogEventBarrierEnd(e,o1,o2,o3,o4,cm)   0
364: #define PetscLogObjectParent(p,c)           0
365: #define PetscLogObjectParents(p,n,c)        0
366: #define PetscLogObjectCreate(h)             0
367: #define PetscLogObjectDestroy(h)            0
368: #define PetscLogObjectMemory(p,m)           0
369: #define PetscLogDestroy()                   0
370: #define PetscLogStagePush(a)                0
371: #define PetscLogStagePop()                  0
372: #define PetscLogStageRegister(a,b)          0
373: #define PetscLogStagePrint(a,flg)           0
374: #define PetscLogPrintSummary(comm,file)     0
375: #define PetscLogBegin()                     0
376: #define PetscLogTraceBegin(file)            0
377: #define PetscLogSet(lb,le)                  0
378: #define PetscLogAllBegin()                  0
379: #define PetscLogDump(c)                     0
380: #define PetscLogEventRegister(a,b,c)        0
381: #define PetscLogObjects(a)                  0
382: #define PetscLogActions(a)                  0
383: EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLogObjectState(PetscObject,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3);

385: /* If PETSC_USE_LOG is NOT defined, these still need to be! */
386: #define MPI_Startall_irecv(count,number,requests) MPI_Startall(number,requests)
387: #define MPI_Startall_isend(count,number,requests) MPI_Startall(number,requests)
388: #define MPI_Start_isend(count,requests) MPI_Start(requests)

390: /* Creation and destruction functions */
391: #define StageLogCreate(stageLog)                     0
392: #define StageLogDestroy(stageLog)                    0
393: /* Registration functions */
394: #define StageLogRegister(stageLog, name, stage)      0
395: /* Runtime functions */
396: #define PetscLogGetStageLog(stageLog)                0
397: #define StageLogPush(stageLog, stage)                0
398: #define StageLogPop(stageLog)                        0
399: #define StageLogGetCurrent(stageLog, stage)          0
400: #define StageLogSetActive(stageLog, stage, active)   0
401: #define StageLogGetActive(stageLog, stage, active)   0
402: #define StageLogSetVisible(stageLog, stage, visible) 0
403: #define StageLogGetVisible(stageLog, stage, visible) 0
404: #define StageLogGetStage(stageLog, name, stage)      0

406: #endif   /* PETSC_USE_LOG */


411: #define PreLoadBegin(flag,name) \
412: {\
413:   PetscTruth PreLoading = flag;\
414:   int        PreLoadMax,PreLoadIt,_stageNum,_3_ierr;\
415:   _3_PetscOptionsGetTruth(PETSC_NULL,"-preload",&PreLoading,PETSC_NULL);CHKERRQ(_3_ierr);\
416:   PreLoadMax = (int)(PreLoading);\
417:   PetscPreLoadingUsed = PreLoading ? PETSC_TRUE : PetscPreLoadingUsed;\
418:   for (PreLoadIt=0; PreLoadIt<=PreLoadMax; PreLoadIt++) {\
419:     PetscPreLoadingOn = PreLoading;\
420:     _3_PetscBarrier(PETSC_NULL);CHKERRQ(_3_ierr);\
421:     if (PreLoadIt>0) {\
422:       _3_PetscLogStageGetId(name,&_stageNum);CHKERRQ(_3_ierr);\
423:     } else {\
424:       _3_PetscLogStageRegister(&_stageNum,name);CHKERRQ(_3_ierr);\
425:     }\
426:     _3_PetscLogStageSetActive(_stageNum,(PetscTruth)(!PreLoadMax || PreLoadIt));\
427:     _3_PetscLogStagePush(_stageNum);CHKERRQ(_3_ierr);

429: #define PreLoadEnd() \
430:     _3_PetscLogStagePop();CHKERRQ(_3_ierr);\
431:     PreLoading = PETSC_FALSE;\
432:   }\
433: }

435: #define PreLoadStage(name) \
436:   _3_PetscLogStagePop();CHKERRQ(_3_ierr);\
437:   if (PreLoadIt>0) {\
438:     _3_PetscLogStageGetId(name,&_stageNum);CHKERRQ(_3_ierr);\
439:   } else {\
440:     _3_PetscLogStageRegister(&_stageNum,name);CHKERRQ(_3_ierr);\
441:   }\
442:   _3_PetscLogStageSetActive(_stageNum,(PetscTruth)(!PreLoadMax || PreLoadIt));\
443:   _3_PetscLogStagePush(_stageNum);CHKERRQ(_3_ierr);

446: #endif