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