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