Actual source code: stageLog.c

 2:  #include petsc.h
 3:  #include src/sys/src/plog/ptime.h
 4:  #include plog.h

  6: StageLog _stageLog = 0;

 10: /*@C
 11:   StageInfoDestroy - This destroys a StageInfo object.

 13:   Not collective

 15:   Input Paramter:
 16: . stageInfo - The StageInfo

 18:   Level: beginner

 20: .keywords: log, stage, destroy
 21: .seealso: StageLogCreate()
 22: @*/
 23: PetscErrorCode StageInfoDestroy(StageInfo *stageInfo)
 24: {

 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: PetscErrorCode StageLogDestroy(StageLog stageLog)
 50: {
 51:   int stage;

 55:   StackDestroy(stageLog->stack);
 56:   EventRegLogDestroy(stageLog->eventLog);
 57:   ClassRegLogDestroy(stageLog->classLog);
 58:   for(stage = 0; stage < stageLog->numStages; stage++) {
 59:     StageInfoDestroy(&stageLog->stageInfo[stage]);
 60:   }
 61:   PetscFree(stageLog->stageInfo);
 62:   PetscFree(stageLog);
 63:   return(0);
 64: }

 68: /*@
 69:   StageLogRegister - Registers a stage name for logging operations in an application code.

 71:   Not Collective

 73:   Input Parameter:
 74: + stageLog - The StageLog
 75: - sname    - the name to associate with that stage

 77:   Output Parameter:
 78: . stage    - The stage index

 80:   Level: intermediate

 82: .keywords: log, stage, register
 83: .seealso: StageLogPush(), StageLogPop(), StageLogCreate()
 84: @*/
 85: PetscErrorCode StageLogRegister(StageLog stageLog, const char sname[], int *stage)
 86: {
 87:   StageInfo *stageInfo;
 88:   char      *str;
 89:   int        s;

 95:   s = stageLog->numStages++;
 96:   if (stageLog->numStages > stageLog->maxStages) {
 97:     PetscMalloc(stageLog->maxStages*2 * sizeof(StageInfo), &stageInfo);
 98:     PetscMemcpy(stageInfo, stageLog->stageInfo, stageLog->maxStages * sizeof(StageInfo));
 99:     PetscFree(stageLog->stageInfo);
100:     stageLog->stageInfo  = stageInfo;
101:     stageLog->maxStages *= 2;
102:   }
103:   /* Setup stage */
104:   PetscStrallocpy(sname, &str);
105:   stageLog->stageInfo[s].name                   = str;
106:   stageLog->stageInfo[s].used                   = PETSC_FALSE;
107:   stageLog->stageInfo[s].perfInfo.active        = PETSC_TRUE;
108:   stageLog->stageInfo[s].perfInfo.visible       = PETSC_TRUE;
109:   stageLog->stageInfo[s].perfInfo.count         = 0;
110:   stageLog->stageInfo[s].perfInfo.flops         = 0.0;
111:   stageLog->stageInfo[s].perfInfo.time          = 0.0;
112:   stageLog->stageInfo[s].perfInfo.numMessages   = 0.0;
113:   stageLog->stageInfo[s].perfInfo.messageLength = 0.0;
114:   stageLog->stageInfo[s].perfInfo.numReductions = 0.0;
115:   EventPerfLogCreate(&stageLog->stageInfo[s].eventLog);
116:   ClassPerfLogCreate(&stageLog->stageInfo[s].classLog);
117:   *stage = s;
118:   return(0);
119: }

123: /*@
124:   StageLogPush - This function pushes a stage on the stack.

126:   Not Collective

128:   Input Parameters:
129: + stageLog   - The StageLog
130: - stage - The stage to log

132:   Database Options:
133: . -log_summary - Activates logging

135:   Usage:
136:   If the option -log_sumary is used to run the program containing the 
137:   following code, then 2 sets of summary data will be printed during
138:   PetscFinalize().
139: .vb
140:       PetscInitialize(int *argc,char ***args,0,0);
141:       [stage 0 of code]   
142:       StageLogPush(stageLog,1);
143:       [stage 1 of code]
144:       StageLogPop(stageLog);
145:       PetscBarrier(...);
146:       [more stage 0 of code]   
147:       PetscFinalize();
148: .ve

150:   Notes:
151:   Use PetscLogStageRegister() to register a stage. All previous stages are
152:   accumulating time and flops, but events will only be logged in this stage.

154:   Level: intermediate

156: .keywords: log, push, stage
157: .seealso: StageLogPop(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
158: @*/
159: PetscErrorCode StageLogPush(StageLog stageLog, int stage)
160: {
161:   int        curStage = 0;
162:   PetscTruth empty;

166:   if ((stage < 0) || (stage >= stageLog->numStages)) {
167:     SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
168:   }

170:   /* Record flops/time of previous stage */
171:   StackEmpty(stageLog->stack, &empty);
172:   if (empty == PETSC_FALSE) {
173:     StackTop(stageLog->stack, &curStage);
174:     if (stageLog->stageInfo[curStage].perfInfo.active) {
175:       PetscTimeAdd(stageLog->stageInfo[curStage].perfInfo.time);
176:       stageLog->stageInfo[curStage].perfInfo.flops         += _TotalFlops;
177:       stageLog->stageInfo[curStage].perfInfo.numMessages   += irecv_ct  + isend_ct  + recv_ct  + send_ct;
178:       stageLog->stageInfo[curStage].perfInfo.messageLength += irecv_len + isend_len + recv_len + send_len;
179:       stageLog->stageInfo[curStage].perfInfo.numReductions += allreduce_ct;
180:     }
181:   }
182:   /* Activate the stage */
183:   StackPush(stageLog->stack, stage);
184:   stageLog->stageInfo[stage].used = PETSC_TRUE;
185:   stageLog->stageInfo[stage].perfInfo.count++;
186:   stageLog->curStage = stage;
187:   /* Subtract current quantities so that we obtain the difference when we pop */
188:   if (stageLog->stageInfo[stage].perfInfo.active) {
189:     PetscTimeSubtract(stageLog->stageInfo[stage].perfInfo.time);
190:     stageLog->stageInfo[stage].perfInfo.flops         -= _TotalFlops;
191:     stageLog->stageInfo[stage].perfInfo.numMessages   -= irecv_ct  + isend_ct  + recv_ct  + send_ct;
192:     stageLog->stageInfo[stage].perfInfo.messageLength -= irecv_len + isend_len + recv_len + send_len;
193:     stageLog->stageInfo[stage].perfInfo.numReductions -= allreduce_ct;
194:   }
195:   return(0);
196: }

200: /*@
201:   StageLogPop - This function pops a stage from the stack.

203:   Not Collective

205:   Input Parameter:
206: . stageLog - The StageLog

208:   Usage:
209:   If the option -log_sumary is used to run the program containing the 
210:   following code, then 2 sets of summary data will be printed during
211:   PetscFinalize().
212: .vb
213:       PetscInitialize(int *argc,char ***args,0,0);
214:       [stage 0 of code]   
215:       StageLogPush(stageLog,1);
216:       [stage 1 of code]
217:       StageLogPop(stageLog);
218:       PetscBarrier(...);
219:       [more stage 0 of code]   
220:       PetscFinalize();
221: .ve

223:   Notes:
224:   Use StageLogRegister() to register a stage.

226:   Level: intermediate

228: .keywords: log, pop, stage
229: .seealso: StageLogPush(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
230: @*/
231: PetscErrorCode StageLogPop(StageLog stageLog)
232: {
233:   int        curStage;
234:   PetscTruth empty;

238:   /* Record flops/time of current stage */
239:   StackPop(stageLog->stack, &curStage);
240:   if (stageLog->stageInfo[curStage].perfInfo.active) {
241:     PetscTimeAdd(stageLog->stageInfo[curStage].perfInfo.time);
242:     stageLog->stageInfo[curStage].perfInfo.flops         += _TotalFlops;
243:     stageLog->stageInfo[curStage].perfInfo.numMessages   += irecv_ct  + isend_ct  + recv_ct  + send_ct;
244:     stageLog->stageInfo[curStage].perfInfo.messageLength += irecv_len + isend_len + recv_len + send_len;
245:     stageLog->stageInfo[curStage].perfInfo.numReductions += allreduce_ct;
246:   }
247:   StackEmpty(stageLog->stack, &empty);
248:   if (empty == PETSC_FALSE) {
249:     /* Subtract current quantities so that we obtain the difference when we pop */
250:     StackTop(stageLog->stack, &curStage);
251:     if (stageLog->stageInfo[curStage].perfInfo.active) {
252:       PetscTimeSubtract(stageLog->stageInfo[curStage].perfInfo.time);
253:       stageLog->stageInfo[curStage].perfInfo.flops         -= _TotalFlops;
254:       stageLog->stageInfo[curStage].perfInfo.numMessages   -= irecv_ct  + isend_ct  + recv_ct  + send_ct;
255:       stageLog->stageInfo[curStage].perfInfo.messageLength -= irecv_len + isend_len + recv_len + send_len;
256:       stageLog->stageInfo[curStage].perfInfo.numReductions -= allreduce_ct;
257:     }
258:     stageLog->curStage                           = curStage;
259:   } else {
260:     stageLog->curStage                           = -1;
261:   }
262:   return(0);
263: }

267: /*@
268:   StageLogGetCurrent - This function returns the stage from the top of the stack.

270:   Not Collective

272:   Input Parameter:
273: . stageLog - The StageLog

275:   Output Parameter:
276: . stage    - The current stage

278:   Notes:
279:   If no stage is currently active, stage is set to -1.

281:   Level: intermediate

283: .keywords: log, stage
284: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
285: @*/
286: PetscErrorCode StageLogGetCurrent(StageLog stageLog, int *stage)
287: {
288:   PetscTruth empty;

292:   StackEmpty(stageLog->stack, &empty);
293:   if (empty == PETSC_TRUE) {
294:     *stage = -1;
295:   } else {
296:     StackTop(stageLog->stack, stage);
297:   }
298: #ifdef PETSC_USE_BOPT_g
299:   if (*stage != stageLog->curStage) {
300:     SETERRQ2(PETSC_ERR_PLIB, "Inconsistency in stage log: stage %d should be %d", *stage, stageLog->curStage);
301:   }
302: #endif
303:   return(0);
304: }

308: /*@C
309:   StageLogGetClassRegLog - This function returns the ClassRegLog for the given stage.

311:   Not Collective

313:   Input Parameters:
314: . stageLog - The StageLog

316:   Output Parameter:
317: . classLog - The ClassRegLog

319:   Level: intermediate

321: .keywords: log, stage
322: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
323: @*/
324: PetscErrorCode StageLogGetClassRegLog(StageLog stageLog, ClassRegLog *classLog)
325: {
328:   *classLog = stageLog->classLog;
329:   return(0);
330: }

334: /*@C
335:   StageLogGetEventRegLog - This function returns the EventRegLog.

337:   Not Collective

339:   Input Parameters:
340: . stageLog - The StageLog

342:   Output Parameter:
343: . eventLog - The EventRegLog

345:   Level: intermediate

347: .keywords: log, stage
348: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
349: @*/
350: PetscErrorCode StageLogGetEventRegLog(StageLog stageLog, EventRegLog *eventLog)
351: {
354:   *eventLog = stageLog->eventLog;
355:   return(0);
356: }

360: /*@C
361:   StageLogGetClassPerfLog - This function returns the ClassPerfLog for the given stage.

363:   Not Collective

365:   Input Parameters:
366: + stageLog - The StageLog
367: - stage    - The stage

369:   Output Parameter:
370: . classLog - The ClassPerfLog

372:   Level: intermediate

374: .keywords: log, stage
375: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
376: @*/
377: PetscErrorCode StageLogGetClassPerfLog(StageLog stageLog, int stage, ClassPerfLog *classLog)
378: {
381:   if ((stage < 0) || (stage >= stageLog->numStages)) {
382:     SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
383:   }
384:   *classLog = stageLog->stageInfo[stage].classLog;
385:   return(0);
386: }

390: /*@C
391:   StageLogGetEventPerfLog - This function returns the EventPerfLog for the given stage.

393:   Not Collective

395:   Input Parameters:
396: + stageLog - The StageLog
397: - stage    - The stage

399:   Output Parameter:
400: . eventLog - The EventPerfLog

402:   Level: intermediate

404: .keywords: log, stage
405: .seealso: StageLogPush(), StageLogPop(), PetscLogGetStageLog()
406: @*/
407: PetscErrorCode StageLogGetEventPerfLog(StageLog stageLog, int stage, EventPerfLog *eventLog)
408: {
411:   if ((stage < 0) || (stage >= stageLog->numStages)) {
412:     SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
413:   }
414:   *eventLog = stageLog->stageInfo[stage].eventLog;
415:   return(0);
416: }

420: /*@
421:   StageLogSetActive - This function determines whether events will be logged during this state.

423:   Not Collective

425:   Input Parameters:
426: + stageLog - The StageLog
427: . stage    - The stage to log
428: - isActive - The activity flag, PETSC_TRUE for logging, otherwise PETSC_FALSE (default is PETSC_TRUE)

430:   Level: intermediate

432: .keywords: log, active, stage
433: .seealso: StageLogGetActive(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
434: @*/
435: PetscErrorCode StageLogSetActive(StageLog stageLog, int stage, PetscTruth isActive)
436: {
438:   if ((stage < 0) || (stage >= stageLog->numStages)) {
439:     SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
440:   }
441:   stageLog->stageInfo[stage].perfInfo.active = isActive;
442:   return(0);
443: }

447: /*@
448:   StageLogGetActive - This function returns whether events will be logged suring this stage.

450:   Not Collective

452:   Input Parameters:
453: + stageLog - The StageLog
454: - stage    - The stage to log

456:   Output Parameter:
457: . isActive - The activity flag, PETSC_TRUE for logging, otherwise PETSC_FALSE (default is PETSC_TRUE)

459:   Level: intermediate

461: .keywords: log, visible, stage
462: .seealso: StageLogSetActive(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
463: @*/
464: PetscErrorCode StageLogGetActive(StageLog stageLog, int stage, PetscTruth *isActive)
465: {
467:   if ((stage < 0) || (stage >= stageLog->numStages)) {
468:     SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
469:   }
471:   *isActive = stageLog->stageInfo[stage].perfInfo.active;
472:   return(0);
473: }

477: /*@
478:   StageLogSetVisible - This function determines whether a stage is printed during PetscLogPrintSummary()

480:   Not Collective

482:   Input Parameters:
483: + stageLog  - The StageLog
484: . stage     - The stage to log
485: - isVisible - The visibility flag, PETSC_TRUE for printing, otherwise PETSC_FALSE (default is PETSC_TRUE)

487:   Database Options:
488: . -log_summary - Activates log summary

490:   Level: intermediate

492: .keywords: log, visible, stage
493: .seealso: StageLogGetVisible(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
494: @*/
495: PetscErrorCode StageLogSetVisible(StageLog stageLog, int stage, PetscTruth isVisible)
496: {
498:   if ((stage < 0) || (stage >= stageLog->numStages)) {
499:     SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
500:   }
501:   stageLog->stageInfo[stage].perfInfo.visible = isVisible;
502:   return(0);
503: }

507: /*@
508:   StageLogGetVisible - This function returns whether a stage is printed during PetscLogPrintSummary()

510:   Not Collective

512:   Input Parameters:
513: + stageLog  - The StageLog
514: - stage     - The stage to log

516:   Output Parameter:
517: . isVisible - The visibility flag, PETSC_TRUE for printing, otherwise PETSC_FALSE (default is PETSC_TRUE)

519:   Database Options:
520: . -log_summary - Activates log summary

522:   Level: intermediate

524: .keywords: log, visible, stage
525: .seealso: StageLogSetVisible(), StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
526: @*/
527: PetscErrorCode StageLogGetVisible(StageLog stageLog, int stage, PetscTruth *isVisible)
528: {
530:   if ((stage < 0) || (stage >= stageLog->numStages)) {
531:     SETERRQ2(PETSC_ERR_ARG_OUTOFRANGE, "Invalid stage %d should be in [0,%d)", stage, stageLog->numStages);
532:   }
534:   *isVisible = stageLog->stageInfo[stage].perfInfo.visible;
535:   return(0);
536: }

540: /*@
541:   StageLogGetStage - This function the stage id given the stage name.

543:   Not Collective

545:   Input Parameters:
546: + stageLog - The StageLog
547: - name     - The stage name

549:   Output Parameter:
550: . stage    - The stage id

552:   Level: intermediate

554: .keywords: log, stage
555: .seealso: StageLogGetCurrent(), StageLogRegister(), PetscLogGetStageLog()
556: @*/
557: PetscErrorCode StageLogGetStage(StageLog stageLog, const char name[], int *stage)
558: {
559:   PetscTruth match;
560:   int        s;

566:   *stage = -1;
567:   for(s = 0; s < stageLog->numStages; s++) {
568:     PetscStrcasecmp(stageLog->stageInfo[s].name, name, &match);
569:     if (match == PETSC_TRUE) break;
570:   }
571:   if (s == stageLog->numStages) SETERRQ1(PETSC_ERR_ARG_WRONG, "No stage named %s", name);
572:   *stage = s;
573:   return(0);
574: }

578: /*@
579:   StageLogCreate - This creates a StageLog object.

581:   Not collective

583:   Input Parameter:
584: . stageLog - The StageLog

586:   Level: beginner

588: .keywords: log, stage, create
589: .seealso: StageLogCreate()
590: @*/
591: PetscErrorCode StageLogCreate(StageLog *stageLog)
592: {
593:   StageLog l;

597:   PetscNew(struct _StageLog, &l);
598:   l->numStages = 0;
599:   l->maxStages = 10;
600:   l->curStage  = -1;
601:   StackCreate(&l->stack);
602:   PetscMalloc(l->maxStages * sizeof(StageInfo), &l->stageInfo);
603:   EventRegLogCreate(&l->eventLog);
604:   ClassRegLogCreate(&l->classLog);
605:   *stageLog = l;
606:   return(0);
607: }