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;
9: #undef __FUNCT__
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: }
34: #undef __FUNCT__
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: }
65: #undef __FUNCT__
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: }
119: #undef __FUNCT__
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: }
196: #undef __FUNCT__
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: }
263: #undef __FUNCT__
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: }
303: #undef __FUNCT__
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: }
329: #undef __FUNCT__
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: }
354: #undef __FUNCT__
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) {
376: if ((stage < 0) || (stage >= stageLog->numStages)) {
377: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
378: }
379: *classLog = stageLog->stageInfo[stage].classLog;
380: return(0);
381: }
383: #undef __FUNCT__
385: /*@C
386: StageLogGetEventPerfLog - This function returns the EventPerfLog for the given stage.
388: Not Collective
390: Input Parameters:
391: + stageLog - The StageLog
392: - stage - The stage
394: Output Parameter:
395: . eventLog - The EventPerfLog
397: Level: intermediate
399: .keywords: log, stage
400: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
401: @*/
402: int StageLogGetEventPerfLog(StageLog stageLog, int stage, EventPerfLog *eventLog) {
405: if ((stage < 0) || (stage >= stageLog->numStages)) {
406: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
407: }
408: *eventLog = stageLog->stageInfo[stage].eventLog;
409: return(0);
410: }
412: #undef __FUNCT__
414: /*@
415: StageLogSetActive - This function determines whether events will be logged during this state.
417: Not Collective
419: Input Parameters:
420: + stageLog - The StageLog
421: . stage - The stage to log
422: - isActive - The activity flag, PETSC_TRUE for logging, otherwise PETSC_FALSE (default is PETSC_TRUE)
424: Level: intermediate
426: .keywords: log, active, stage
427: .seealso: StageLogGetActive(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
428: @*/
429: int StageLogSetActive(StageLog stageLog, int stage, PetscTruth isActive) {
431: if ((stage < 0) || (stage >= stageLog->numStages)) {
432: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
433: }
434: stageLog->stageInfo[stage].perfInfo.active = isActive;
435: return(0);
436: }
438: #undef __FUNCT__
440: /*@
441: StageLogGetActive - This function returns whether events will be logged suring this stage.
443: Not Collective
445: Input Parameters:
446: + stageLog - The StageLog
447: - stage - The stage to log
449: Output Parameter:
450: . isActive - The activity flag, PETSC_TRUE for logging, otherwise PETSC_FALSE (default is PETSC_TRUE)
452: Level: intermediate
454: .keywords: log, visible, stage
455: .seealso: StageLogSetActive(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
456: @*/
457: int StageLogGetActive(StageLog stageLog, int stage, PetscTruth *isActive) {
459: if ((stage < 0) || (stage >= stageLog->numStages)) {
460: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
461: }
463: *isActive = stageLog->stageInfo[stage].perfInfo.active;
464: return(0);
465: }
467: #undef __FUNCT__
469: /*@
470: StageLogSetVisible - This function determines whether a stage is printed during PetscLogPrintSummary()
472: Not Collective
474: Input Parameters:
475: + stageLog - The StageLog
476: . stage - The stage to log
477: - isVisible - The visibility flag, PETSC_TRUE for printing, otherwise PETSC_FALSE (default is PETSC_TRUE)
479: Database Options:
480: . -log_summary - Activates log summary
482: Level: intermediate
484: .keywords: log, visible, stage
485: .seealso: StageLogGetVisible(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
486: @*/
487: int StageLogSetVisible(StageLog stageLog, int stage, PetscTruth isVisible) {
489: if ((stage < 0) || (stage >= stageLog->numStages)) {
490: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
491: }
492: stageLog->stageInfo[stage].perfInfo.visible = isVisible;
493: return(0);
494: }
496: #undef __FUNCT__
498: /*@
499: StageLogGetVisible - This function returns whether a stage is printed during PetscLogPrintSummary()
501: Not Collective
503: Input Parameters:
504: + stageLog - The StageLog
505: - stage - The stage to log
507: Output Parameter:
508: . isVisible - The visibility flag, PETSC_TRUE for printing, otherwise PETSC_FALSE (default is PETSC_TRUE)
510: Database Options:
511: . -log_summary - Activates log summary
513: Level: intermediate
515: .keywords: log, visible, stage
516: .seealso: StageLogSetVisible(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
517: @*/
518: int StageLogGetVisible(StageLog stageLog, int stage, PetscTruth *isVisible) {
520: if ((stage < 0) || (stage >= stageLog->numStages)) {
521: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
522: }
524: *isVisible = stageLog->stageInfo[stage].perfInfo.visible;
525: return(0);
526: }
528: #undef __FUNCT__
530: /*@
531: StageLogGetStage - This function the stage id given the stage name.
533: Not Collective
535: Input Parameters:
536: + stageLog - The StageLog
537: - name - The stage name
539: Output Parameter:
540: . stage - The stage id
542: Level: intermediate
544: .keywords: log, stage
545: .seealso: StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
546: @*/
547: int StageLogGetStage(StageLog stageLog, const char name[], int *stage) {
548: PetscTruth match;
549: int s;
550: int ierr;
554: *stage = -1;
555: for(s = 0; s < stageLog->numStages; s++) {
556: PetscStrcasecmp(stageLog->stageInfo[s].name, name, &match);
557: if (match == PETSC_TRUE) break;
558: }
559: if (s == stageLog->numStages) SETERRQ1(PETSC_ERR_ARG_WRONG, "No stage named %s", name);
560: *stage = s;
561: return(0);
562: }
564: #undef __FUNCT__
566: /*@
567: StageLogCreate - This creates a StageLog object.
569: Not collective
571: Input Parameter:
572: . stageLog - The StageLog
574: Level: beginner
576: .keywords: log, stage, create
577: .seealso: StageLogCreate()
578: @*/
579: int StageLogCreate(StageLog *stageLog) {
580: StageLog l;
581: int ierr;
584: PetscNew(struct _StageLog, &l);
585: l->numStages = 0;
586: l->maxStages = 10;
587: l->curStage = -1;
588: StackCreate(&l->stack);
589: PetscMalloc(l->maxStages * sizeof(StageInfo), &l->stageInfo);
590: EventRegLogCreate(&l->eventLog);
591: ClassRegLogCreate(&l->classLog);
592: *stageLog = l;
593: return(0);
594: }