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: /*@C
10: StageInfoDestroy - This destroys a StageInfo object.
12: Not collective
14: Input Paramter:
15: . stageInfo - The StageInfo
17: Level: beginner
19: .keywords: log, stage, destroy
20: .seealso: StageLogCreate()
21: @*/
22: int StageInfoDestroy(StageInfo *stageInfo) {
26: PetscFree(stageInfo->name);
27: EventPerfLogDestroy(stageInfo->eventLog);
28: ClassPerfLogDestroy(stageInfo->classLog);
29: return(0);
30: }
32: /*@
33: StageLogDestroy - This destroys a StageLog object.
35: Not collective
37: Input Paramter:
38: . stageLog - The StageLog
40: Level: beginner
42: .keywords: log, stage, destroy
43: .seealso: StageLogCreate()
44: @*/
45: int StageLogDestroy(StageLog stageLog) {
46: int stage;
50: StackDestroy(stageLog->stack);
51: EventRegLogDestroy(stageLog->eventLog);
52: ClassRegLogDestroy(stageLog->classLog);
53: for(stage = 0; stage < stageLog->numStages; stage++) {
54: StageInfoDestroy(&stageLog->stageInfo[stage]);
55: }
56: PetscFree(stageLog->stageInfo);
57: PetscFree(stageLog);
58: return(0);
59: }
61: /*@
62: StageLogRegister - Registers a stage name for logging operations in an application code.
64: Not Collective
66: Input Parameter:
67: + stageLog - The StageLog
68: - sname - the name to associate with that stage
70: Output Parameter:
71: . stage - The stage index
73: Level: intermediate
75: .keywords: log, stage, register
76: .seealso: StageLogPush(), StageLogPop(), StageLogCreate()
77: @*/
78: int StageLogRegister(StageLog stageLog, const char sname[], int *stage) {
79: StageInfo *stageInfo;
80: char *str;
81: int s;
82: int ierr;
87: s = stageLog->numStages++;
88: if (stageLog->numStages > stageLog->maxStages) {
89: PetscMalloc(stageLog->maxStages*2 * sizeof(StageInfo), &stageInfo);
90: PetscMemcpy(stageInfo, stageLog->stageInfo, stageLog->maxStages * sizeof(StageInfo));
91: PetscFree(stageLog->stageInfo);
92: stageLog->stageInfo = stageInfo;
93: stageLog->maxStages *= 2;
94: }
95: /* Setup stage */
96: PetscStrallocpy(sname, &str);
97: stageLog->stageInfo[s].name = str;
98: stageLog->stageInfo[s].used = PETSC_FALSE;
99: stageLog->stageInfo[s].perfInfo.active = PETSC_TRUE;
100: stageLog->stageInfo[s].perfInfo.visible = PETSC_TRUE;
101: stageLog->stageInfo[s].perfInfo.count = 0;
102: stageLog->stageInfo[s].perfInfo.flops = 0.0;
103: stageLog->stageInfo[s].perfInfo.time = 0.0;
104: stageLog->stageInfo[s].perfInfo.numMessages = 0.0;
105: stageLog->stageInfo[s].perfInfo.messageLength = 0.0;
106: stageLog->stageInfo[s].perfInfo.numReductions = 0.0;
107: EventPerfLogCreate(&stageLog->stageInfo[s].eventLog);
108: ClassPerfLogCreate(&stageLog->stageInfo[s].classLog);
109: *stage = s;
110: return(0);
111: }
113: /*@
114: StageLogPush - This function pushes a stage on the stack.
116: Not Collective
118: Input Parameters:
119: + stageLog - The StageLog
120: - stage - The stage to log
122: Database Options:
123: . -log_summary - Activates logging
125: Usage:
126: If the option -log_sumary is used to run the program containing the
127: following code, then 2 sets of summary data will be printed during
128: PetscFinalize().
129: .vb
130: PetscInitialize(int *argc,char ***args,0,0);
131: [stage 0 of code]
132: StageLogPush(stageLog,1);
133: [stage 1 of code]
134: StageLogPop(stageLog);
135: PetscBarrier(...);
136: [more stage 0 of code]
137: PetscFinalize();
138: .ve
140: Notes:
141: Use PetscLogStageRegister() to register a stage. All previous stages are
142: accumulating time and flops, but events will only be logged in this stage.
144: Level: intermediate
146: .keywords: log, push, stage
147: .seealso: StageLogPop(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
148: @*/
149: int StageLogPush(StageLog stageLog, int stage)
150: {
151: int curStage = 0;
152: PetscTruth empty;
153: int ierr;
156: if ((stage < 0) || (stage >= stageLog->numStages)) {
157: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
158: }
160: /* Record flops/time of previous stage */
161: StackEmpty(stageLog->stack, &empty);
162: if (empty == PETSC_FALSE) {
163: StackTop(stageLog->stack, &curStage);
164: PetscTimeAdd(stageLog->stageInfo[curStage].perfInfo.time);
165: stageLog->stageInfo[curStage].perfInfo.flops += _TotalFlops;
166: stageLog->stageInfo[curStage].perfInfo.numMessages += irecv_ct + isend_ct + recv_ct + send_ct;
167: stageLog->stageInfo[curStage].perfInfo.messageLength += irecv_len + isend_len + recv_len + send_len;
168: stageLog->stageInfo[curStage].perfInfo.numReductions += allreduce_ct;
169: }
170: /* Activate the stage */
171: StackPush(stageLog->stack, stage);
172: stageLog->stageInfo[stage].used = PETSC_TRUE;
173: stageLog->stageInfo[stage].perfInfo.count++;
174: stageLog->curStage = stage;
175: /* Subtract current quantities so that we obtain the difference when we pop */
176: PetscTimeSubtract(stageLog->stageInfo[stage].perfInfo.time);
177: stageLog->stageInfo[stage].perfInfo.flops -= _TotalFlops;
178: stageLog->stageInfo[stage].perfInfo.numMessages -= irecv_ct + isend_ct + recv_ct + send_ct;
179: stageLog->stageInfo[stage].perfInfo.messageLength -= irecv_len + isend_len + recv_len + send_len;
180: stageLog->stageInfo[stage].perfInfo.numReductions -= allreduce_ct;
181: return(0);
182: }
184: /*@
185: StageLogPop - This function pops a stage from the stack.
187: Not Collective
189: Input Parameter:
190: . stageLog - The StageLog
192: Usage:
193: If the option -log_sumary is used to run the program containing the
194: following code, then 2 sets of summary data will be printed during
195: PetscFinalize().
196: .vb
197: PetscInitialize(int *argc,char ***args,0,0);
198: [stage 0 of code]
199: StageLogPush(stageLog,1);
200: [stage 1 of code]
201: StageLogPop(stageLog);
202: PetscBarrier(...);
203: [more stage 0 of code]
204: PetscFinalize();
205: .ve
207: Notes:
208: Use StageLogRegister() to register a stage.
210: Level: intermediate
212: .keywords: log, pop, stage
213: .seealso: StageLogPush(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
214: @*/
215: int StageLogPop(StageLog stageLog)
216: {
217: int curStage;
218: PetscTruth empty;
219: int ierr;
222: /* Record flops/time of current stage */
223: StackPop(stageLog->stack, &curStage);
224: PetscTimeAdd(stageLog->stageInfo[curStage].perfInfo.time);
225: stageLog->stageInfo[curStage].perfInfo.flops += _TotalFlops;
226: stageLog->stageInfo[curStage].perfInfo.numMessages += irecv_ct + isend_ct + recv_ct + send_ct;
227: stageLog->stageInfo[curStage].perfInfo.messageLength += irecv_len + isend_len + recv_len + send_len;
228: stageLog->stageInfo[curStage].perfInfo.numReductions += allreduce_ct;
229: StackEmpty(stageLog->stack, &empty);
230: if (empty == PETSC_FALSE) {
231: /* Subtract current quantities so that we obtain the difference when we pop */
232: StackTop(stageLog->stack, &curStage);
233: PetscTimeSubtract(stageLog->stageInfo[curStage].perfInfo.time);
234: stageLog->stageInfo[curStage].perfInfo.flops -= _TotalFlops;
235: stageLog->stageInfo[curStage].perfInfo.numMessages -= irecv_ct + isend_ct + recv_ct + send_ct;
236: stageLog->stageInfo[curStage].perfInfo.messageLength -= irecv_len + isend_len + recv_len + send_len;
237: stageLog->stageInfo[curStage].perfInfo.numReductions -= allreduce_ct;
238: stageLog->curStage = curStage;
239: } else {
240: stageLog->curStage = -1;
241: }
242: return(0);
243: }
245: /*@
246: StageLogGetCurrent - This function returns the stage from the top of the stack.
248: Not Collective
250: Input Parameter:
251: . stageLog - The StageLog
253: Output Parameter:
254: . stage - The current stage
256: Notes:
257: If no stage is currently active, stage is set to -1.
259: Level: intermediate
261: .keywords: log, stage
262: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
263: @*/
264: int StageLogGetCurrent(StageLog stageLog, int *stage) {
265: PetscTruth empty;
266: int ierr;
269: StackEmpty(stageLog->stack, &empty);
270: if (empty == PETSC_TRUE) {
271: *stage = -1;
272: } else {
273: StackTop(stageLog->stack, stage);
274: }
275: #ifdef PETSC_USE_BOPT_g
276: if (*stage != stageLog->curStage) {
277: SETERRQ2(PETSC_ERR_PLIB, "Inconsistency in stage log: stage %d should be %d", *stage, stageLog->curStage);
278: }
279: #endif
280: return(0);
281: }
283: /*@C
284: StageLogGetClassRegLog - This function returns the ClassRegLog for the given stage.
286: Not Collective
288: Input Parameters:
289: . stageLog - The StageLog
291: Output Parameter:
292: . classLog - The ClassRegLog
294: Level: intermediate
296: .keywords: log, stage
297: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
298: @*/
299: int StageLogGetClassRegLog(StageLog stageLog, ClassRegLog *classLog)
300: {
303: *classLog = stageLog->classLog;
304: return(0);
305: }
307: /*@C
308: StageLogGetEventRegLog - This function returns the EventRegLog.
310: Not Collective
312: Input Parameters:
313: . stageLog - The StageLog
315: Output Parameter:
316: . eventLog - The EventRegLog
318: Level: intermediate
320: .keywords: log, stage
321: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
322: @*/
323: int StageLogGetEventRegLog(StageLog stageLog, EventRegLog *eventLog) {
326: *eventLog = stageLog->eventLog;
327: return(0);
328: }
330: /*@C
331: StageLogGetClassPerfLog - This function returns the ClassPerfLog for the given stage.
333: Not Collective
335: Input Parameters:
336: + stageLog - The StageLog
337: - stage - The stage
339: Output Parameter:
340: . classLog - The ClassPerfLog
342: Level: intermediate
344: .keywords: log, stage
345: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
346: @*/
347: int StageLogGetClassPerfLog(StageLog stageLog, int stage, ClassPerfLog *classLog) {
350: if ((stage < 0) || (stage >= stageLog->numStages)) {
351: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
352: }
353: *classLog = stageLog->stageInfo[stage].classLog;
354: return(0);
355: }
357: /*@C
358: StageLogGetEventPerfLog - This function returns the EventPerfLog for the given stage.
360: Not Collective
362: Input Parameters:
363: + stageLog - The StageLog
364: - stage - The stage
366: Output Parameter:
367: . eventLog - The EventPerfLog
369: Level: intermediate
371: .keywords: log, stage
372: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
373: @*/
374: int StageLogGetEventPerfLog(StageLog stageLog, int stage, EventPerfLog *eventLog) {
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: *eventLog = stageLog->stageInfo[stage].eventLog;
381: return(0);
382: }
384: /*@
385: StageLogSetActive - This function determines whether events will be logged during this state.
387: Not Collective
389: Input Parameters:
390: + stageLog - The StageLog
391: . stage - The stage to log
392: - isActive - The activity flag, PETSC_TRUE for logging, otherwise PETSC_FALSE (default is PETSC_TRUE)
394: Level: intermediate
396: .keywords: log, active, stage
397: .seealso: StageLogGetActive(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
398: @*/
399: int StageLogSetActive(StageLog stageLog, int stage, PetscTruth isActive) {
401: if ((stage < 0) || (stage >= stageLog->numStages)) {
402: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
403: }
404: stageLog->stageInfo[stage].perfInfo.active = isActive;
405: return(0);
406: }
408: /*@
409: StageLogGetActive - This function returns whether events will be logged suring this stage.
411: Not Collective
413: Input Parameters:
414: + stageLog - The StageLog
415: - stage - The stage to log
417: Output Parameter:
418: . isActive - The activity flag, PETSC_TRUE for logging, otherwise PETSC_FALSE (default is PETSC_TRUE)
420: Level: intermediate
422: .keywords: log, visible, stage
423: .seealso: StageLogSetActive(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
424: @*/
425: int StageLogGetActive(StageLog stageLog, int stage, PetscTruth *isActive) {
427: if ((stage < 0) || (stage >= stageLog->numStages)) {
428: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
429: }
431: *isActive = stageLog->stageInfo[stage].perfInfo.active;
432: return(0);
433: }
435: /*@
436: StageLogSetVisible - This function determines whether a stage is printed during PetscLogPrintSummary()
438: Not Collective
440: Input Parameters:
441: + stageLog - The StageLog
442: . stage - The stage to log
443: - isVisible - The visibility flag, PETSC_TRUE for printing, otherwise PETSC_FALSE (default is PETSC_TRUE)
445: Database Options:
446: . -log_summary - Activates log summary
448: Level: intermediate
450: .keywords: log, visible, stage
451: .seealso: StageLogGetVisible(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
452: @*/
453: int StageLogSetVisible(StageLog stageLog, int stage, PetscTruth isVisible) {
455: if ((stage < 0) || (stage >= stageLog->numStages)) {
456: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
457: }
458: stageLog->stageInfo[stage].perfInfo.visible = isVisible;
459: return(0);
460: }
462: /*@
463: StageLogGetVisible - This function returns whether a stage is printed during PetscLogPrintSummary()
465: Not Collective
467: Input Parameters:
468: + stageLog - The StageLog
469: - stage - The stage to log
471: Output Parameter:
472: . isVisible - The visibility flag, PETSC_TRUE for printing, otherwise PETSC_FALSE (default is PETSC_TRUE)
474: Database Options:
475: . -log_summary - Activates log summary
477: Level: intermediate
479: .keywords: log, visible, stage
480: .seealso: StageLogSetVisible(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
481: @*/
482: int StageLogGetVisible(StageLog stageLog, int stage, PetscTruth *isVisible) {
484: if ((stage < 0) || (stage >= stageLog->numStages)) {
485: SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
486: }
488: *isVisible = stageLog->stageInfo[stage].perfInfo.visible;
489: return(0);
490: }
492: /*@
493: StageLogGetStage - This function the stage id given the stage name.
495: Not Collective
497: Input Parameters:
498: + stageLog - The StageLog
499: - name - The stage name
501: Output Parameter:
502: . stage - The stage id
504: Level: intermediate
506: .keywords: log, stage
507: .seealso: StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
508: @*/
509: int StageLogGetStage(StageLog stageLog, const char name[], int *stage) {
510: PetscTruth match;
511: int s;
512: int ierr;
516: *stage = -1;
517: for(s = 0; s < stageLog->numStages; s++) {
518: PetscStrcasecmp(stageLog->stageInfo[s].name, name, &match);
519: if (match == PETSC_TRUE) break;
520: }
521: if (s == stageLog->numStages) SETERRQ1(PETSC_ERR_ARG_WRONG, "No stage named %s", name);
522: *stage = s;
523: return(0);
524: }
526: /*@
527: StageLogCreate - This creates a StageLog object.
529: Not collective
531: Input Parameter:
532: . stageLog - The StageLog
534: Level: beginner
536: .keywords: log, stage, create
537: .seealso: StageLogCreate()
538: @*/
539: int StageLogCreate(StageLog *stageLog) {
540: StageLog l;
541: int ierr;
544: PetscNew(struct _StageLog, &l);
545: l->numStages = 0;
546: l->maxStages = 10;
547: l->curStage = -1;
548: StackCreate(&l->stack);
549: PetscMalloc(l->maxStages * sizeof(StageInfo), &l->stageInfo);
550: EventRegLogCreate(&l->eventLog);
551: ClassRegLogCreate(&l->classLog);
552: *stageLog = l;
553: return(0);
554: }