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: }