Actual source code: stageLog.c
2: #include petsc.h
3: #include src/sys/src/plog/ptime.h
4: #include plog.h
6: StageLog _stageLog = 0;
10: /*@C
11: StageInfoDestroy - This destroys a StageInfo object.
13: Not collective
15: Input Paramter:
16: . stageInfo - The StageInfo
18: Level: beginner
20: .keywords: log, stage, destroy
21: .seealso: StageLogCreate()
22: @*/
23: PetscErrorCode StageInfoDestroy(StageInfo *stageInfo)
24: {
28: PetscFree(stageInfo->name);
29: EventPerfLogDestroy(stageInfo->eventLog);
30: ClassPerfLogDestroy(stageInfo->classLog);
31: return(0);
32: }
36: /*@
37: StageLogDestroy - This destroys a StageLog object.
39: Not collective
41: Input Paramter:
42: . stageLog - The StageLog
44: Level: beginner
46: .keywords: log, stage, destroy
47: .seealso: StageLogCreate()
48: @*/
49: PetscErrorCode StageLogDestroy(StageLog stageLog)
50: {
51: int stage;
55: StackDestroy(stageLog->stack);
56: EventRegLogDestroy(stageLog->eventLog);
57: ClassRegLogDestroy(stageLog->classLog);
58: for(stage = 0; stage < stageLog->numStages; stage++) {
59: StageInfoDestroy(&stageLog->stageInfo[stage]);
60: }
61: PetscFree(stageLog->stageInfo);
62: PetscFree(stageLog);
63: return(0);
64: }
68: /*@
69: StageLogRegister - Registers a stage name for logging operations in an application code.
71: Not Collective
73: Input Parameter:
74: + stageLog - The StageLog
75: - sname - the name to associate with that stage
77: Output Parameter:
78: . stage - The stage index
80: Level: intermediate
82: .keywords: log, stage, register
83: .seealso: StageLogPush(), StageLogPop(), StageLogCreate()
84: @*/
85: PetscErrorCode StageLogRegister(StageLog stageLog, const char sname[], int *stage)
86: {
87: StageInfo *stageInfo;
88: char *str;
89: int s;
95: s = stageLog->numStages++;
96: if (stageLog->numStages > stageLog->maxStages) {
97: PetscMalloc(stageLog->maxStages*2 * sizeof(StageInfo), &stageInfo);
98: PetscMemcpy(stageInfo, stageLog->stageInfo, stageLog->maxStages * sizeof(StageInfo));
99: PetscFree(stageLog->stageInfo);
100: stageLog->stageInfo = stageInfo;
101: stageLog->maxStages *= 2;
102: }
103: /* Setup stage */
104: PetscStrallocpy(sname, &str);
105: stageLog->stageInfo[s].name = str;
106: stageLog->stageInfo[s].used = PETSC_FALSE;
107: stageLog->stageInfo[s].perfInfo.active = PETSC_TRUE;
108: stageLog->stageInfo[s].perfInfo.visible = PETSC_TRUE;
109: stageLog->stageInfo[s].perfInfo.count = 0;
110: stageLog->stageInfo[s].perfInfo.flops = 0.0;
111: stageLog->stageInfo[s].perfInfo.time = 0.0;
112: stageLog->stageInfo[s].perfInfo.numMessages = 0.0;
113: stageLog->stageInfo[s].perfInfo.messageLength = 0.0;
114: stageLog->stageInfo[s].perfInfo.numReductions = 0.0;
115: EventPerfLogCreate(&stageLog->stageInfo[s].eventLog);
116: ClassPerfLogCreate(&stageLog->stageInfo[s].classLog);
117: *stage = s;
118: return(0);
119: }
123: /*@
124: StageLogPush - This function pushes a stage on the stack.
126: Not Collective
128: Input Parameters:
129: + stageLog - The StageLog
130: - stage - The stage to log
132: Database Options:
133: . -log_summary - Activates logging
135: Usage:
136: If the option -log_sumary is used to run the program containing the
137: following code, then 2 sets of summary data will be printed during
138: PetscFinalize().
139: .vb
140: PetscInitialize(int *argc,char ***args,0,0);
141: [stage 0 of code]
142: StageLogPush(stageLog,1);
143: [stage 1 of code]
144: StageLogPop(stageLog);
145: PetscBarrier(...);
146: [more stage 0 of code]
147: PetscFinalize();
148: .ve
150: Notes:
151: Use PetscLogStageRegister() to register a stage. All previous stages are
152: accumulating time and flops, but events will only be logged in this stage.
154: Level: intermediate
156: .keywords: log, push, stage
157: .seealso: StageLogPop(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
158: @*/
159: PetscErrorCode StageLogPush(StageLog stageLog, int stage)
160: {
161: int curStage = 0;
162: PetscTruth empty;
166: if ((stage < 0) || (stage >= stageLog->numStages)) {
167: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
168: }
170: /* Record flops/time of previous stage */
171: StackEmpty(stageLog->stack, &empty);
172: if (empty == PETSC_FALSE) {
173: StackTop(stageLog->stack, &curStage);
174: if (stageLog->stageInfo[curStage].perfInfo.active) {
175: PetscTimeAdd(stageLog->stageInfo[curStage].perfInfo.time);
176: stageLog->stageInfo[curStage].perfInfo.flops += _TotalFlops;
177: stageLog->stageInfo[curStage].perfInfo.numMessages += irecv_ct + isend_ct + recv_ct + send_ct;
178: stageLog->stageInfo[curStage].perfInfo.messageLength += irecv_len + isend_len + recv_len + send_len;
179: stageLog->stageInfo[curStage].perfInfo.numReductions += allreduce_ct;
180: }
181: }
182: /* Activate the stage */
183: StackPush(stageLog->stack, stage);
184: stageLog->stageInfo[stage].used = PETSC_TRUE;
185: stageLog->stageInfo[stage].perfInfo.count++;
186: stageLog->curStage = stage;
187: /* Subtract current quantities so that we obtain the difference when we pop */
188: if (stageLog->stageInfo[stage].perfInfo.active) {
189: PetscTimeSubtract(stageLog->stageInfo[stage].perfInfo.time);
190: stageLog->stageInfo[stage].perfInfo.flops -= _TotalFlops;
191: stageLog->stageInfo[stage].perfInfo.numMessages -= irecv_ct + isend_ct + recv_ct + send_ct;
192: stageLog->stageInfo[stage].perfInfo.messageLength -= irecv_len + isend_len + recv_len + send_len;
193: stageLog->stageInfo[stage].perfInfo.numReductions -= allreduce_ct;
194: }
195: return(0);
196: }
200: /*@
201: StageLogPop - This function pops a stage from the stack.
203: Not Collective
205: Input Parameter:
206: . stageLog - The StageLog
208: Usage:
209: If the option -log_sumary is used to run the program containing the
210: following code, then 2 sets of summary data will be printed during
211: PetscFinalize().
212: .vb
213: PetscInitialize(int *argc,char ***args,0,0);
214: [stage 0 of code]
215: StageLogPush(stageLog,1);
216: [stage 1 of code]
217: StageLogPop(stageLog);
218: PetscBarrier(...);
219: [more stage 0 of code]
220: PetscFinalize();
221: .ve
223: Notes:
224: Use StageLogRegister() to register a stage.
226: Level: intermediate
228: .keywords: log, pop, stage
229: .seealso: StageLogPush(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
230: @*/
231: PetscErrorCode StageLogPop(StageLog stageLog)
232: {
233: int curStage;
234: PetscTruth empty;
238: /* Record flops/time of current stage */
239: StackPop(stageLog->stack, &curStage);
240: if (stageLog->stageInfo[curStage].perfInfo.active) {
241: PetscTimeAdd(stageLog->stageInfo[curStage].perfInfo.time);
242: stageLog->stageInfo[curStage].perfInfo.flops += _TotalFlops;
243: stageLog->stageInfo[curStage].perfInfo.numMessages += irecv_ct + isend_ct + recv_ct + send_ct;
244: stageLog->stageInfo[curStage].perfInfo.messageLength += irecv_len + isend_len + recv_len + send_len;
245: stageLog->stageInfo[curStage].perfInfo.numReductions += allreduce_ct;
246: }
247: StackEmpty(stageLog->stack, &empty);
248: if (empty == PETSC_FALSE) {
249: /* Subtract current quantities so that we obtain the difference when we pop */
250: StackTop(stageLog->stack, &curStage);
251: if (stageLog->stageInfo[curStage].perfInfo.active) {
252: PetscTimeSubtract(stageLog->stageInfo[curStage].perfInfo.time);
253: stageLog->stageInfo[curStage].perfInfo.flops -= _TotalFlops;
254: stageLog->stageInfo[curStage].perfInfo.numMessages -= irecv_ct + isend_ct + recv_ct + send_ct;
255: stageLog->stageInfo[curStage].perfInfo.messageLength -= irecv_len + isend_len + recv_len + send_len;
256: stageLog->stageInfo[curStage].perfInfo.numReductions -= allreduce_ct;
257: }
258: stageLog->curStage = curStage;
259: } else {
260: stageLog->curStage = -1;
261: }
262: return(0);
263: }
267: /*@
268: StageLogGetCurrent - This function returns the stage from the top of the stack.
270: Not Collective
272: Input Parameter:
273: . stageLog - The StageLog
275: Output Parameter:
276: . stage - The current stage
278: Notes:
279: If no stage is currently active, stage is set to -1.
281: Level: intermediate
283: .keywords: log, stage
284: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
285: @*/
286: PetscErrorCode StageLogGetCurrent(StageLog stageLog, int *stage)
287: {
288: PetscTruth empty;
292: StackEmpty(stageLog->stack, &empty);
293: if (empty == PETSC_TRUE) {
294: *stage = -1;
295: } else {
296: StackTop(stageLog->stack, stage);
297: }
298: #ifdef PETSC_USE_BOPT_g
299: if (*stage != stageLog->curStage) {
300: SETERRQ2(PETSC_ERR_PLIB, "Inconsistency in stage log: stage %d should be %d", *stage, stageLog->curStage);
301: }
302: #endif
303: return(0);
304: }
308: /*@C
309: StageLogGetClassRegLog - This function returns the ClassRegLog for the given stage.
311: Not Collective
313: Input Parameters:
314: . stageLog - The StageLog
316: Output Parameter:
317: . classLog - The ClassRegLog
319: Level: intermediate
321: .keywords: log, stage
322: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
323: @*/
324: PetscErrorCode StageLogGetClassRegLog(StageLog stageLog, ClassRegLog *classLog)
325: {
328: *classLog = stageLog->classLog;
329: return(0);
330: }
334: /*@C
335: StageLogGetEventRegLog - This function returns the EventRegLog.
337: Not Collective
339: Input Parameters:
340: . stageLog - The StageLog
342: Output Parameter:
343: . eventLog - The EventRegLog
345: Level: intermediate
347: .keywords: log, stage
348: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
349: @*/
350: PetscErrorCode StageLogGetEventRegLog(StageLog stageLog, EventRegLog *eventLog)
351: {
354: *eventLog = stageLog->eventLog;
355: return(0);
356: }
360: /*@C
361: StageLogGetClassPerfLog - This function returns the ClassPerfLog for the given stage.
363: Not Collective
365: Input Parameters:
366: + stageLog - The StageLog
367: - stage - The stage
369: Output Parameter:
370: . classLog - The ClassPerfLog
372: Level: intermediate
374: .keywords: log, stage
375: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
376: @*/
377: PetscErrorCode StageLogGetClassPerfLog(StageLog stageLog, int stage, ClassPerfLog *classLog)
378: {
381: if ((stage < 0) || (stage >= stageLog->numStages)) {
382: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
383: }
384: *classLog = stageLog->stageInfo[stage].classLog;
385: return(0);
386: }
390: /*@C
391: StageLogGetEventPerfLog - This function returns the EventPerfLog for the given stage.
393: Not Collective
395: Input Parameters:
396: + stageLog - The StageLog
397: - stage - The stage
399: Output Parameter:
400: . eventLog - The EventPerfLog
402: Level: intermediate
404: .keywords: log, stage
405: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
406: @*/
407: PetscErrorCode StageLogGetEventPerfLog(StageLog stageLog, int stage, EventPerfLog *eventLog)
408: {
411: if ((stage < 0) || (stage >= stageLog->numStages)) {
412: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
413: }
414: *eventLog = stageLog->stageInfo[stage].eventLog;
415: return(0);
416: }
420: /*@
421: StageLogSetActive - This function determines whether events will be logged during this state.
423: Not Collective
425: Input Parameters:
426: + stageLog - The StageLog
427: . stage - The stage to log
428: - isActive - The activity flag, PETSC_TRUE for logging, otherwise PETSC_FALSE (default is PETSC_TRUE)
430: Level: intermediate
432: .keywords: log, active, stage
433: .seealso: StageLogGetActive(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
434: @*/
435: PetscErrorCode StageLogSetActive(StageLog stageLog, int stage, PetscTruth isActive)
436: {
438: if ((stage < 0) || (stage >= stageLog->numStages)) {
439: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
440: }
441: stageLog->stageInfo[stage].perfInfo.active = isActive;
442: return(0);
443: }
447: /*@
448: StageLogGetActive - This function returns whether events will be logged suring this stage.
450: Not Collective
452: Input Parameters:
453: + stageLog - The StageLog
454: - stage - The stage to log
456: Output Parameter:
457: . isActive - The activity flag, PETSC_TRUE for logging, otherwise PETSC_FALSE (default is PETSC_TRUE)
459: Level: intermediate
461: .keywords: log, visible, stage
462: .seealso: StageLogSetActive(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
463: @*/
464: PetscErrorCode StageLogGetActive(StageLog stageLog, int stage, PetscTruth *isActive)
465: {
467: if ((stage < 0) || (stage >= stageLog->numStages)) {
468: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
469: }
471: *isActive = stageLog->stageInfo[stage].perfInfo.active;
472: return(0);
473: }
477: /*@
478: StageLogSetVisible - This function determines whether a stage is printed during PetscLogPrintSummary()
480: Not Collective
482: Input Parameters:
483: + stageLog - The StageLog
484: . stage - The stage to log
485: - isVisible - The visibility flag, PETSC_TRUE for printing, otherwise PETSC_FALSE (default is PETSC_TRUE)
487: Database Options:
488: . -log_summary - Activates log summary
490: Level: intermediate
492: .keywords: log, visible, stage
493: .seealso: StageLogGetVisible(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
494: @*/
495: PetscErrorCode StageLogSetVisible(StageLog stageLog, int stage, PetscTruth isVisible)
496: {
498: if ((stage < 0) || (stage >= stageLog->numStages)) {
499: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
500: }
501: stageLog->stageInfo[stage].perfInfo.visible = isVisible;
502: return(0);
503: }
507: /*@
508: StageLogGetVisible - This function returns whether a stage is printed during PetscLogPrintSummary()
510: Not Collective
512: Input Parameters:
513: + stageLog - The StageLog
514: - stage - The stage to log
516: Output Parameter:
517: . isVisible - The visibility flag, PETSC_TRUE for printing, otherwise PETSC_FALSE (default is PETSC_TRUE)
519: Database Options:
520: . -log_summary - Activates log summary
522: Level: intermediate
524: .keywords: log, visible, stage
525: .seealso: StageLogSetVisible(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
526: @*/
527: PetscErrorCode StageLogGetVisible(StageLog stageLog, int stage, PetscTruth *isVisible)
528: {
530: if ((stage < 0) || (stage >= stageLog->numStages)) {
531: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
532: }
534: *isVisible = stageLog->stageInfo[stage].perfInfo.visible;
535: return(0);
536: }
540: /*@
541: StageLogGetStage - This function the stage id given the stage name.
543: Not Collective
545: Input Parameters:
546: + stageLog - The StageLog
547: - name - The stage name
549: Output Parameter:
550: . stage - The stage id
552: Level: intermediate
554: .keywords: log, stage
555: .seealso: StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
556: @*/
557: PetscErrorCode StageLogGetStage(StageLog stageLog, const char name[], int *stage)
558: {
559: PetscTruth match;
560: int s;
566: *stage = -1;
567: for(s = 0; s < stageLog->numStages; s++) {
568: PetscStrcasecmp(stageLog->stageInfo[s].name, name, &match);
569: if (match == PETSC_TRUE) break;
570: }
571: if (s == stageLog->numStages) SETERRQ1(PETSC_ERR_ARG_WRONG, "No stage named %s", name);
572: *stage = s;
573: return(0);
574: }
578: /*@
579: StageLogCreate - This creates a StageLog object.
581: Not collective
583: Input Parameter:
584: . stageLog - The StageLog
586: Level: beginner
588: .keywords: log, stage, create
589: .seealso: StageLogCreate()
590: @*/
591: PetscErrorCode StageLogCreate(StageLog *stageLog)
592: {
593: StageLog l;
597: PetscNew(struct _StageLog, &l);
598: l->numStages = 0;
599: l->maxStages = 10;
600: l->curStage = -1;
601: StackCreate(&l->stack);
602: PetscMalloc(l->maxStages * sizeof(StageInfo), &l->stageInfo);
603: EventRegLogCreate(&l->eventLog);
604: ClassRegLogCreate(&l->classLog);
605: *stageLog = l;
606: return(0);
607: }