Actual source code: stageLog.c
1: /* $Id: stageLog.c,v 1.1 2000/01/10 03:28:12 knepley Exp $ */
3: #include petsc.h
4: #include src/sys/src/plog/ptime.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: int StageInfoDestroy(StageInfo *stageInfo) {
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: int StageLogDestroy(StageLog stageLog) {
50: int stage;
54: StackDestroy(stageLog->stack);
55: EventRegLogDestroy(stageLog->eventLog);
56: ClassRegLogDestroy(stageLog->classLog);
57: for(stage = 0; stage < stageLog->numStages; stage++) {
58: StageInfoDestroy(&stageLog->stageInfo[stage]);
59: }
60: PetscFree(stageLog->stageInfo);
61: PetscFree(stageLog);
62: return(0);
63: }
67: /*@
68: StageLogRegister - Registers a stage name for logging operations in an application code.
70: Not Collective
72: Input Parameter:
73: + stageLog - The StageLog
74: - sname - the name to associate with that stage
76: Output Parameter:
77: . stage - The stage index
79: Level: intermediate
81: .keywords: log, stage, register
82: .seealso: StageLogPush(), StageLogPop(), StageLogCreate()
83: @*/
84: int StageLogRegister(StageLog stageLog, const char sname[], int *stage) {
85: StageInfo *stageInfo;
86: char *str;
87: int s;
88: int ierr;
93: s = stageLog->numStages++;
94: if (stageLog->numStages > stageLog->maxStages) {
95: PetscMalloc(stageLog->maxStages*2 * sizeof(StageInfo), &stageInfo);
96: PetscMemcpy(stageInfo, stageLog->stageInfo, stageLog->maxStages * sizeof(StageInfo));
97: PetscFree(stageLog->stageInfo);
98: stageLog->stageInfo = stageInfo;
99: stageLog->maxStages *= 2;
100: }
101: /* Setup stage */
102: PetscStrallocpy(sname, &str);
103: stageLog->stageInfo[s].name = str;
104: stageLog->stageInfo[s].used = PETSC_FALSE;
105: stageLog->stageInfo[s].perfInfo.active = PETSC_TRUE;
106: stageLog->stageInfo[s].perfInfo.visible = PETSC_TRUE;
107: stageLog->stageInfo[s].perfInfo.count = 0;
108: stageLog->stageInfo[s].perfInfo.flops = 0.0;
109: stageLog->stageInfo[s].perfInfo.time = 0.0;
110: stageLog->stageInfo[s].perfInfo.numMessages = 0.0;
111: stageLog->stageInfo[s].perfInfo.messageLength = 0.0;
112: stageLog->stageInfo[s].perfInfo.numReductions = 0.0;
113: EventPerfLogCreate(&stageLog->stageInfo[s].eventLog);
114: ClassPerfLogCreate(&stageLog->stageInfo[s].classLog);
115: *stage = s;
116: return(0);
117: }
121: /*@
122: StageLogPush - This function pushes a stage on the stack.
124: Not Collective
126: Input Parameters:
127: + stageLog - The StageLog
128: - stage - The stage to log
130: Database Options:
131: . -log_summary - Activates logging
133: Usage:
134: If the option -log_sumary is used to run the program containing the
135: following code, then 2 sets of summary data will be printed during
136: PetscFinalize().
137: .vb
138: PetscInitialize(int *argc,char ***args,0,0);
139: [stage 0 of code]
140: StageLogPush(stageLog,1);
141: [stage 1 of code]
142: StageLogPop(stageLog);
143: PetscBarrier(...);
144: [more stage 0 of code]
145: PetscFinalize();
146: .ve
148: Notes:
149: Use PetscLogStageRegister() to register a stage. All previous stages are
150: accumulating time and flops, but events will only be logged in this stage.
152: Level: intermediate
154: .keywords: log, push, stage
155: .seealso: StageLogPop(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
156: @*/
157: int StageLogPush(StageLog stageLog, int stage)
158: {
159: int curStage = 0;
160: PetscTruth empty;
161: int ierr;
164: if ((stage < 0) || (stage >= stageLog->numStages)) {
165: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
166: }
168: /* Record flops/time of previous stage */
169: StackEmpty(stageLog->stack, &empty);
170: if (empty == PETSC_FALSE) {
171: StackTop(stageLog->stack, &curStage);
172: if (stageLog->stageInfo[curStage].perfInfo.active) {
173: PetscTimeAdd(stageLog->stageInfo[curStage].perfInfo.time);
174: stageLog->stageInfo[curStage].perfInfo.flops += _TotalFlops;
175: stageLog->stageInfo[curStage].perfInfo.numMessages += irecv_ct + isend_ct + recv_ct + send_ct;
176: stageLog->stageInfo[curStage].perfInfo.messageLength += irecv_len + isend_len + recv_len + send_len;
177: stageLog->stageInfo[curStage].perfInfo.numReductions += allreduce_ct;
178: }
179: }
180: /* Activate the stage */
181: StackPush(stageLog->stack, stage);
182: stageLog->stageInfo[stage].used = PETSC_TRUE;
183: stageLog->stageInfo[stage].perfInfo.count++;
184: stageLog->curStage = stage;
185: /* Subtract current quantities so that we obtain the difference when we pop */
186: if (stageLog->stageInfo[stage].perfInfo.active) {
187: PetscTimeSubtract(stageLog->stageInfo[stage].perfInfo.time);
188: stageLog->stageInfo[stage].perfInfo.flops -= _TotalFlops;
189: stageLog->stageInfo[stage].perfInfo.numMessages -= irecv_ct + isend_ct + recv_ct + send_ct;
190: stageLog->stageInfo[stage].perfInfo.messageLength -= irecv_len + isend_len + recv_len + send_len;
191: stageLog->stageInfo[stage].perfInfo.numReductions -= allreduce_ct;
192: }
193: return(0);
194: }
198: /*@
199: StageLogPop - This function pops a stage from the stack.
201: Not Collective
203: Input Parameter:
204: . stageLog - The StageLog
206: Usage:
207: If the option -log_sumary is used to run the program containing the
208: following code, then 2 sets of summary data will be printed during
209: PetscFinalize().
210: .vb
211: PetscInitialize(int *argc,char ***args,0,0);
212: [stage 0 of code]
213: StageLogPush(stageLog,1);
214: [stage 1 of code]
215: StageLogPop(stageLog);
216: PetscBarrier(...);
217: [more stage 0 of code]
218: PetscFinalize();
219: .ve
221: Notes:
222: Use StageLogRegister() to register a stage.
224: Level: intermediate
226: .keywords: log, pop, stage
227: .seealso: StageLogPush(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
228: @*/
229: int StageLogPop(StageLog stageLog)
230: {
231: int curStage;
232: PetscTruth empty;
233: int ierr;
236: /* Record flops/time of current stage */
237: StackPop(stageLog->stack, &curStage);
238: if (stageLog->stageInfo[curStage].perfInfo.active) {
239: PetscTimeAdd(stageLog->stageInfo[curStage].perfInfo.time);
240: stageLog->stageInfo[curStage].perfInfo.flops += _TotalFlops;
241: stageLog->stageInfo[curStage].perfInfo.numMessages += irecv_ct + isend_ct + recv_ct + send_ct;
242: stageLog->stageInfo[curStage].perfInfo.messageLength += irecv_len + isend_len + recv_len + send_len;
243: stageLog->stageInfo[curStage].perfInfo.numReductions += allreduce_ct;
244: }
245: StackEmpty(stageLog->stack, &empty);
246: if (empty == PETSC_FALSE) {
247: /* Subtract current quantities so that we obtain the difference when we pop */
248: StackTop(stageLog->stack, &curStage);
249: if (stageLog->stageInfo[curStage].perfInfo.active) {
250: PetscTimeSubtract(stageLog->stageInfo[curStage].perfInfo.time);
251: stageLog->stageInfo[curStage].perfInfo.flops -= _TotalFlops;
252: stageLog->stageInfo[curStage].perfInfo.numMessages -= irecv_ct + isend_ct + recv_ct + send_ct;
253: stageLog->stageInfo[curStage].perfInfo.messageLength -= irecv_len + isend_len + recv_len + send_len;
254: stageLog->stageInfo[curStage].perfInfo.numReductions -= allreduce_ct;
255: }
256: stageLog->curStage = curStage;
257: } else {
258: stageLog->curStage = -1;
259: }
260: return(0);
261: }
265: /*@
266: StageLogGetCurrent - This function returns the stage from the top of the stack.
268: Not Collective
270: Input Parameter:
271: . stageLog - The StageLog
273: Output Parameter:
274: . stage - The current stage
276: Notes:
277: If no stage is currently active, stage is set to -1.
279: Level: intermediate
281: .keywords: log, stage
282: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
283: @*/
284: int StageLogGetCurrent(StageLog stageLog, int *stage) {
285: PetscTruth empty;
286: int ierr;
289: StackEmpty(stageLog->stack, &empty);
290: if (empty == PETSC_TRUE) {
291: *stage = -1;
292: } else {
293: StackTop(stageLog->stack, stage);
294: }
295: #ifdef PETSC_USE_BOPT_g
296: if (*stage != stageLog->curStage) {
297: SETERRQ2(PETSC_ERR_PLIB, "Inconsistency in stage log: stage %d should be %d", *stage, stageLog->curStage);
298: }
299: #endif
300: return(0);
301: }
305: /*@C
306: StageLogGetClassRegLog - This function returns the ClassRegLog for the given stage.
308: Not Collective
310: Input Parameters:
311: . stageLog - The StageLog
313: Output Parameter:
314: . classLog - The ClassRegLog
316: Level: intermediate
318: .keywords: log, stage
319: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
320: @*/
321: int StageLogGetClassRegLog(StageLog stageLog, ClassRegLog *classLog)
322: {
325: *classLog = stageLog->classLog;
326: return(0);
327: }
331: /*@C
332: StageLogGetEventRegLog - This function returns the EventRegLog.
334: Not Collective
336: Input Parameters:
337: . stageLog - The StageLog
339: Output Parameter:
340: . eventLog - The EventRegLog
342: Level: intermediate
344: .keywords: log, stage
345: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
346: @*/
347: int StageLogGetEventRegLog(StageLog stageLog, EventRegLog *eventLog) {
350: *eventLog = stageLog->eventLog;
351: return(0);
352: }
356: /*@C
357: StageLogGetClassPerfLog - This function returns the ClassPerfLog for the given stage.
359: Not Collective
361: Input Parameters:
362: + stageLog - The StageLog
363: - stage - The stage
365: Output Parameter:
366: . classLog - The ClassPerfLog
368: Level: intermediate
370: .keywords: log, stage
371: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
372: @*/
373: int StageLogGetClassPerfLog(StageLog stageLog, int stage, ClassPerfLog *classLog)
374: {
377: if ((stage < 0) || (stage >= stageLog->numStages)) {
378: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
379: }
380: *classLog = stageLog->stageInfo[stage].classLog;
381: return(0);
382: }
386: /*@C
387: StageLogGetEventPerfLog - This function returns the EventPerfLog for the given stage.
389: Not Collective
391: Input Parameters:
392: + stageLog - The StageLog
393: - stage - The stage
395: Output Parameter:
396: . eventLog - The EventPerfLog
398: Level: intermediate
400: .keywords: log, stage
401: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
402: @*/
403: int StageLogGetEventPerfLog(StageLog stageLog, int stage, EventPerfLog *eventLog)
404: {
407: if ((stage < 0) || (stage >= stageLog->numStages)) {
408: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
409: }
410: *eventLog = stageLog->stageInfo[stage].eventLog;
411: return(0);
412: }
416: /*@
417: StageLogSetActive - This function determines whether events will be logged during this state.
419: Not Collective
421: Input Parameters:
422: + stageLog - The StageLog
423: . stage - The stage to log
424: - isActive - The activity flag, PETSC_TRUE for logging, otherwise PETSC_FALSE (default is PETSC_TRUE)
426: Level: intermediate
428: .keywords: log, active, stage
429: .seealso: StageLogGetActive(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
430: @*/
431: int StageLogSetActive(StageLog stageLog, int stage, PetscTruth isActive) {
433: if ((stage < 0) || (stage >= stageLog->numStages)) {
434: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
435: }
436: stageLog->stageInfo[stage].perfInfo.active = isActive;
437: return(0);
438: }
442: /*@
443: StageLogGetActive - This function returns whether events will be logged suring this stage.
445: Not Collective
447: Input Parameters:
448: + stageLog - The StageLog
449: - stage - The stage to log
451: Output Parameter:
452: . isActive - The activity flag, PETSC_TRUE for logging, otherwise PETSC_FALSE (default is PETSC_TRUE)
454: Level: intermediate
456: .keywords: log, visible, stage
457: .seealso: StageLogSetActive(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
458: @*/
459: int StageLogGetActive(StageLog stageLog, int stage, PetscTruth *isActive)
460: {
462: if ((stage < 0) || (stage >= stageLog->numStages)) {
463: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
464: }
466: *isActive = stageLog->stageInfo[stage].perfInfo.active;
467: return(0);
468: }
472: /*@
473: StageLogSetVisible - This function determines whether a stage is printed during PetscLogPrintSummary()
475: Not Collective
477: Input Parameters:
478: + stageLog - The StageLog
479: . stage - The stage to log
480: - isVisible - The visibility flag, PETSC_TRUE for printing, otherwise PETSC_FALSE (default is PETSC_TRUE)
482: Database Options:
483: . -log_summary - Activates log summary
485: Level: intermediate
487: .keywords: log, visible, stage
488: .seealso: StageLogGetVisible(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
489: @*/
490: int StageLogSetVisible(StageLog stageLog, int stage, PetscTruth isVisible) {
492: if ((stage < 0) || (stage >= stageLog->numStages)) {
493: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
494: }
495: stageLog->stageInfo[stage].perfInfo.visible = isVisible;
496: return(0);
497: }
501: /*@
502: StageLogGetVisible - This function returns whether a stage is printed during PetscLogPrintSummary()
504: Not Collective
506: Input Parameters:
507: + stageLog - The StageLog
508: - stage - The stage to log
510: Output Parameter:
511: . isVisible - The visibility flag, PETSC_TRUE for printing, otherwise PETSC_FALSE (default is PETSC_TRUE)
513: Database Options:
514: . -log_summary - Activates log summary
516: Level: intermediate
518: .keywords: log, visible, stage
519: .seealso: StageLogSetVisible(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
520: @*/
521: int StageLogGetVisible(StageLog stageLog, int stage, PetscTruth *isVisible)
522: {
524: if ((stage < 0) || (stage >= stageLog->numStages)) {
525: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
526: }
528: *isVisible = stageLog->stageInfo[stage].perfInfo.visible;
529: return(0);
530: }
534: /*@
535: StageLogGetStage - This function the stage id given the stage name.
537: Not Collective
539: Input Parameters:
540: + stageLog - The StageLog
541: - name - The stage name
543: Output Parameter:
544: . stage - The stage id
546: Level: intermediate
548: .keywords: log, stage
549: .seealso: StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
550: @*/
551: int StageLogGetStage(StageLog stageLog, const char name[], int *stage)
552: {
553: PetscTruth match;
554: int s;
555: int ierr;
560: *stage = -1;
561: for(s = 0; s < stageLog->numStages; s++) {
562: PetscStrcasecmp(stageLog->stageInfo[s].name, name, &match);
563: if (match == PETSC_TRUE) break;
564: }
565: if (s == stageLog->numStages) SETERRQ1(PETSC_ERR_ARG_WRONG, "No stage named %s", name);
566: *stage = s;
567: return(0);
568: }
572: /*@
573: StageLogCreate - This creates a StageLog object.
575: Not collective
577: Input Parameter:
578: . stageLog - The StageLog
580: Level: beginner
582: .keywords: log, stage, create
583: .seealso: StageLogCreate()
584: @*/
585: int StageLogCreate(StageLog *stageLog) {
586: StageLog l;
587: int ierr;
590: PetscNew(struct _StageLog, &l);
591: l->numStages = 0;
592: l->maxStages = 10;
593: l->curStage = -1;
594: StackCreate(&l->stack);
595: PetscMalloc(l->maxStages * sizeof(StageInfo), &l->stageInfo);
596: EventRegLogCreate(&l->eventLog);
597: ClassRegLogCreate(&l->classLog);
598: *stageLog = l;
599: return(0);
600: }