Actual source code: stageLog.c
1: #define PETSC_DLL
3: #include petsc.h
4: #include petsctime.h
5: #include plog.h
7: StageLog _stageLog = 0;
11: /*@C
12: StageInfoDestroy - This destroys a StageInfo object.
14: Not collective
16: Input Paramter:
17: . stageInfo - The StageInfo
19: Level: beginner
21: .keywords: log, stage, destroy
22: .seealso: StageLogCreate()
23: @*/
24: PetscErrorCode StageInfoDestroy(StageInfo *stageInfo)
25: {
29: PetscFree(stageInfo->name);
30: EventPerfLogDestroy(stageInfo->eventLog);
31: ClassPerfLogDestroy(stageInfo->classLog);
32: return(0);
33: }
37: /*@
38: StageLogDestroy - This destroys a StageLog object.
40: Not collective
42: Input Paramter:
43: . stageLog - The StageLog
45: Level: beginner
47: .keywords: log, stage, destroy
48: .seealso: StageLogCreate()
49: @*/
50: PetscErrorCode StageLogDestroy(StageLog stageLog)
51: {
52: int stage;
56: StackDestroy(stageLog->stack);
57: EventRegLogDestroy(stageLog->eventLog);
58: ClassRegLogDestroy(stageLog->classLog);
59: for(stage = 0; stage < stageLog->numStages; stage++) {
60: StageInfoDestroy(&stageLog->stageInfo[stage]);
61: }
62: PetscFree(stageLog->stageInfo);
63: PetscFree(stageLog);
64: return(0);
65: }
69: /*@
70: StageLogRegister - Registers a stage name for logging operations in an application code.
72: Not Collective
74: Input Parameter:
75: + stageLog - The StageLog
76: - sname - the name to associate with that stage
78: Output Parameter:
79: . stage - The stage index
81: Level: intermediate
83: .keywords: log, stage, register
84: .seealso: StageLogPush(), StageLogPop(), StageLogCreate()
85: @*/
86: PetscErrorCode StageLogRegister(StageLog stageLog, const char sname[], int *stage)
87: {
88: StageInfo *stageInfo;
89: char *str;
90: int s;
96: s = stageLog->numStages++;
97: if (stageLog->numStages > stageLog->maxStages) {
98: PetscMalloc(stageLog->maxStages*2 * sizeof(StageInfo), &stageInfo);
99: PetscMemcpy(stageInfo, stageLog->stageInfo, stageLog->maxStages * sizeof(StageInfo));
100: PetscFree(stageLog->stageInfo);
101: stageLog->stageInfo = stageInfo;
102: stageLog->maxStages *= 2;
103: }
104: /* Setup stage */
105: PetscStrallocpy(sname, &str);
106: stageLog->stageInfo[s].name = str;
107: stageLog->stageInfo[s].used = PETSC_FALSE;
108: stageLog->stageInfo[s].perfInfo.active = PETSC_TRUE;
109: stageLog->stageInfo[s].perfInfo.visible = PETSC_TRUE;
110: stageLog->stageInfo[s].perfInfo.count = 0;
111: stageLog->stageInfo[s].perfInfo.flops = 0.0;
112: stageLog->stageInfo[s].perfInfo.time = 0.0;
113: stageLog->stageInfo[s].perfInfo.numMessages = 0.0;
114: stageLog->stageInfo[s].perfInfo.messageLength = 0.0;
115: stageLog->stageInfo[s].perfInfo.numReductions = 0.0;
116: EventPerfLogCreate(&stageLog->stageInfo[s].eventLog);
117: ClassPerfLogCreate(&stageLog->stageInfo[s].classLog);
118: *stage = s;
119: return(0);
120: }
124: /*@
125: StageLogPush - This function pushes a stage on the stack.
127: Not Collective
129: Input Parameters:
130: + stageLog - The StageLog
131: - stage - The stage to log
133: Database Options:
134: . -log_summary - Activates logging
136: Usage:
137: If the option -log_sumary is used to run the program containing the
138: following code, then 2 sets of summary data will be printed during
139: PetscFinalize().
140: .vb
141: PetscInitialize(int *argc,char ***args,0,0);
142: [stage 0 of code]
143: StageLogPush(stageLog,1);
144: [stage 1 of code]
145: StageLogPop(stageLog);
146: PetscBarrier(...);
147: [more stage 0 of code]
148: PetscFinalize();
149: .ve
151: Notes:
152: Use PetscLogStageRegister() to register a stage. All previous stages are
153: accumulating time and flops, but events will only be logged in this stage.
155: Level: intermediate
157: .keywords: log, push, stage
158: .seealso: StageLogPop(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
159: @*/
160: PetscErrorCode StageLogPush(StageLog stageLog, int stage)
161: {
162: int curStage = 0;
163: PetscTruth empty;
167: if ((stage < 0) || (stage >= stageLog->numStages)) {
168: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
169: }
171: /* Record flops/time of previous stage */
172: StackEmpty(stageLog->stack, &empty);
173: if (!empty) {
174: StackTop(stageLog->stack, &curStage);
175: if (stageLog->stageInfo[curStage].perfInfo.active) {
176: PetscTimeAdd(stageLog->stageInfo[curStage].perfInfo.time);
177: stageLog->stageInfo[curStage].perfInfo.flops += _TotalFlops;
178: stageLog->stageInfo[curStage].perfInfo.numMessages += irecv_ct + isend_ct + recv_ct + send_ct;
179: stageLog->stageInfo[curStage].perfInfo.messageLength += irecv_len + isend_len + recv_len + send_len;
180: stageLog->stageInfo[curStage].perfInfo.numReductions += allreduce_ct;
181: }
182: }
183: /* Activate the stage */
184: StackPush(stageLog->stack, stage);
185: stageLog->stageInfo[stage].used = PETSC_TRUE;
186: stageLog->stageInfo[stage].perfInfo.count++;
187: stageLog->curStage = stage;
188: /* Subtract current quantities so that we obtain the difference when we pop */
189: if (stageLog->stageInfo[stage].perfInfo.active) {
190: PetscTimeSubtract(stageLog->stageInfo[stage].perfInfo.time);
191: stageLog->stageInfo[stage].perfInfo.flops -= _TotalFlops;
192: stageLog->stageInfo[stage].perfInfo.numMessages -= irecv_ct + isend_ct + recv_ct + send_ct;
193: stageLog->stageInfo[stage].perfInfo.messageLength -= irecv_len + isend_len + recv_len + send_len;
194: stageLog->stageInfo[stage].perfInfo.numReductions -= allreduce_ct;
195: }
196: return(0);
197: }
201: /*@
202: StageLogPop - This function pops a stage from the stack.
204: Not Collective
206: Input Parameter:
207: . stageLog - The StageLog
209: Usage:
210: If the option -log_sumary is used to run the program containing the
211: following code, then 2 sets of summary data will be printed during
212: PetscFinalize().
213: .vb
214: PetscInitialize(int *argc,char ***args,0,0);
215: [stage 0 of code]
216: StageLogPush(stageLog,1);
217: [stage 1 of code]
218: StageLogPop(stageLog);
219: PetscBarrier(...);
220: [more stage 0 of code]
221: PetscFinalize();
222: .ve
224: Notes:
225: Use StageLogRegister() to register a stage.
227: Level: intermediate
229: .keywords: log, pop, stage
230: .seealso: StageLogPush(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
231: @*/
232: PetscErrorCode StageLogPop(StageLog stageLog)
233: {
234: int curStage;
235: PetscTruth empty;
239: /* Record flops/time of current stage */
240: StackPop(stageLog->stack, &curStage);
241: if (stageLog->stageInfo[curStage].perfInfo.active) {
242: PetscTimeAdd(stageLog->stageInfo[curStage].perfInfo.time);
243: stageLog->stageInfo[curStage].perfInfo.flops += _TotalFlops;
244: stageLog->stageInfo[curStage].perfInfo.numMessages += irecv_ct + isend_ct + recv_ct + send_ct;
245: stageLog->stageInfo[curStage].perfInfo.messageLength += irecv_len + isend_len + recv_len + send_len;
246: stageLog->stageInfo[curStage].perfInfo.numReductions += allreduce_ct;
247: }
248: StackEmpty(stageLog->stack, &empty);
249: if (!empty) {
250: /* Subtract current quantities so that we obtain the difference when we pop */
251: StackTop(stageLog->stack, &curStage);
252: if (stageLog->stageInfo[curStage].perfInfo.active) {
253: PetscTimeSubtract(stageLog->stageInfo[curStage].perfInfo.time);
254: stageLog->stageInfo[curStage].perfInfo.flops -= _TotalFlops;
255: stageLog->stageInfo[curStage].perfInfo.numMessages -= irecv_ct + isend_ct + recv_ct + send_ct;
256: stageLog->stageInfo[curStage].perfInfo.messageLength -= irecv_len + isend_len + recv_len + send_len;
257: stageLog->stageInfo[curStage].perfInfo.numReductions -= allreduce_ct;
258: }
259: stageLog->curStage = curStage;
260: } else {
261: stageLog->curStage = -1;
262: }
263: return(0);
264: }
268: /*@
269: StageLogGetCurrent - This function returns the stage from the top of the stack.
271: Not Collective
273: Input Parameter:
274: . stageLog - The StageLog
276: Output Parameter:
277: . stage - The current stage
279: Notes:
280: If no stage is currently active, stage is set to -1.
282: Level: intermediate
284: .keywords: log, stage
285: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
286: @*/
287: PetscErrorCode StageLogGetCurrent(StageLog stageLog, int *stage)
288: {
289: PetscTruth empty;
293: StackEmpty(stageLog->stack, &empty);
294: if (empty) {
295: *stage = -1;
296: } else {
297: StackTop(stageLog->stack, stage);
298: }
299: #ifdef PETSC_USE_DEBUG
300: if (*stage != stageLog->curStage) {
301: SETERRQ2(PETSC_ERR_PLIB, "Inconsistency in stage log: stage %d should be %d", *stage, stageLog->curStage);
302: }
303: #endif
304: return(0);
305: }
309: /*@C
310: StageLogGetClassRegLog - This function returns the ClassRegLog for the given stage.
312: Not Collective
314: Input Parameters:
315: . stageLog - The StageLog
317: Output Parameter:
318: . classLog - The ClassRegLog
320: Level: intermediate
322: .keywords: log, stage
323: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
324: @*/
325: PetscErrorCode StageLogGetClassRegLog(StageLog stageLog, ClassRegLog *classLog)
326: {
329: *classLog = stageLog->classLog;
330: return(0);
331: }
335: /*@C
336: StageLogGetEventRegLog - This function returns the EventRegLog.
338: Not Collective
340: Input Parameters:
341: . stageLog - The StageLog
343: Output Parameter:
344: . eventLog - The EventRegLog
346: Level: intermediate
348: .keywords: log, stage
349: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
350: @*/
351: PetscErrorCode StageLogGetEventRegLog(StageLog stageLog, EventRegLog *eventLog)
352: {
355: *eventLog = stageLog->eventLog;
356: return(0);
357: }
361: /*@C
362: StageLogGetClassPerfLog - This function returns the ClassPerfLog for the given stage.
364: Not Collective
366: Input Parameters:
367: + stageLog - The StageLog
368: - stage - The stage
370: Output Parameter:
371: . classLog - The ClassPerfLog
373: Level: intermediate
375: .keywords: log, stage
376: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
377: @*/
378: PetscErrorCode StageLogGetClassPerfLog(StageLog stageLog, int stage, ClassPerfLog *classLog)
379: {
382: if ((stage < 0) || (stage >= stageLog->numStages)) {
383: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
384: }
385: *classLog = stageLog->stageInfo[stage].classLog;
386: return(0);
387: }
391: /*@C
392: StageLogGetEventPerfLog - This function returns the EventPerfLog for the given stage.
394: Not Collective
396: Input Parameters:
397: + stageLog - The StageLog
398: - stage - The stage
400: Output Parameter:
401: . eventLog - The EventPerfLog
403: Level: intermediate
405: .keywords: log, stage
406: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
407: @*/
408: PetscErrorCode StageLogGetEventPerfLog(StageLog stageLog, int stage, EventPerfLog *eventLog)
409: {
412: if ((stage < 0) || (stage >= stageLog->numStages)) {
413: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
414: }
415: *eventLog = stageLog->stageInfo[stage].eventLog;
416: return(0);
417: }
421: /*@
422: StageLogSetActive - This function determines whether events will be logged during this state.
424: Not Collective
426: Input Parameters:
427: + stageLog - The StageLog
428: . stage - The stage to log
429: - isActive - The activity flag, PETSC_TRUE for logging, otherwise PETSC_FALSE (default is PETSC_TRUE)
431: Level: intermediate
433: .keywords: log, active, stage
434: .seealso: StageLogGetActive(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
435: @*/
436: PetscErrorCode StageLogSetActive(StageLog stageLog, int stage, PetscTruth isActive)
437: {
439: if ((stage < 0) || (stage >= stageLog->numStages)) {
440: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
441: }
442: stageLog->stageInfo[stage].perfInfo.active = isActive;
443: return(0);
444: }
448: /*@
449: StageLogGetActive - This function returns whether events will be logged suring this stage.
451: Not Collective
453: Input Parameters:
454: + stageLog - The StageLog
455: - stage - The stage to log
457: Output Parameter:
458: . isActive - The activity flag, PETSC_TRUE for logging, otherwise PETSC_FALSE (default is PETSC_TRUE)
460: Level: intermediate
462: .keywords: log, visible, stage
463: .seealso: StageLogSetActive(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
464: @*/
465: PetscErrorCode StageLogGetActive(StageLog stageLog, int stage, PetscTruth *isActive)
466: {
468: if ((stage < 0) || (stage >= stageLog->numStages)) {
469: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
470: }
472: *isActive = stageLog->stageInfo[stage].perfInfo.active;
473: return(0);
474: }
478: /*@
479: StageLogSetVisible - This function determines whether a stage is printed during PetscLogPrintSummary()
481: Not Collective
483: Input Parameters:
484: + stageLog - The StageLog
485: . stage - The stage to log
486: - isVisible - The visibility flag, PETSC_TRUE for printing, otherwise PETSC_FALSE (default is PETSC_TRUE)
488: Database Options:
489: . -log_summary - Activates log summary
491: Level: intermediate
493: .keywords: log, visible, stage
494: .seealso: StageLogGetVisible(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
495: @*/
496: PetscErrorCode StageLogSetVisible(StageLog stageLog, int stage, PetscTruth isVisible)
497: {
499: if ((stage < 0) || (stage >= stageLog->numStages)) {
500: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
501: }
502: stageLog->stageInfo[stage].perfInfo.visible = isVisible;
503: return(0);
504: }
508: /*@
509: StageLogGetVisible - This function returns whether a stage is printed during PetscLogPrintSummary()
511: Not Collective
513: Input Parameters:
514: + stageLog - The StageLog
515: - stage - The stage to log
517: Output Parameter:
518: . isVisible - The visibility flag, PETSC_TRUE for printing, otherwise PETSC_FALSE (default is PETSC_TRUE)
520: Database Options:
521: . -log_summary - Activates log summary
523: Level: intermediate
525: .keywords: log, visible, stage
526: .seealso: StageLogSetVisible(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
527: @*/
528: PetscErrorCode StageLogGetVisible(StageLog stageLog, int stage, PetscTruth *isVisible)
529: {
531: if ((stage < 0) || (stage >= stageLog->numStages)) {
532: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
533: }
535: *isVisible = stageLog->stageInfo[stage].perfInfo.visible;
536: return(0);
537: }
541: /*@
542: StageLogGetStage - This function the stage id given the stage name.
544: Not Collective
546: Input Parameters:
547: + stageLog - The StageLog
548: - name - The stage name
550: Output Parameter:
551: . stage - The stage id
553: Level: intermediate
555: .keywords: log, stage
556: .seealso: StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
557: @*/
558: PetscErrorCode StageLogGetStage(StageLog stageLog, const char name[], int *stage)
559: {
560: PetscTruth match;
561: int s;
567: *stage = -1;
568: for(s = 0; s < stageLog->numStages; s++) {
569: PetscStrcasecmp(stageLog->stageInfo[s].name, name, &match);
570: if (match) break;
571: }
572: if (s == stageLog->numStages) SETERRQ1(PETSC_ERR_ARG_WRONG, "No stage named %s", name);
573: *stage = s;
574: return(0);
575: }
579: /*@
580: StageLogCreate - This creates a StageLog object.
582: Not collective
584: Input Parameter:
585: . stageLog - The StageLog
587: Level: beginner
589: .keywords: log, stage, create
590: .seealso: StageLogCreate()
591: @*/
592: PetscErrorCode StageLogCreate(StageLog *stageLog)
593: {
594: StageLog l;
598: PetscNew(struct _n_StageLog, &l);
599: l->numStages = 0;
600: l->maxStages = 10;
601: l->curStage = -1;
602: StackCreate(&l->stack);
603: PetscMalloc(l->maxStages * sizeof(StageInfo), &l->stageInfo);
604: EventRegLogCreate(&l->eventLog);
605: ClassRegLogCreate(&l->classLog);
606: *stageLog = l;
607: return(0);
608: }