Actual source code: plog.c


  2: /*
  3:       PETSc code to log object creation and destruction and PETSc events.

  5:       This provides the public API used by the rest of PETSc and by users.

  7:       These routines use a private API that is not used elsewhere in PETSc and is not
  8:       accessible to users. The private API is defined in logimpl.h and the utils directory.

 10: */
 11: #include <petsc/private/logimpl.h>
 12: #include <petsctime.h>
 13: #include <petscviewer.h>

 15: PetscErrorCode PetscLogObjectParent(PetscObject p,PetscObject c)
 16: {
 17:   if (!c || !p) return 0;
 18:   c->parent   = p;
 19:   c->parentid = p->id;
 20:   return 0;
 21: }

 23: /*@C
 24:    PetscLogObjectMemory - Adds to an object a count of additional amount of memory that is used by the object.

 26:    Not collective.

 28:    Input Parameters:
 29: +  obj  - the PETSc object
 30: -  mem  - the amount of memory that is being added to the object

 32:    Level: developer

 34:    Developer Notes:
 35:     Currently we do not always do a good job of associating all memory allocations with an object.

 37: .seealso: PetscFinalize(), PetscInitializeFortran(), PetscGetArgs(), PetscInitializeNoArguments()

 39: @*/
 40: PetscErrorCode PetscLogObjectMemory(PetscObject p,PetscLogDouble m)
 41: {
 42:   if (!p) return 0;
 43:   p->mem += m;
 44:   return 0;
 45: }

 47: PetscLogEvent PETSC_LARGEST_EVENT = PETSC_EVENT;

 49: #if defined(PETSC_USE_LOG)
 50: #include <petscmachineinfo.h>
 51: #include <petscconfiginfo.h>

 53: /* used in the MPI_XXX() count macros in petsclog.h */

 55: /* Action and object logging variables */
 56: Action    *petsc_actions            = NULL;
 57: Object    *petsc_objects            = NULL;
 58: PetscBool petsc_logActions          = PETSC_FALSE;
 59: PetscBool petsc_logObjects          = PETSC_FALSE;
 60: int       petsc_numActions          = 0, petsc_maxActions = 100;
 61: int       petsc_numObjects          = 0, petsc_maxObjects = 100;
 62: int       petsc_numObjectsDestroyed = 0;

 64: /* Global counters */
 65: PetscLogDouble petsc_BaseTime        = 0.0;
 66: PetscLogDouble petsc_TotalFlops      = 0.0;  /* The number of flops */
 67: PetscLogDouble petsc_tmp_flops       = 0.0;  /* The incremental number of flops */
 68: PetscLogDouble petsc_send_ct         = 0.0;  /* The number of sends */
 69: PetscLogDouble petsc_recv_ct         = 0.0;  /* The number of receives */
 70: PetscLogDouble petsc_send_len        = 0.0;  /* The total length of all sent messages */
 71: PetscLogDouble petsc_recv_len        = 0.0;  /* The total length of all received messages */
 72: PetscLogDouble petsc_isend_ct        = 0.0;  /* The number of immediate sends */
 73: PetscLogDouble petsc_irecv_ct        = 0.0;  /* The number of immediate receives */
 74: PetscLogDouble petsc_isend_len       = 0.0;  /* The total length of all immediate send messages */
 75: PetscLogDouble petsc_irecv_len       = 0.0;  /* The total length of all immediate receive messages */
 76: PetscLogDouble petsc_wait_ct         = 0.0;  /* The number of waits */
 77: PetscLogDouble petsc_wait_any_ct     = 0.0;  /* The number of anywaits */
 78: PetscLogDouble petsc_wait_all_ct     = 0.0;  /* The number of waitalls */
 79: PetscLogDouble petsc_sum_of_waits_ct = 0.0;  /* The total number of waits */
 80: PetscLogDouble petsc_allreduce_ct    = 0.0;  /* The number of reductions */
 81: PetscLogDouble petsc_gather_ct       = 0.0;  /* The number of gathers and gathervs */
 82: PetscLogDouble petsc_scatter_ct      = 0.0;  /* The number of scatters and scattervs */
 83: #if defined(PETSC_HAVE_DEVICE)
 84: PetscLogDouble petsc_ctog_ct         = 0.0;  /* The total number of CPU to GPU copies */
 85: PetscLogDouble petsc_gtoc_ct         = 0.0;  /* The total number of GPU to CPU copies */
 86: PetscLogDouble petsc_ctog_sz         = 0.0;  /* The total size of CPU to GPU copies */
 87: PetscLogDouble petsc_gtoc_sz         = 0.0;  /* The total size of GPU to CPU copies */
 88: PetscLogDouble petsc_ctog_ct_scalar  = 0.0;  /* The total number of CPU to GPU copies */
 89: PetscLogDouble petsc_gtoc_ct_scalar  = 0.0;  /* The total number of GPU to CPU copies */
 90: PetscLogDouble petsc_ctog_sz_scalar  = 0.0;  /* The total size of CPU to GPU copies */
 91: PetscLogDouble petsc_gtoc_sz_scalar  = 0.0;  /* The total size of GPU to CPU copies */
 92: PetscLogDouble petsc_gflops          = 0.0;  /* The flops done on a GPU */
 93: PetscLogDouble petsc_gtime           = 0.0;  /* The time spent on a GPU */

 95: #if defined(PETSC_USE_DEBUG)
 96: PetscBool petsc_gtime_inuse = PETSC_FALSE;
 97: #endif
 98: #endif

100: /* Logging functions */
101: PetscErrorCode (*PetscLogPHC)(PetscObject) = NULL;
102: PetscErrorCode (*PetscLogPHD)(PetscObject) = NULL;
103: PetscErrorCode (*PetscLogPLB)(PetscLogEvent, int, PetscObject, PetscObject, PetscObject, PetscObject) = NULL;
104: PetscErrorCode (*PetscLogPLE)(PetscLogEvent, int, PetscObject, PetscObject, PetscObject, PetscObject) = NULL;

106: /* Tracing event logging variables */
107: FILE             *petsc_tracefile            = NULL;
108: int              petsc_tracelevel            = 0;
109: const char       *petsc_traceblanks          = "                                                                                                    ";
110: char             petsc_tracespace[128]       = " ";
111: PetscLogDouble   petsc_tracetime             = 0.0;
112: static PetscBool PetscLogInitializeCalled = PETSC_FALSE;

114: PETSC_INTERN PetscErrorCode PetscLogInitialize(void)
115: {
116:   int            stage;
117:   PetscBool      opt;

121:   if (PetscLogInitializeCalled) return(0);
122:   PetscLogInitializeCalled = PETSC_TRUE;

124:   PetscOptionsHasName(NULL,NULL, "-log_exclude_actions", &opt);
125:   if (opt) petsc_logActions = PETSC_FALSE;
126:   PetscOptionsHasName(NULL,NULL, "-log_exclude_objects", &opt);
127:   if (opt) petsc_logObjects = PETSC_FALSE;
128:   if (petsc_logActions) {
129:     PetscMalloc1(petsc_maxActions, &petsc_actions);
130:   }
131:   if (petsc_logObjects) {
132:     PetscMalloc1(petsc_maxObjects, &petsc_objects);
133:   }
134:   PetscLogPHC = PetscLogObjCreateDefault;
135:   PetscLogPHD = PetscLogObjDestroyDefault;
136:   /* Setup default logging structures */
137:   PetscStageLogCreate(&petsc_stageLog);
138:   PetscStageLogRegister(petsc_stageLog, "Main Stage", &stage);

140:   /* All processors sync here for more consistent logging */
141:   MPI_Barrier(PETSC_COMM_WORLD);
142:   PetscTime(&petsc_BaseTime);
143:   PetscLogStagePush(stage);
144:   return(0);
145: }

147: PETSC_INTERN PetscErrorCode PetscLogFinalize(void)
148: {
149:   PetscStageLog  stageLog;

153:   PetscFree(petsc_actions);
154:   PetscFree(petsc_objects);
155:   PetscLogNestedEnd();
156:   PetscLogSet(NULL, NULL);

158:   /* Resetting phase */
159:   PetscLogGetStageLog(&stageLog);
160:   PetscStageLogDestroy(stageLog);

162:   petsc_TotalFlops            = 0.0;
163:   petsc_numActions            = 0;
164:   petsc_numObjects            = 0;
165:   petsc_numObjectsDestroyed   = 0;
166:   petsc_maxActions            = 100;
167:   petsc_maxObjects            = 100;
168:   petsc_actions               = NULL;
169:   petsc_objects               = NULL;
170:   petsc_logActions            = PETSC_FALSE;
171:   petsc_logObjects            = PETSC_FALSE;
172:   petsc_BaseTime              = 0.0;
173:   petsc_TotalFlops            = 0.0;
174:   petsc_tmp_flops             = 0.0;
175:   petsc_send_ct               = 0.0;
176:   petsc_recv_ct               = 0.0;
177:   petsc_send_len              = 0.0;
178:   petsc_recv_len              = 0.0;
179:   petsc_isend_ct              = 0.0;
180:   petsc_irecv_ct              = 0.0;
181:   petsc_isend_len             = 0.0;
182:   petsc_irecv_len             = 0.0;
183:   petsc_wait_ct               = 0.0;
184:   petsc_wait_any_ct           = 0.0;
185:   petsc_wait_all_ct           = 0.0;
186:   petsc_sum_of_waits_ct       = 0.0;
187:   petsc_allreduce_ct          = 0.0;
188:   petsc_gather_ct             = 0.0;
189:   petsc_scatter_ct            = 0.0;
190:   #if defined(PETSC_HAVE_DEVICE)
191:   petsc_ctog_ct               = 0.0;
192:   petsc_gtoc_ct               = 0.0;
193:   petsc_ctog_sz               = 0.0;
194:   petsc_gtoc_sz               = 0.0;
195:   petsc_gflops                = 0.0;
196:   petsc_gtime                 = 0.0;
197:   #endif
198:   PETSC_LARGEST_EVENT         = PETSC_EVENT;
199:   PetscLogPHC                 = NULL;
200:   PetscLogPHD                 = NULL;
201:   petsc_tracefile             = NULL;
202:   petsc_tracelevel            = 0;
203:   petsc_traceblanks           = "                                                                                                    ";
204:   petsc_tracespace[0]         = ' '; petsc_tracespace[1] = 0;
205:   petsc_tracetime             = 0.0;
206:   PETSC_LARGEST_CLASSID       = PETSC_SMALLEST_CLASSID;
207:   PETSC_OBJECT_CLASSID        = 0;
208:   petsc_stageLog              = NULL;
209:   PetscLogInitializeCalled    = PETSC_FALSE;
210:   return(0);
211: }

213: /*@C
214:   PetscLogSet - Sets the logging functions called at the beginning and ending of every event.

216:   Not Collective

218:   Input Parameters:
219: + b - The function called at beginning of event
220: - e - The function called at end of event

222:   Level: developer

224: .seealso: PetscLogDump(), PetscLogDefaultBegin(), PetscLogAllBegin(), PetscLogTraceBegin()
225: @*/
226: PetscErrorCode  PetscLogSet(PetscErrorCode (*b)(PetscLogEvent, int, PetscObject, PetscObject, PetscObject, PetscObject),
227:                             PetscErrorCode (*e)(PetscLogEvent, int, PetscObject, PetscObject, PetscObject, PetscObject))
228: {
230:   PetscLogPLB = b;
231:   PetscLogPLE = e;
232:   return(0);
233: }

235: /*@C
236:   PetscLogDefaultBegin - Turns on logging of objects and events. This logs flop
237:   rates and object creation and should not slow programs down too much.
238:   This routine may be called more than once.

240:   Logically Collective over PETSC_COMM_WORLD

242:   Options Database Keys:
243: . -log_view [viewertype:filename:viewerformat] - Prints summary of flop and timing information to the
244:                   screen (for code configured with --with-log=1 (which is the default))

246:   Usage:
247: .vb
248:       PetscInitialize(...);
249:       PetscLogDefaultBegin();
250:        ... code ...
251:       PetscLogView(viewer); or PetscLogDump();
252:       PetscFinalize();
253: .ve

255:   Notes:
256:   PetscLogView(viewer) or PetscLogDump() actually cause the printing of
257:   the logging information.

259:   Level: advanced

261: .seealso: PetscLogDump(), PetscLogAllBegin(), PetscLogView(), PetscLogTraceBegin()
262: @*/
263: PetscErrorCode  PetscLogDefaultBegin(void)
264: {

268:   PetscLogSet(PetscLogEventBeginDefault, PetscLogEventEndDefault);
269:   return(0);
270: }

272: /*@C
273:   PetscLogAllBegin - Turns on extensive logging of objects and events. Logs
274:   all events. This creates large log files and slows the program down.

276:   Logically Collective on PETSC_COMM_WORLD

278:   Options Database Keys:
279: . -log_all - Prints extensive log information

281:   Usage:
282: .vb
283:      PetscInitialize(...);
284:      PetscLogAllBegin();
285:      ... code ...
286:      PetscLogDump(filename);
287:      PetscFinalize();
288: .ve

290:   Notes:
291:   A related routine is PetscLogDefaultBegin() (with the options key -log), which is
292:   intended for production runs since it logs only flop rates and object
293:   creation (and shouldn't significantly slow the programs).

295:   Level: advanced

297: .seealso: PetscLogDump(), PetscLogDefaultBegin(), PetscLogTraceBegin()
298: @*/
299: PetscErrorCode  PetscLogAllBegin(void)
300: {

304:   PetscLogSet(PetscLogEventBeginComplete, PetscLogEventEndComplete);
305:   return(0);
306: }

308: /*@C
309:   PetscLogTraceBegin - Activates trace logging.  Every time a PETSc event
310:   begins or ends, the event name is printed.

312:   Logically Collective on PETSC_COMM_WORLD

314:   Input Parameter:
315: . file - The file to print trace in (e.g. stdout)

317:   Options Database Key:
318: . -log_trace [filename] - Activates PetscLogTraceBegin()

320:   Notes:
321:   PetscLogTraceBegin() prints the processor number, the execution time (sec),
322:   then "Event begin:" or "Event end:" followed by the event name.

324:   PetscLogTraceBegin() allows tracing of all PETSc calls, which is useful
325:   to determine where a program is hanging without running in the
326:   debugger.  Can be used in conjunction with the -info option.

328:   Level: intermediate

330: .seealso: PetscLogDump(), PetscLogAllBegin(), PetscLogView(), PetscLogDefaultBegin()
331: @*/
332: PetscErrorCode  PetscLogTraceBegin(FILE *file)
333: {

337:   petsc_tracefile = file;

339:   PetscLogSet(PetscLogEventBeginTrace, PetscLogEventEndTrace);
340:   return(0);
341: }

343: /*@
344:   PetscLogActions - Determines whether actions are logged for the graphical viewer.

346:   Not Collective

348:   Input Parameter:
349: . flag - PETSC_TRUE if actions are to be logged

351:   Level: intermediate

353:   Note: Logging of actions continues to consume more memory as the program
354:   runs. Long running programs should consider turning this feature off.

356:   Options Database Keys:
357: . -log_exclude_actions - Turns off actions logging

359: .seealso: PetscLogStagePush(), PetscLogStagePop()
360: @*/
361: PetscErrorCode  PetscLogActions(PetscBool flag)
362: {
364:   petsc_logActions = flag;
365:   return(0);
366: }

368: /*@
369:   PetscLogObjects - Determines whether objects are logged for the graphical viewer.

371:   Not Collective

373:   Input Parameter:
374: . flag - PETSC_TRUE if objects are to be logged

376:   Level: intermediate

378:   Note: Logging of objects continues to consume more memory as the program
379:   runs. Long running programs should consider turning this feature off.

381:   Options Database Keys:
382: . -log_exclude_objects - Turns off objects logging

384: .seealso: PetscLogStagePush(), PetscLogStagePop()
385: @*/
386: PetscErrorCode  PetscLogObjects(PetscBool flag)
387: {
389:   petsc_logObjects = flag;
390:   return(0);
391: }

393: /*------------------------------------------------ Stage Functions --------------------------------------------------*/
394: /*@C
395:   PetscLogStageRegister - Attaches a character string name to a logging stage.

397:   Not Collective

399:   Input Parameter:
400: . sname - The name to associate with that stage

402:   Output Parameter:
403: . stage - The stage number

405:   Level: intermediate

407: .seealso: PetscLogStagePush(), PetscLogStagePop()
408: @*/
409: PetscErrorCode  PetscLogStageRegister(const char sname[],PetscLogStage *stage)
410: {
411:   PetscStageLog  stageLog;
412:   PetscLogEvent  event;

416:   PetscLogGetStageLog(&stageLog);
417:   PetscStageLogRegister(stageLog, sname, stage);
418:   /* Copy events already changed in the main stage, this sucks */
419:   PetscEventPerfLogEnsureSize(stageLog->stageInfo[*stage].eventLog, stageLog->eventLog->numEvents);
420:   for (event = 0; event < stageLog->eventLog->numEvents; event++) {
421:     PetscEventPerfInfoCopy(&stageLog->stageInfo[0].eventLog->eventInfo[event],&stageLog->stageInfo[*stage].eventLog->eventInfo[event]);
422:   }
423:   PetscClassPerfLogEnsureSize(stageLog->stageInfo[*stage].classLog, stageLog->classLog->numClasses);
424:   return(0);
425: }

427: /*@C
428:   PetscLogStagePush - This function pushes a stage on the stack.

430:   Not Collective

432:   Input Parameter:
433: . stage - The stage on which to log

435:   Usage:
436:   If the option -log_sumary is used to run the program containing the
437:   following code, then 2 sets of summary data will be printed during
438:   PetscFinalize().
439: .vb
440:       PetscInitialize(int *argc,char ***args,0,0);
441:       [stage 0 of code]
442:       PetscLogStagePush(1);
443:       [stage 1 of code]
444:       PetscLogStagePop();
445:       PetscBarrier(...);
446:       [more stage 0 of code]
447:       PetscFinalize();
448: .ve

450:   Notes:
451:   Use PetscLogStageRegister() to register a stage.

453:   Level: intermediate

455: .seealso: PetscLogStagePop(), PetscLogStageRegister(), PetscBarrier()
456: @*/
457: PetscErrorCode  PetscLogStagePush(PetscLogStage stage)
458: {
459:   PetscStageLog  stageLog;

463:   PetscLogGetStageLog(&stageLog);
464:   PetscStageLogPush(stageLog, stage);
465:   return(0);
466: }

468: /*@C
469:   PetscLogStagePop - This function pops a stage from the stack.

471:   Not Collective

473:   Usage:
474:   If the option -log_sumary is used to run the program containing the
475:   following code, then 2 sets of summary data will be printed during
476:   PetscFinalize().
477: .vb
478:       PetscInitialize(int *argc,char ***args,0,0);
479:       [stage 0 of code]
480:       PetscLogStagePush(1);
481:       [stage 1 of code]
482:       PetscLogStagePop();
483:       PetscBarrier(...);
484:       [more stage 0 of code]
485:       PetscFinalize();
486: .ve

488:   Notes:
489:   Use PetscLogStageRegister() to register a stage.

491:   Level: intermediate

493: .seealso: PetscLogStagePush(), PetscLogStageRegister(), PetscBarrier()
494: @*/
495: PetscErrorCode  PetscLogStagePop(void)
496: {
497:   PetscStageLog  stageLog;

501:   PetscLogGetStageLog(&stageLog);
502:   PetscStageLogPop(stageLog);
503:   return(0);
504: }

506: /*@
507:   PetscLogStageSetActive - Determines stage activity for PetscLogEventBegin() and PetscLogEventEnd().

509:   Not Collective

511:   Input Parameters:
512: + stage    - The stage
513: - isActive - The activity flag, PETSC_TRUE for logging, else PETSC_FALSE (defaults to PETSC_TRUE)

515:   Level: intermediate

517: .seealso: PetscLogStagePush(), PetscLogStagePop(), PetscLogEventBegin(), PetscLogEventEnd(), PetscPreLoadBegin(), PetscPreLoadEnd(), PetscPreLoadStage()
518: @*/
519: PetscErrorCode  PetscLogStageSetActive(PetscLogStage stage, PetscBool isActive)
520: {
521:   PetscStageLog  stageLog;

525:   PetscLogGetStageLog(&stageLog);
526:   PetscStageLogSetActive(stageLog, stage, isActive);
527:   return(0);
528: }

530: /*@
531:   PetscLogStageGetActive - Returns stage activity for PetscLogEventBegin() and PetscLogEventEnd().

533:   Not Collective

535:   Input Parameter:
536: . stage    - The stage

538:   Output Parameter:
539: . isActive - The activity flag, PETSC_TRUE for logging, else PETSC_FALSE (defaults to PETSC_TRUE)

541:   Level: intermediate

543: .seealso: PetscLogStagePush(), PetscLogStagePop(), PetscLogEventBegin(), PetscLogEventEnd(), PetscPreLoadBegin(), PetscPreLoadEnd(), PetscPreLoadStage()
544: @*/
545: PetscErrorCode  PetscLogStageGetActive(PetscLogStage stage, PetscBool  *isActive)
546: {
547:   PetscStageLog  stageLog;

551:   PetscLogGetStageLog(&stageLog);
552:   PetscStageLogGetActive(stageLog, stage, isActive);
553:   return(0);
554: }

556: /*@
557:   PetscLogStageSetVisible - Determines stage visibility in PetscLogView()

559:   Not Collective

561:   Input Parameters:
562: + stage     - The stage
563: - isVisible - The visibility flag, PETSC_TRUE to print, else PETSC_FALSE (defaults to PETSC_TRUE)

565:   Level: intermediate

567: .seealso: PetscLogStagePush(), PetscLogStagePop(), PetscLogView()
568: @*/
569: PetscErrorCode  PetscLogStageSetVisible(PetscLogStage stage, PetscBool isVisible)
570: {
571:   PetscStageLog  stageLog;

575:   PetscLogGetStageLog(&stageLog);
576:   PetscStageLogSetVisible(stageLog, stage, isVisible);
577:   return(0);
578: }

580: /*@
581:   PetscLogStageGetVisible - Returns stage visibility in PetscLogView()

583:   Not Collective

585:   Input Parameter:
586: . stage     - The stage

588:   Output Parameter:
589: . isVisible - The visibility flag, PETSC_TRUE to print, else PETSC_FALSE (defaults to PETSC_TRUE)

591:   Level: intermediate

593: .seealso: PetscLogStagePush(), PetscLogStagePop(), PetscLogView()
594: @*/
595: PetscErrorCode  PetscLogStageGetVisible(PetscLogStage stage, PetscBool  *isVisible)
596: {
597:   PetscStageLog  stageLog;

601:   PetscLogGetStageLog(&stageLog);
602:   PetscStageLogGetVisible(stageLog, stage, isVisible);
603:   return(0);
604: }

606: /*@C
607:   PetscLogStageGetId - Returns the stage id when given the stage name.

609:   Not Collective

611:   Input Parameter:
612: . name  - The stage name

614:   Output Parameter:
615: . stage - The stage, , or -1 if no stage with that name exists

617:   Level: intermediate

619: .seealso: PetscLogStagePush(), PetscLogStagePop(), PetscPreLoadBegin(), PetscPreLoadEnd(), PetscPreLoadStage()
620: @*/
621: PetscErrorCode  PetscLogStageGetId(const char name[], PetscLogStage *stage)
622: {
623:   PetscStageLog  stageLog;

627:   PetscLogGetStageLog(&stageLog);
628:   PetscStageLogGetStage(stageLog, name, stage);
629:   return(0);
630: }

632: /*------------------------------------------------ Event Functions --------------------------------------------------*/
633: /*@C
634:   PetscLogEventRegister - Registers an event name for logging operations in an application code.

636:   Not Collective

638:   Input Parameters:
639: + name   - The name associated with the event
640: - classid - The classid associated to the class for this event, obtain either with
641:            PetscClassIdRegister() or use a predefined one such as KSP_CLASSID, SNES_CLASSID, the predefined ones
642:            are only available in C code

644:   Output Parameter:
645: . event - The event id for use with PetscLogEventBegin() and PetscLogEventEnd().

647:   Example of Usage:
648: .vb
649:       PetscLogEvent USER_EVENT;
650:       PetscClassId classid;
651:       PetscLogDouble user_event_flops;
652:       PetscClassIdRegister("class name",&classid);
653:       PetscLogEventRegister("User event name",classid,&USER_EVENT);
654:       PetscLogEventBegin(USER_EVENT,0,0,0,0);
655:          [code segment to monitor]
656:          PetscLogFlops(user_event_flops);
657:       PetscLogEventEnd(USER_EVENT,0,0,0,0);
658: .ve

660:   Notes:
661:   PETSc automatically logs library events if the code has been
662:   configured with --with-log (which is the default) and
663:   -log_view or -log_all is specified.  PetscLogEventRegister() is
664:   intended for logging user events to supplement this PETSc
665:   information.

667:   PETSc can gather data for use with the utilities Jumpshot
668:   (part of the MPICH distribution).  If PETSc has been compiled
669:   with flag -DPETSC_HAVE_MPE (MPE is an additional utility within
670:   MPICH), the user can employ another command line option, -log_mpe,
671:   to create a logfile, "mpe.log", which can be visualized
672:   Jumpshot.

674:   The classid is associated with each event so that classes of events
675:   can be disabled simultaneously, such as all matrix events. The user
676:   can either use an existing classid, such as MAT_CLASSID, or create
677:   their own as shown in the example.

679:   If an existing event with the same name exists, its event handle is
680:   returned instead of creating a new event.

682:   Level: intermediate

684: .seealso: PetscLogEventBegin(), PetscLogEventEnd(), PetscLogFlops(),
685:           PetscLogEventActivate(), PetscLogEventDeactivate(), PetscClassIdRegister()
686: @*/
687: PetscErrorCode  PetscLogEventRegister(const char name[],PetscClassId classid,PetscLogEvent *event)
688: {
689:   PetscStageLog  stageLog;
690:   int            stage;

694:   *event = PETSC_DECIDE;
695:   PetscLogGetStageLog(&stageLog);
696:   PetscEventRegLogGetEvent(stageLog->eventLog, name, event);
697:   if (*event > 0) return(0);
698:   PetscEventRegLogRegister(stageLog->eventLog, name, classid, event);
699:   for (stage = 0; stage < stageLog->numStages; stage++) {
700:     PetscEventPerfLogEnsureSize(stageLog->stageInfo[stage].eventLog, stageLog->eventLog->numEvents);
701:     PetscClassPerfLogEnsureSize(stageLog->stageInfo[stage].classLog, stageLog->classLog->numClasses);
702:   }
703:   return(0);
704: }

706: /*@
707:   PetscLogEventSetCollective - Indicates that a particular event is collective.

709:   Not Collective

711:   Input Parameters:
712: + event - The event id
713: - collective - Bolean flag indicating whether a particular event is collective

715:   Note:
716:   New events returned from PetscLogEventRegister() are collective by default.

718:   Level: developer

720: .seealso: PetscLogEventRegister()
721: @*/
722: PetscErrorCode PetscLogEventSetCollective(PetscLogEvent event,PetscBool collective)
723: {
724:   PetscStageLog    stageLog;
725:   PetscEventRegLog eventRegLog;
726:   PetscErrorCode   ierr;

729:   PetscLogGetStageLog(&stageLog);
730:   PetscStageLogGetEventRegLog(stageLog,&eventRegLog);
731:   if (event < 0 || event > eventRegLog->numEvents) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Invalid event id");
732:   eventRegLog->eventInfo[event].collective = collective;
733:   return(0);
734: }

736: /*@
737:   PetscLogEventIncludeClass - Activates event logging for a PETSc object class in every stage.

739:   Not Collective

741:   Input Parameter:
742: . classid - The object class, for example MAT_CLASSID, SNES_CLASSID, etc.

744:   Level: developer

746: .seealso: PetscLogEventActivateClass(),PetscLogEventDeactivateClass(),PetscLogEventActivate(),PetscLogEventDeactivate()
747: @*/
748: PetscErrorCode  PetscLogEventIncludeClass(PetscClassId classid)
749: {
750:   PetscStageLog  stageLog;
751:   int            stage;

755:   PetscLogGetStageLog(&stageLog);
756:   for (stage = 0; stage < stageLog->numStages; stage++) {
757:     PetscEventPerfLogActivateClass(stageLog->stageInfo[stage].eventLog, stageLog->eventLog, classid);
758:   }
759:   return(0);
760: }

762: /*@
763:   PetscLogEventExcludeClass - Deactivates event logging for a PETSc object class in every stage.

765:   Not Collective

767:   Input Parameter:
768: . classid - The object class, for example MAT_CLASSID, SNES_CLASSID, etc.

770:   Level: developer

772: .seealso: PetscLogEventDeactivateClass(),PetscLogEventActivateClass(),PetscLogEventDeactivate(),PetscLogEventActivate()
773: @*/
774: PetscErrorCode  PetscLogEventExcludeClass(PetscClassId classid)
775: {
776:   PetscStageLog  stageLog;
777:   int            stage;

781:   PetscLogGetStageLog(&stageLog);
782:   for (stage = 0; stage < stageLog->numStages; stage++) {
783:     PetscEventPerfLogDeactivateClass(stageLog->stageInfo[stage].eventLog, stageLog->eventLog, classid);
784:   }
785:   return(0);
786: }

788: /*@
789:   PetscLogEventActivate - Indicates that a particular event should be logged.

791:   Not Collective

793:   Input Parameter:
794: . event - The event id

796:   Usage:
797: .vb
798:       PetscLogEventDeactivate(VEC_SetValues);
799:         [code where you do not want to log VecSetValues()]
800:       PetscLogEventActivate(VEC_SetValues);
801:         [code where you do want to log VecSetValues()]
802: .ve

804:   Note:
805:   The event may be either a pre-defined PETSc event (found in include/petsclog.h)
806:   or an event number obtained with PetscLogEventRegister().

808:   Level: advanced

810: .seealso: PlogEventDeactivate(), PlogEventDeactivatePush(), PetscLogEventDeactivatePop()
811: @*/
812: PetscErrorCode  PetscLogEventActivate(PetscLogEvent event)
813: {
814:   PetscStageLog  stageLog;
815:   int            stage;

819:   PetscLogGetStageLog(&stageLog);
820:   PetscStageLogGetCurrent(stageLog, &stage);
821:   PetscEventPerfLogActivate(stageLog->stageInfo[stage].eventLog, event);
822:   return(0);
823: }

825: /*@
826:   PetscLogEventDeactivate - Indicates that a particular event should not be logged.

828:   Not Collective

830:   Input Parameter:
831: . event - The event id

833:   Usage:
834: .vb
835:       PetscLogEventDeactivate(VEC_SetValues);
836:         [code where you do not want to log VecSetValues()]
837:       PetscLogEventActivate(VEC_SetValues);
838:         [code where you do want to log VecSetValues()]
839: .ve

841:   Note:
842:   The event may be either a pre-defined PETSc event (found in
843:   include/petsclog.h) or an event number obtained with PetscLogEventRegister()).

845:   Level: advanced

847: .seealso: PetscLogEventActivate(), PetscLogEventDeactivatePush(), PetscLogEventDeactivatePop()
848: @*/
849: PetscErrorCode  PetscLogEventDeactivate(PetscLogEvent event)
850: {
851:   PetscStageLog  stageLog;
852:   int            stage;

856:   PetscLogGetStageLog(&stageLog);
857:   PetscStageLogGetCurrent(stageLog, &stage);
858:   PetscEventPerfLogDeactivate(stageLog->stageInfo[stage].eventLog, event);
859:   return(0);
860: }

862: /*@
863:   PetscLogEventDeactivatePush - Indicates that a particular event should not be logged.

865:   Not Collective

867:   Input Parameter:
868: . event - The event id

870:   Usage:
871: .vb
872:       PetscLogEventDeactivatePush(VEC_SetValues);
873:         [code where you do not want to log VecSetValues()]
874:       PetscLogEventDeactivatePop(VEC_SetValues);
875:         [code where you do want to log VecSetValues()]
876: .ve

878:   Note:
879:   The event may be either a pre-defined PETSc event (found in
880:   include/petsclog.h) or an event number obtained with PetscLogEventRegister()).

882:   Level: advanced

884: .seealso: PetscLogEventActivate(), PetscLogEventDeactivatePop()
885: @*/
886: PetscErrorCode  PetscLogEventDeactivatePush(PetscLogEvent event)
887: {
888:   PetscStageLog  stageLog;
889:   int            stage;

893:   PetscLogGetStageLog(&stageLog);
894:   PetscStageLogGetCurrent(stageLog, &stage);
895:   PetscEventPerfLogDeactivatePush(stageLog->stageInfo[stage].eventLog, event);
896:   return(0);
897: }

899: /*@
900:   PetscLogEventDeactivatePop - Indicates that a particular event shouldbe logged.

902:   Not Collective

904:   Input Parameter:
905: . event - The event id

907:   Usage:
908: .vb
909:       PetscLogEventDeactivatePush(VEC_SetValues);
910:         [code where you do not want to log VecSetValues()]
911:       PetscLogEventDeactivatePop(VEC_SetValues);
912:         [code where you do want to log VecSetValues()]
913: .ve

915:   Note:
916:   The event may be either a pre-defined PETSc event (found in
917:   include/petsclog.h) or an event number obtained with PetscLogEventRegister()).

919:   Level: advanced

921: .seealso: PetscLogEventActivate(), PetscLogEventDeactivatePush()
922: @*/
923: PetscErrorCode  PetscLogEventDeactivatePop(PetscLogEvent event)
924: {
925:   PetscStageLog  stageLog;
926:   int            stage;

930:   PetscLogGetStageLog(&stageLog);
931:   PetscStageLogGetCurrent(stageLog, &stage);
932:   PetscEventPerfLogDeactivatePop(stageLog->stageInfo[stage].eventLog, event);
933:   return(0);
934: }

936: /*@
937:   PetscLogEventSetActiveAll - Sets the event activity in every stage.

939:   Not Collective

941:   Input Parameters:
942: + event    - The event id
943: - isActive - The activity flag determining whether the event is logged

945:   Level: advanced

947: .seealso: PlogEventActivate(),PlogEventDeactivate()
948: @*/
949: PetscErrorCode  PetscLogEventSetActiveAll(PetscLogEvent event, PetscBool isActive)
950: {
951:   PetscStageLog  stageLog;
952:   int            stage;

956:   PetscLogGetStageLog(&stageLog);
957:   for (stage = 0; stage < stageLog->numStages; stage++) {
958:     if (isActive) {
959:       PetscEventPerfLogActivate(stageLog->stageInfo[stage].eventLog, event);
960:     } else {
961:       PetscEventPerfLogDeactivate(stageLog->stageInfo[stage].eventLog, event);
962:     }
963:   }
964:   return(0);
965: }

967: /*@
968:   PetscLogEventActivateClass - Activates event logging for a PETSc object class.

970:   Not Collective

972:   Input Parameter:
973: . classid - The event class, for example MAT_CLASSID, SNES_CLASSID, etc.

975:   Level: developer

977: .seealso: PetscLogEventDeactivateClass(),PetscLogEventActivate(),PetscLogEventDeactivate()
978: @*/
979: PetscErrorCode  PetscLogEventActivateClass(PetscClassId classid)
980: {
981:   PetscStageLog  stageLog;
982:   int            stage;

986:   PetscLogGetStageLog(&stageLog);
987:   PetscStageLogGetCurrent(stageLog, &stage);
988:   PetscEventPerfLogActivateClass(stageLog->stageInfo[stage].eventLog, stageLog->eventLog, classid);
989:   return(0);
990: }

992: /*@
993:   PetscLogEventDeactivateClass - Deactivates event logging for a PETSc object class.

995:   Not Collective

997:   Input Parameter:
998: . classid - The event class, for example MAT_CLASSID, SNES_CLASSID, etc.

1000:   Level: developer

1002: .seealso: PetscLogEventActivateClass(),PetscLogEventActivate(),PetscLogEventDeactivate()
1003: @*/
1004: PetscErrorCode  PetscLogEventDeactivateClass(PetscClassId classid)
1005: {
1006:   PetscStageLog  stageLog;
1007:   int            stage;

1011:   PetscLogGetStageLog(&stageLog);
1012:   PetscStageLogGetCurrent(stageLog, &stage);
1013:   PetscEventPerfLogDeactivateClass(stageLog->stageInfo[stage].eventLog, stageLog->eventLog, classid);
1014:   return(0);
1015: }

1017: /*MC
1018:    PetscLogEventSync - Synchronizes the beginning of a user event.

1020:    Synopsis:
1021: #include <petsclog.h>
1022:    PetscErrorCode PetscLogEventSync(int e,MPI_Comm comm)

1024:    Collective

1026:    Input Parameters:
1027: +  e - integer associated with the event obtained from PetscLogEventRegister()
1028: -  comm - an MPI communicator

1030:    Usage:
1031: .vb
1032:      PetscLogEvent USER_EVENT;
1033:      PetscLogEventRegister("User event",0,&USER_EVENT);
1034:      PetscLogEventSync(USER_EVENT,PETSC_COMM_WORLD);
1035:      PetscLogEventBegin(USER_EVENT,0,0,0,0);
1036:         [code segment to monitor]
1037:      PetscLogEventEnd(USER_EVENT,0,0,0,0);
1038: .ve

1040:    Notes:
1041:    This routine should be called only if there is not a
1042:    PetscObject available to pass to PetscLogEventBegin().

1044:    Level: developer

1046: .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogEventEnd()

1048: M*/

1050: /*MC
1051:    PetscLogEventBegin - Logs the beginning of a user event.

1053:    Synopsis:
1054: #include <petsclog.h>
1055:    PetscErrorCode PetscLogEventBegin(int e,PetscObject o1,PetscObject o2,PetscObject o3,PetscObject o4)

1057:    Not Collective

1059:    Input Parameters:
1060: +  e - integer associated with the event obtained from PetscLogEventRegister()
1061: -  o1,o2,o3,o4 - objects associated with the event, or 0

1063:    Fortran Synopsis:
1064:    void PetscLogEventBegin(int e,PetscErrorCode ierr)

1066:    Usage:
1067: .vb
1068:      PetscLogEvent USER_EVENT;
1069:      PetscLogDouble user_event_flops;
1070:      PetscLogEventRegister("User event",0,&USER_EVENT);
1071:      PetscLogEventBegin(USER_EVENT,0,0,0,0);
1072:         [code segment to monitor]
1073:         PetscLogFlops(user_event_flops);
1074:      PetscLogEventEnd(USER_EVENT,0,0,0,0);
1075: .ve

1077:    Notes:
1078:    You need to register each integer event with the command
1079:    PetscLogEventRegister().

1081:    Level: intermediate

1083: .seealso: PetscLogEventRegister(), PetscLogEventEnd(), PetscLogFlops()

1085: M*/

1087: /*MC
1088:    PetscLogEventEnd - Log the end of a user event.

1090:    Synopsis:
1091: #include <petsclog.h>
1092:    PetscErrorCode PetscLogEventEnd(int e,PetscObject o1,PetscObject o2,PetscObject o3,PetscObject o4)

1094:    Not Collective

1096:    Input Parameters:
1097: +  e - integer associated with the event obtained with PetscLogEventRegister()
1098: -  o1,o2,o3,o4 - objects associated with the event, or 0

1100:    Fortran Synopsis:
1101:    void PetscLogEventEnd(int e,PetscErrorCode ierr)

1103:    Usage:
1104: .vb
1105:      PetscLogEvent USER_EVENT;
1106:      PetscLogDouble user_event_flops;
1107:      PetscLogEventRegister("User event",0,&USER_EVENT,);
1108:      PetscLogEventBegin(USER_EVENT,0,0,0,0);
1109:         [code segment to monitor]
1110:         PetscLogFlops(user_event_flops);
1111:      PetscLogEventEnd(USER_EVENT,0,0,0,0);
1112: .ve

1114:    Notes:
1115:    You should also register each additional integer event with the command
1116:    PetscLogEventRegister().

1118:    Level: intermediate

1120: .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogFlops()

1122: M*/

1124: /*@C
1125:   PetscLogEventGetId - Returns the event id when given the event name.

1127:   Not Collective

1129:   Input Parameter:
1130: . name  - The event name

1132:   Output Parameter:
1133: . event - The event, or -1 if no event with that name exists

1135:   Level: intermediate

1137: .seealso: PetscLogEventBegin(), PetscLogEventEnd(), PetscLogStageGetId()
1138: @*/
1139: PetscErrorCode  PetscLogEventGetId(const char name[], PetscLogEvent *event)
1140: {
1141:   PetscStageLog  stageLog;

1145:   PetscLogGetStageLog(&stageLog);
1146:   PetscEventRegLogGetEvent(stageLog->eventLog, name, event);
1147:   return(0);
1148: }

1150: /*------------------------------------------------ Output Functions -------------------------------------------------*/
1151: /*@C
1152:   PetscLogDump - Dumps logs of objects to a file. This file is intended to
1153:   be read by bin/petscview. This program no longer exists.

1155:   Collective on PETSC_COMM_WORLD

1157:   Input Parameter:
1158: . name - an optional file name

1160:   Usage:
1161: .vb
1162:      PetscInitialize(...);
1163:      PetscLogDefaultBegin(); or PetscLogAllBegin();
1164:      ... code ...
1165:      PetscLogDump(filename);
1166:      PetscFinalize();
1167: .ve

1169:   Notes:
1170:   The default file name is
1171: $    Log.<rank>
1172:   where <rank> is the processor number. If no name is specified,
1173:   this file will be used.

1175:   Level: advanced

1177: .seealso: PetscLogDefaultBegin(), PetscLogAllBegin(), PetscLogView()
1178: @*/
1179: PetscErrorCode  PetscLogDump(const char sname[])
1180: {
1181:   PetscStageLog      stageLog;
1182:   PetscEventPerfInfo *eventInfo;
1183:   FILE               *fd;
1184:   char               file[PETSC_MAX_PATH_LEN], fname[PETSC_MAX_PATH_LEN];
1185:   PetscLogDouble     flops, _TotalTime;
1186:   PetscMPIInt        rank;
1187:   int                action, object, curStage;
1188:   PetscLogEvent      event;
1189:   PetscErrorCode     ierr;

1192:   /* Calculate the total elapsed time */
1193:   PetscTime(&_TotalTime);
1194:   _TotalTime -= petsc_BaseTime;
1195:   /* Open log file */
1196:   MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
1197:   if (sname && sname[0]) sprintf(file, "%s.%d", sname, rank);
1198:   else sprintf(file, "Log.%d", rank);
1199:   PetscFixFilename(file, fname);
1200:   PetscFOpen(PETSC_COMM_WORLD, fname, "w", &fd);
1201:   if ((rank == 0) && (!fd)) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN, "Cannot open file: %s", fname);
1202:   /* Output totals */
1203:   PetscFPrintf(PETSC_COMM_WORLD, fd, "Total Flop %14e %16.8e\n", petsc_TotalFlops, _TotalTime);
1204:   PetscFPrintf(PETSC_COMM_WORLD, fd, "Clock Resolution %g\n", 0.0);
1205:   /* Output actions */
1206:   if (petsc_logActions) {
1207:     PetscFPrintf(PETSC_COMM_WORLD, fd, "Actions accomplished %d\n", petsc_numActions);
1208:     for (action = 0; action < petsc_numActions; action++) {
1209:       PetscFPrintf(PETSC_COMM_WORLD, fd, "%g %d %d %d %d %d %d %g %g %g\n",
1210:                           petsc_actions[action].time, petsc_actions[action].action, (int)petsc_actions[action].event, (int)petsc_actions[action].classid, petsc_actions[action].id1,
1211:                           petsc_actions[action].id2, petsc_actions[action].id3, petsc_actions[action].flops, petsc_actions[action].mem, petsc_actions[action].maxmem);
1212:     }
1213:   }
1214:   /* Output objects */
1215:   if (petsc_logObjects) {
1216:     PetscFPrintf(PETSC_COMM_WORLD, fd, "Objects created %d destroyed %d\n", petsc_numObjects, petsc_numObjectsDestroyed);
1217:     for (object = 0; object < petsc_numObjects; object++) {
1218:       PetscFPrintf(PETSC_COMM_WORLD, fd, "Parent ID: %d Memory: %d\n", petsc_objects[object].parent, (int) petsc_objects[object].mem);
1219:       if (!petsc_objects[object].name[0]) {
1220:         PetscFPrintf(PETSC_COMM_WORLD, fd,"No Name\n");
1221:       } else {
1222:         PetscFPrintf(PETSC_COMM_WORLD, fd, "Name: %s\n", petsc_objects[object].name);
1223:       }
1224:       if (petsc_objects[object].info[0] != 0) {
1225:         PetscFPrintf(PETSC_COMM_WORLD, fd, "No Info\n");
1226:       } else {
1227:         PetscFPrintf(PETSC_COMM_WORLD, fd, "Info: %s\n", petsc_objects[object].info);
1228:       }
1229:     }
1230:   }
1231:   /* Output events */
1232:   PetscFPrintf(PETSC_COMM_WORLD, fd, "Event log:\n");
1233:   PetscLogGetStageLog(&stageLog);
1234:   PetscIntStackTop(stageLog->stack, &curStage);
1235:   eventInfo = stageLog->stageInfo[curStage].eventLog->eventInfo;
1236:   for (event = 0; event < stageLog->stageInfo[curStage].eventLog->numEvents; event++) {
1237:     if (eventInfo[event].time != 0.0) flops = eventInfo[event].flops/eventInfo[event].time;
1238:     else flops = 0.0;
1239:     PetscFPrintf(PETSC_COMM_WORLD, fd, "%d %16d %16g %16g %16g\n", event, eventInfo[event].count,
1240:                         eventInfo[event].flops, eventInfo[event].time, flops);
1241:   }
1242:   PetscFClose(PETSC_COMM_WORLD, fd);
1243:   return(0);
1244: }

1246: /*
1247:   PetscLogView_Detailed - Each process prints the times for its own events

1249: */
1250: PetscErrorCode  PetscLogView_Detailed(PetscViewer viewer)
1251: {
1252:   PetscStageLog      stageLog;
1253:   PetscEventPerfInfo *eventInfo = NULL, *stageInfo = NULL;
1254:   PetscLogDouble     locTotalTime, numRed, maxMem;
1255:   int                numStages,numEvents,stage,event;
1256:   MPI_Comm           comm = PetscObjectComm((PetscObject) viewer);
1257:   PetscMPIInt        rank,size;
1258:   PetscErrorCode     ierr;

1261:   MPI_Comm_size(comm, &size);
1262:   MPI_Comm_rank(comm, &rank);
1263:   /* Must preserve reduction count before we go on */
1264:   numRed = petsc_allreduce_ct + petsc_gather_ct + petsc_scatter_ct;
1265:   /* Get the total elapsed time */
1266:   PetscTime(&locTotalTime);  locTotalTime -= petsc_BaseTime;
1267:   PetscViewerASCIIPrintf(viewer,"size = %d\n",size);
1268:   PetscViewerASCIIPrintf(viewer,"LocalTimes = {}\n");
1269:   PetscViewerASCIIPrintf(viewer,"LocalMessages = {}\n");
1270:   PetscViewerASCIIPrintf(viewer,"LocalMessageLens = {}\n");
1271:   PetscViewerASCIIPrintf(viewer,"LocalReductions = {}\n");
1272:   PetscViewerASCIIPrintf(viewer,"LocalFlop = {}\n");
1273:   PetscViewerASCIIPrintf(viewer,"LocalObjects = {}\n");
1274:   PetscViewerASCIIPrintf(viewer,"LocalMemory = {}\n");
1275:   PetscLogGetStageLog(&stageLog);
1276:   MPI_Allreduce(&stageLog->numStages, &numStages, 1, MPI_INT, MPI_MAX, comm);
1277:   PetscViewerASCIIPrintf(viewer,"Stages = {}\n");
1278:   for (stage=0; stage<numStages; stage++) {
1279:     PetscViewerASCIIPrintf(viewer,"Stages[\"%s\"] = {}\n",stageLog->stageInfo[stage].name);
1280:     PetscViewerASCIIPrintf(viewer,"Stages[\"%s\"][\"summary\"] = {}\n",stageLog->stageInfo[stage].name);
1281:     MPI_Allreduce(&stageLog->stageInfo[stage].eventLog->numEvents, &numEvents, 1, MPI_INT, MPI_MAX, comm);
1282:     for (event = 0; event < numEvents; event++) {
1283:       PetscViewerASCIIPrintf(viewer,"Stages[\"%s\"][\"%s\"] = {}\n",stageLog->stageInfo[stage].name,stageLog->eventLog->eventInfo[event].name);
1284:     }
1285:   }
1286:   PetscMallocGetMaximumUsage(&maxMem);
1287:   PetscViewerASCIIPushSynchronized(viewer);
1288:   PetscViewerASCIISynchronizedPrintf(viewer,"LocalTimes[%d] = %g\n",rank,locTotalTime);
1289:   PetscViewerASCIISynchronizedPrintf(viewer,"LocalMessages[%d] = %g\n",rank,(petsc_irecv_ct + petsc_isend_ct + petsc_recv_ct + petsc_send_ct));
1290:   PetscViewerASCIISynchronizedPrintf(viewer,"LocalMessageLens[%d] = %g\n",rank,(petsc_irecv_len + petsc_isend_len + petsc_recv_len + petsc_send_len));
1291:   PetscViewerASCIISynchronizedPrintf(viewer,"LocalReductions[%d] = %g\n",rank,numRed);
1292:   PetscViewerASCIISynchronizedPrintf(viewer,"LocalFlop[%d] = %g\n",rank,petsc_TotalFlops);
1293:   PetscViewerASCIISynchronizedPrintf(viewer,"LocalObjects[%d] = %d\n",rank,petsc_numObjects);
1294:   PetscViewerASCIISynchronizedPrintf(viewer,"LocalMemory[%d] = %g\n",rank,maxMem);
1295:   PetscViewerFlush(viewer);
1296:   for (stage=0; stage<numStages; stage++) {
1297:     stageInfo = &stageLog->stageInfo[stage].perfInfo;
1298:     PetscViewerASCIISynchronizedPrintf(viewer,"Stages[\"%s\"][\"summary\"][%d] = {\"time\" : %g, \"numMessages\" : %g, \"messageLength\" : %g, \"numReductions\" : %g, \"flop\" : %g}\n",
1299:                                               stageLog->stageInfo[stage].name,rank,
1300:                                               stageInfo->time,stageInfo->numMessages,stageInfo->messageLength,stageInfo->numReductions,stageInfo->flops);
1301:     MPI_Allreduce(&stageLog->stageInfo[stage].eventLog->numEvents, &numEvents, 1, MPI_INT, MPI_MAX, comm);
1302:     for (event = 0; event < numEvents; event++) {
1303:       eventInfo = &stageLog->stageInfo[stage].eventLog->eventInfo[event];
1304:       PetscViewerASCIISynchronizedPrintf(viewer,"Stages[\"%s\"][\"%s\"][%d] = {\"count\" : %D, \"time\" : %g, \"syncTime\" : %g, \"numMessages\" : %g, \"messageLength\" : %g, \"numReductions\" : %g, \"flop\" : %g",
1305:                                                 stageLog->stageInfo[stage].name,stageLog->eventLog->eventInfo[event].name,rank,
1306:                                                 eventInfo->count,eventInfo->time,eventInfo->syncTime,eventInfo->numMessages,eventInfo->messageLength,eventInfo->numReductions,eventInfo->flops);
1307:       if (eventInfo->dof[0] >= 0.) {
1308:         PetscInt d, e;

1310:         PetscViewerASCIISynchronizedPrintf(viewer, ", \"dof\" : [");
1311:         for (d = 0; d < 8; ++d) {
1312:           if (d > 0) {PetscViewerASCIISynchronizedPrintf(viewer, ", ");}
1313:           PetscViewerASCIISynchronizedPrintf(viewer, "%g", eventInfo->dof[d]);
1314:         }
1315:         PetscViewerASCIISynchronizedPrintf(viewer, "]");
1316:         PetscViewerASCIISynchronizedPrintf(viewer, ", \"error\" : [");
1317:         for (e = 0; e < 8; ++e) {
1318:           if (e > 0) {PetscViewerASCIISynchronizedPrintf(viewer, ", ");}
1319:           PetscViewerASCIISynchronizedPrintf(viewer, "%g", eventInfo->errors[e]);
1320:         }
1321:         PetscViewerASCIISynchronizedPrintf(viewer, "]");
1322:       }
1323:       PetscViewerASCIISynchronizedPrintf(viewer,"}\n");
1324:     }
1325:   }
1326:   PetscViewerFlush(viewer);
1327:   PetscViewerASCIIPopSynchronized(viewer);
1328:   return(0);
1329: }

1331: /*
1332:   PetscLogView_CSV - Each process prints the times for its own events in Comma-Separated Value Format
1333: */
1334: PetscErrorCode  PetscLogView_CSV(PetscViewer viewer)
1335: {
1336:   PetscStageLog      stageLog;
1337:   PetscEventPerfInfo *eventInfo = NULL;
1338:   PetscLogDouble     locTotalTime, maxMem;
1339:   int                numStages,numEvents,stage,event;
1340:   MPI_Comm           comm = PetscObjectComm((PetscObject) viewer);
1341:   PetscMPIInt        rank,size;
1342:   PetscErrorCode     ierr;

1345:   MPI_Comm_size(comm, &size);
1346:   MPI_Comm_rank(comm, &rank);
1347:   /* Must preserve reduction count before we go on */
1348:   /* Get the total elapsed time */
1349:   PetscTime(&locTotalTime);  locTotalTime -= petsc_BaseTime;
1350:   PetscLogGetStageLog(&stageLog);
1351:   MPI_Allreduce(&stageLog->numStages, &numStages, 1, MPI_INT, MPI_MAX, comm);
1352:   PetscMallocGetMaximumUsage(&maxMem);
1353:   PetscViewerASCIIPushSynchronized(viewer);
1354:   PetscViewerASCIIPrintf(viewer,"Stage Name,Event Name,Rank,Count,Time,Num Messages,Message Length,Num Reductions,FLOP,dof0,dof1,dof2,dof3,dof4,dof5,dof6,dof7,e0,e1,e2,e3,e4,e5,e6,e7,%d\n", size);
1355:   PetscViewerFlush(viewer);
1356:   for (stage=0; stage<numStages; stage++) {
1357:     PetscEventPerfInfo *stageInfo = &stageLog->stageInfo[stage].perfInfo;

1359:     PetscViewerASCIISynchronizedPrintf(viewer,"%s,summary,%d,1,%g,%g,%g,%g,%g\n",
1360:                                               stageLog->stageInfo[stage].name,rank,stageInfo->time,stageInfo->numMessages,stageInfo->messageLength,stageInfo->numReductions,stageInfo->flops);
1361:     MPI_Allreduce(&stageLog->stageInfo[stage].eventLog->numEvents, &numEvents, 1, MPI_INT, MPI_MAX, comm);
1362:     for (event = 0; event < numEvents; event++) {
1363:       eventInfo = &stageLog->stageInfo[stage].eventLog->eventInfo[event];
1364:       PetscViewerASCIISynchronizedPrintf(viewer,"%s,%s,%d,%D,%g,%g,%g,%g,%g",stageLog->stageInfo[stage].name,
1365:                                                 stageLog->eventLog->eventInfo[event].name,rank,eventInfo->count,eventInfo->time,eventInfo->numMessages,
1366:                                                 eventInfo->messageLength,eventInfo->numReductions,eventInfo->flops);
1367:       if (eventInfo->dof[0] >= 0.) {
1368:         PetscInt d, e;

1370:         for (d = 0; d < 8; ++d) {
1371:           PetscViewerASCIISynchronizedPrintf(viewer, ",%g", eventInfo->dof[d]);
1372:         }
1373:         for (e = 0; e < 8; ++e) {
1374:           PetscViewerASCIISynchronizedPrintf(viewer, ",%g", eventInfo->errors[e]);
1375:         }
1376:       }
1377:       PetscViewerASCIISynchronizedPrintf(viewer,"\n");
1378:     }
1379:   }
1380:   PetscViewerFlush(viewer);
1381:   PetscViewerASCIIPopSynchronized(viewer);
1382:   return(0);
1383: }

1385: static PetscErrorCode PetscLogViewWarnSync(MPI_Comm comm,FILE *fd)
1386: {
1389:   if (!PetscLogSyncOn) return(0);
1390:   PetscFPrintf(comm, fd, "\n\n");
1391:   PetscFPrintf(comm, fd, "      ##########################################################\n");
1392:   PetscFPrintf(comm, fd, "      #                                                        #\n");
1393:   PetscFPrintf(comm, fd, "      #                       WARNING!!!                       #\n");
1394:   PetscFPrintf(comm, fd, "      #                                                        #\n");
1395:   PetscFPrintf(comm, fd, "      #   This program was run with logging synchronization.   #\n");
1396:   PetscFPrintf(comm, fd, "      #   This option provides more meaningful imbalance       #\n");
1397:   PetscFPrintf(comm, fd, "      #   figures at the expense of slowing things down and    #\n");
1398:   PetscFPrintf(comm, fd, "      #   providing a distorted view of the overall runtime.   #\n");
1399:   PetscFPrintf(comm, fd, "      #                                                        #\n");
1400:   PetscFPrintf(comm, fd, "      ##########################################################\n\n\n");
1401:   return(0);
1402: }

1404: static PetscErrorCode PetscLogViewWarnDebugging(MPI_Comm comm,FILE *fd)
1405: {

1409:   if (PetscDefined(USE_DEBUG)) {
1410:     PetscFPrintf(comm, fd, "\n\n");
1411:     PetscFPrintf(comm, fd, "      ##########################################################\n");
1412:     PetscFPrintf(comm, fd, "      #                                                        #\n");
1413:     PetscFPrintf(comm, fd, "      #                       WARNING!!!                       #\n");
1414:     PetscFPrintf(comm, fd, "      #                                                        #\n");
1415:     PetscFPrintf(comm, fd, "      #   This code was compiled with a debugging option.      #\n");
1416:     PetscFPrintf(comm, fd, "      #   To get timing results run ./configure                #\n");
1417:     PetscFPrintf(comm, fd, "      #   using --with-debugging=no, the performance will      #\n");
1418:     PetscFPrintf(comm, fd, "      #   be generally two or three times faster.              #\n");
1419:     PetscFPrintf(comm, fd, "      #                                                        #\n");
1420:     PetscFPrintf(comm, fd, "      ##########################################################\n\n\n");
1421:   }
1422:   return(0);
1423: }

1425: static PetscErrorCode PetscLogViewWarnNoGpuAwareMpi(MPI_Comm comm,FILE *fd)
1426: {
1427: #if defined(PETSC_HAVE_CUDA) || defined(PETSC_HAVE_HIP)

1431:   if (use_gpu_aware_mpi || !PetscCreatedGpuObjects) return(0);
1432:   PetscFPrintf(comm, fd, "\n\n");
1433:   PetscFPrintf(comm, fd, "      ##########################################################\n");
1434:   PetscFPrintf(comm, fd, "      #                                                        #\n");
1435:   PetscFPrintf(comm, fd, "      #                       WARNING!!!                       #\n");
1436:   PetscFPrintf(comm, fd, "      #                                                        #\n");
1437:   PetscFPrintf(comm, fd, "      # This code was compiled with GPU support and you've     #\n");
1438:   PetscFPrintf(comm, fd, "      # created PETSc/GPU objects, but you intentionally used  #\n");
1439:   PetscFPrintf(comm, fd, "      # -use_gpu_aware_mpi 0, such that PETSc had to copy data #\n");
1440:   PetscFPrintf(comm, fd, "      # from GPU to CPU for communication. To get meaningfull  #\n");
1441:   PetscFPrintf(comm, fd, "      # timing results, please use GPU-aware MPI instead.      #\n");
1442:   PetscFPrintf(comm, fd, "      ##########################################################\n\n\n");
1443:   return(0);
1444: #else
1445:   return 0;
1446: #endif
1447: }

1449: PetscErrorCode  PetscLogView_Default(PetscViewer viewer)
1450: {
1451:   FILE               *fd;
1452:   PetscLogDouble     zero       = 0.0;
1453:   PetscStageLog      stageLog;
1454:   PetscStageInfo     *stageInfo = NULL;
1455:   PetscEventPerfInfo *eventInfo = NULL;
1456:   PetscClassPerfInfo *classInfo;
1457:   char               arch[128],hostname[128],username[128],pname[PETSC_MAX_PATH_LEN],date[128];
1458:   const char         *name;
1459:   PetscLogDouble     locTotalTime, TotalTime, TotalFlops;
1460:   PetscLogDouble     numMessages, messageLength, avgMessLen, numReductions;
1461:   PetscLogDouble     stageTime, flops, flopr, mem, mess, messLen, red;
1462:   PetscLogDouble     fracTime, fracFlops, fracMessages, fracLength, fracReductions, fracMess, fracMessLen, fracRed;
1463:   PetscLogDouble     fracStageTime, fracStageFlops, fracStageMess, fracStageMessLen, fracStageRed;
1464:   PetscLogDouble     min, max, tot, ratio, avg, x, y;
1465:   PetscLogDouble     minf, maxf, totf, ratf, mint, maxt, tott, ratt, ratC, totm, totml, totr, mal, malmax, emalmax;
1466:   #if defined(PETSC_HAVE_DEVICE)
1467:   PetscLogDouble     cct, gct, csz, gsz, gmaxt, gflops, gflopr, fracgflops;
1468:   #endif
1469:   PetscMPIInt        minC, maxC;
1470:   PetscMPIInt        size, rank;
1471:   PetscBool          *localStageUsed,    *stageUsed;
1472:   PetscBool          *localStageVisible, *stageVisible;
1473:   int                numStages, localNumEvents, numEvents;
1474:   int                stage, oclass;
1475:   PetscLogEvent      event;
1476:   PetscErrorCode     ierr;
1477:   char               version[256];
1478:   MPI_Comm           comm;

1481:   PetscObjectGetComm((PetscObject)viewer,&comm);
1482:   PetscViewerASCIIGetPointer(viewer,&fd);
1483:   MPI_Comm_size(comm, &size);
1484:   MPI_Comm_rank(comm, &rank);
1485:   /* Get the total elapsed time */
1486:   PetscTime(&locTotalTime);  locTotalTime -= petsc_BaseTime;

1488:   PetscFPrintf(comm, fd, "************************************************************************************************************************\n");
1489:   PetscFPrintf(comm, fd, "***             WIDEN YOUR WINDOW TO 120 CHARACTERS.  Use 'enscript -r -fCourier9' to print this document            ***\n");
1490:   PetscFPrintf(comm, fd, "************************************************************************************************************************\n");
1491:   PetscFPrintf(comm, fd, "\n---------------------------------------------- PETSc Performance Summary: ----------------------------------------------\n\n");
1492:   PetscLogViewWarnSync(comm,fd);
1493:   PetscLogViewWarnDebugging(comm,fd);
1494:   PetscLogViewWarnNoGpuAwareMpi(comm,fd);
1495:   PetscGetArchType(arch,sizeof(arch));
1496:   PetscGetHostName(hostname,sizeof(hostname));
1497:   PetscGetUserName(username,sizeof(username));
1498:   PetscGetProgramName(pname,sizeof(pname));
1499:   PetscGetDate(date,sizeof(date));
1500:   PetscGetVersion(version,sizeof(version));
1501:   if (size == 1) {
1502:     PetscFPrintf(comm,fd,"%s on a %s named %s with %d processor, by %s %s\n", pname, arch, hostname, size, username, date);
1503:   } else {
1504:     PetscFPrintf(comm,fd,"%s on a %s named %s with %d processors, by %s %s\n", pname, arch, hostname, size, username, date);
1505:   }
1506: #if defined(PETSC_HAVE_OPENMP)
1507:   PetscFPrintf(comm,fd,"Using %D OpenMP threads\n", PetscNumOMPThreads);
1508: #endif
1509:   PetscFPrintf(comm, fd, "Using %s\n", version);

1511:   /* Must preserve reduction count before we go on */
1512:   red = petsc_allreduce_ct + petsc_gather_ct + petsc_scatter_ct;

1514:   /* Calculate summary information */
1515:   PetscFPrintf(comm, fd, "\n                         Max       Max/Min     Avg       Total\n");
1516:   /*   Time */
1517:   MPI_Allreduce(&locTotalTime, &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);
1518:   MPI_Allreduce(&locTotalTime, &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1519:   MPI_Allreduce(&locTotalTime, &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1520:   avg  = tot/((PetscLogDouble) size);
1521:   if (min != 0.0) ratio = max/min; else ratio = 0.0;
1522:   PetscFPrintf(comm, fd, "Time (sec):           %5.3e   %7.3f   %5.3e\n", max, ratio, avg);
1523:   TotalTime = tot;
1524:   /*   Objects */
1525:   avg  = (PetscLogDouble) petsc_numObjects;
1526:   MPI_Allreduce(&avg,          &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);
1527:   MPI_Allreduce(&avg,          &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1528:   MPI_Allreduce(&avg,          &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1529:   avg  = tot/((PetscLogDouble) size);
1530:   if (min != 0.0) ratio = max/min; else ratio = 0.0;
1531:   PetscFPrintf(comm, fd, "Objects:              %5.3e   %7.3f   %5.3e\n", max, ratio, avg);
1532:   /*   Flops */
1533:   MPI_Allreduce(&petsc_TotalFlops,  &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);
1534:   MPI_Allreduce(&petsc_TotalFlops,  &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1535:   MPI_Allreduce(&petsc_TotalFlops,  &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1536:   avg  = tot/((PetscLogDouble) size);
1537:   if (min != 0.0) ratio = max/min; else ratio = 0.0;
1538:   PetscFPrintf(comm, fd, "Flop:                 %5.3e   %7.3f   %5.3e  %5.3e\n", max, ratio, avg, tot);
1539:   TotalFlops = tot;
1540:   /*   Flops/sec -- Must talk to Barry here */
1541:   if (locTotalTime != 0.0) flops = petsc_TotalFlops/locTotalTime; else flops = 0.0;
1542:   MPI_Allreduce(&flops,        &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);
1543:   MPI_Allreduce(&flops,        &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1544:   MPI_Allreduce(&flops,        &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1545:   avg  = tot/((PetscLogDouble) size);
1546:   if (min != 0.0) ratio = max/min; else ratio = 0.0;
1547:   PetscFPrintf(comm, fd, "Flop/sec:             %5.3e   %7.3f   %5.3e  %5.3e\n", max, ratio, avg, tot);
1548:   /*   Memory */
1549:   PetscMallocGetMaximumUsage(&mem);
1550:   if (mem > 0.0) {
1551:     MPI_Allreduce(&mem,          &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);
1552:     MPI_Allreduce(&mem,          &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1553:     MPI_Allreduce(&mem,          &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1554:     avg  = tot/((PetscLogDouble) size);
1555:     if (min != 0.0) ratio = max/min; else ratio = 0.0;
1556:     PetscFPrintf(comm, fd, "Memory:               %5.3e   %7.3f   %5.3e  %5.3e\n", max, ratio, avg, tot);
1557:   }
1558:   /*   Messages */
1559:   mess = 0.5*(petsc_irecv_ct + petsc_isend_ct + petsc_recv_ct + petsc_send_ct);
1560:   MPI_Allreduce(&mess,         &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);
1561:   MPI_Allreduce(&mess,         &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1562:   MPI_Allreduce(&mess,         &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1563:   avg  = tot/((PetscLogDouble) size);
1564:   if (min != 0.0) ratio = max/min; else ratio = 0.0;
1565:   PetscFPrintf(comm, fd, "MPI Messages:         %5.3e   %7.3f   %5.3e  %5.3e\n", max, ratio, avg, tot);
1566:   numMessages = tot;
1567:   /*   Message Lengths */
1568:   mess = 0.5*(petsc_irecv_len + petsc_isend_len + petsc_recv_len + petsc_send_len);
1569:   MPI_Allreduce(&mess,         &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);
1570:   MPI_Allreduce(&mess,         &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1571:   MPI_Allreduce(&mess,         &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1572:   if (numMessages != 0) avg = tot/numMessages; else avg = 0.0;
1573:   if (min != 0.0) ratio = max/min; else ratio = 0.0;
1574:   PetscFPrintf(comm, fd, "MPI Message Lengths:  %5.3e   %7.3f   %5.3e  %5.3e\n", max, ratio, avg, tot);
1575:   messageLength = tot;
1576:   /*   Reductions */
1577:   MPI_Allreduce(&red,          &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);
1578:   MPI_Allreduce(&red,          &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1579:   MPI_Allreduce(&red,          &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1580:   if (min != 0.0) ratio = max/min; else ratio = 0.0;
1581:   PetscFPrintf(comm, fd, "MPI Reductions:       %5.3e   %7.3f\n", max, ratio);
1582:   numReductions = red; /* wrong because uses count from process zero */
1583:   PetscFPrintf(comm, fd, "\nFlop counting convention: 1 flop = 1 real number operation of type (multiply/divide/add/subtract)\n");
1584:   PetscFPrintf(comm, fd, "                            e.g., VecAXPY() for real vectors of length N --> 2N flop\n");
1585:   PetscFPrintf(comm, fd, "                            and VecAXPY() for complex vectors of length N --> 8N flop\n");

1587:   /* Get total number of stages --
1588:        Currently, a single processor can register more stages than another, but stages must all be registered in order.
1589:        We can removed this requirement if necessary by having a global stage numbering and indirection on the stage ID.
1590:        This seems best accomplished by assoicating a communicator with each stage.
1591:   */
1592:   PetscLogGetStageLog(&stageLog);
1593:   MPI_Allreduce(&stageLog->numStages, &numStages, 1, MPI_INT, MPI_MAX, comm);
1594:   PetscMalloc1(numStages, &localStageUsed);
1595:   PetscMalloc1(numStages, &stageUsed);
1596:   PetscMalloc1(numStages, &localStageVisible);
1597:   PetscMalloc1(numStages, &stageVisible);
1598:   if (numStages > 0) {
1599:     stageInfo = stageLog->stageInfo;
1600:     for (stage = 0; stage < numStages; stage++) {
1601:       if (stage < stageLog->numStages) {
1602:         localStageUsed[stage]    = stageInfo[stage].used;
1603:         localStageVisible[stage] = stageInfo[stage].perfInfo.visible;
1604:       } else {
1605:         localStageUsed[stage]    = PETSC_FALSE;
1606:         localStageVisible[stage] = PETSC_TRUE;
1607:       }
1608:     }
1609:     MPI_Allreduce(localStageUsed,    stageUsed,    numStages, MPIU_BOOL, MPI_LOR,  comm);
1610:     MPI_Allreduce(localStageVisible, stageVisible, numStages, MPIU_BOOL, MPI_LAND, comm);
1611:     for (stage = 0; stage < numStages; stage++) {
1612:       if (stageUsed[stage]) {
1613:         PetscFPrintf(comm, fd, "\nSummary of Stages:   ----- Time ------  ----- Flop ------  --- Messages ---  -- Message Lengths --  -- Reductions --\n");
1614:         PetscFPrintf(comm, fd, "                        Avg     %%Total     Avg     %%Total    Count   %%Total     Avg         %%Total    Count   %%Total\n");
1615:         break;
1616:       }
1617:     }
1618:     for (stage = 0; stage < numStages; stage++) {
1619:       if (!stageUsed[stage]) continue;
1620:       /* CANNOT use MPI_Allreduce() since it might fail the line number check */
1621:       if (localStageUsed[stage]) {
1622:         MPI_Allreduce(&stageInfo[stage].perfInfo.time,          &stageTime, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1623:         MPI_Allreduce(&stageInfo[stage].perfInfo.flops,         &flops,     1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1624:         MPI_Allreduce(&stageInfo[stage].perfInfo.numMessages,   &mess,      1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1625:         MPI_Allreduce(&stageInfo[stage].perfInfo.messageLength, &messLen,   1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1626:         MPI_Allreduce(&stageInfo[stage].perfInfo.numReductions, &red,       1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1627:         name = stageInfo[stage].name;
1628:       } else {
1629:         MPI_Allreduce(&zero,                           &stageTime, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1630:         MPI_Allreduce(&zero,                           &flops,     1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1631:         MPI_Allreduce(&zero,                           &mess,      1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1632:         MPI_Allreduce(&zero,                           &messLen,   1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1633:         MPI_Allreduce(&zero,                           &red,       1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1634:         name = "";
1635:       }
1636:       mess *= 0.5; messLen *= 0.5; red /= size;
1637:       if (TotalTime     != 0.0) fracTime       = stageTime/TotalTime;    else fracTime       = 0.0;
1638:       if (TotalFlops    != 0.0) fracFlops      = flops/TotalFlops;       else fracFlops      = 0.0;
1639:       /* Talk to Barry if (stageTime     != 0.0) flops          = (size*flops)/stageTime; else flops          = 0.0; */
1640:       if (numMessages   != 0.0) fracMessages   = mess/numMessages;       else fracMessages   = 0.0;
1641:       if (mess          != 0.0) avgMessLen     = messLen/mess;           else avgMessLen     = 0.0;
1642:       if (messageLength != 0.0) fracLength     = messLen/messageLength;  else fracLength     = 0.0;
1643:       if (numReductions != 0.0) fracReductions = red/numReductions;      else fracReductions = 0.0;
1644:       PetscFPrintf(comm, fd, "%2d: %15s: %6.4e %5.1f%%  %6.4e %5.1f%%  %5.3e %5.1f%%  %5.3e      %5.1f%%  %5.3e %5.1f%%\n",
1645:                           stage, name, stageTime/size, 100.0*fracTime, flops, 100.0*fracFlops,
1646:                           mess, 100.0*fracMessages, avgMessLen, 100.0*fracLength, red, 100.0*fracReductions);
1647:     }
1648:   }

1650:   PetscFPrintf(comm, fd,"\n------------------------------------------------------------------------------------------------------------------------\n");
1651:   PetscFPrintf(comm, fd, "See the 'Profiling' chapter of the users' manual for details on interpreting output.\n");
1652:   PetscFPrintf(comm, fd, "Phase summary info:\n");
1653:   PetscFPrintf(comm, fd, "   Count: number of times phase was executed\n");
1654:   PetscFPrintf(comm, fd, "   Time and Flop: Max - maximum over all processors\n");
1655:   PetscFPrintf(comm, fd, "                  Ratio - ratio of maximum to minimum over all processors\n");
1656:   PetscFPrintf(comm, fd, "   Mess: number of messages sent\n");
1657:   PetscFPrintf(comm, fd, "   AvgLen: average message length (bytes)\n");
1658:   PetscFPrintf(comm, fd, "   Reduct: number of global reductions\n");
1659:   PetscFPrintf(comm, fd, "   Global: entire computation\n");
1660:   PetscFPrintf(comm, fd, "   Stage: stages of a computation. Set stages with PetscLogStagePush() and PetscLogStagePop().\n");
1661:   PetscFPrintf(comm, fd, "      %%T - percent time in this phase         %%F - percent flop in this phase\n");
1662:   PetscFPrintf(comm, fd, "      %%M - percent messages in this phase     %%L - percent message lengths in this phase\n");
1663:   PetscFPrintf(comm, fd, "      %%R - percent reductions in this phase\n");
1664:   PetscFPrintf(comm, fd, "   Total Mflop/s: 10e-6 * (sum of flop over all processors)/(max time over all processors)\n");
1665:   if (PetscLogMemory) {
1666:     PetscFPrintf(comm, fd, "   Malloc Mbytes: Memory allocated and kept during event (sum over all calls to event)\n");
1667:     PetscFPrintf(comm, fd, "   EMalloc Mbytes: extra memory allocated during event and then freed (maximum over all calls to events)\n");
1668:     PetscFPrintf(comm, fd, "   MMalloc Mbytes: Increase in high water mark of allocated memory (sum over all calls to event)\n");
1669:     PetscFPrintf(comm, fd, "   RMI Mbytes: Increase in resident memory (sum over all calls to event)\n");
1670:   }
1671:   #if defined(PETSC_HAVE_DEVICE)
1672:   PetscFPrintf(comm, fd, "   GPU Mflop/s: 10e-6 * (sum of flop on GPU over all processors)/(max GPU time over all processors)\n");
1673:   PetscFPrintf(comm, fd, "   CpuToGpu Count: total number of CPU to GPU copies per processor\n");
1674:   PetscFPrintf(comm, fd, "   CpuToGpu Size (Mbytes): 10e-6 * (total size of CPU to GPU copies per processor)\n");
1675:   PetscFPrintf(comm, fd, "   GpuToCpu Count: total number of GPU to CPU copies per processor\n");
1676:   PetscFPrintf(comm, fd, "   GpuToCpu Size (Mbytes): 10e-6 * (total size of GPU to CPU copies per processor)\n");
1677:   PetscFPrintf(comm, fd, "   GPU %%F: percent flops on GPU in this event\n");
1678:   #endif
1679:   PetscFPrintf(comm, fd, "------------------------------------------------------------------------------------------------------------------------\n");

1681:   PetscLogViewWarnDebugging(comm,fd);

1683:   /* Report events */
1684:   PetscFPrintf(comm, fd,"Event                Count      Time (sec)     Flop                              --- Global ---  --- Stage ----  Total");
1685:   if (PetscLogMemory) {
1686:     PetscFPrintf(comm, fd,"  Malloc EMalloc MMalloc RMI");
1687:   }
1688:   #if defined(PETSC_HAVE_DEVICE)
1689:   PetscFPrintf(comm, fd,"   GPU    - CpuToGpu -   - GpuToCpu - GPU");
1690:   #endif
1691:   PetscFPrintf(comm, fd,"\n");
1692:   PetscFPrintf(comm, fd,"                   Max Ratio  Max     Ratio   Max  Ratio  Mess   AvgLen  Reduct  %%T %%F %%M %%L %%R  %%T %%F %%M %%L %%R Mflop/s");
1693:   if (PetscLogMemory) {
1694:     PetscFPrintf(comm, fd," Mbytes Mbytes Mbytes Mbytes");
1695:   }
1696:   #if defined(PETSC_HAVE_DEVICE)
1697:   PetscFPrintf(comm, fd," Mflop/s Count   Size   Count   Size  %%F");
1698:   #endif
1699:   PetscFPrintf(comm, fd,"\n");
1700:   PetscFPrintf(comm, fd,"------------------------------------------------------------------------------------------------------------------------");
1701:   if (PetscLogMemory) {
1702:     PetscFPrintf(comm, fd,"-----------------------------");
1703:   }
1704:   #if defined(PETSC_HAVE_DEVICE)
1705:   PetscFPrintf(comm, fd,"---------------------------------------");
1706:   #endif
1707:   PetscFPrintf(comm, fd,"\n");

1709:   /* Problem: The stage name will not show up unless the stage executed on proc 1 */
1710:   for (stage = 0; stage < numStages; stage++) {
1711:     if (!stageVisible[stage]) continue;
1712:     /* CANNOT use MPI_Allreduce() since it might fail the line number check */
1713:     if (localStageUsed[stage]) {
1714:       PetscFPrintf(comm, fd, "\n--- Event Stage %d: %s\n\n", stage, stageInfo[stage].name);
1715:       MPI_Allreduce(&stageInfo[stage].perfInfo.time,          &stageTime, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1716:       MPI_Allreduce(&stageInfo[stage].perfInfo.flops,         &flops,     1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1717:       MPI_Allreduce(&stageInfo[stage].perfInfo.numMessages,   &mess,      1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1718:       MPI_Allreduce(&stageInfo[stage].perfInfo.messageLength, &messLen,   1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1719:       MPI_Allreduce(&stageInfo[stage].perfInfo.numReductions, &red,       1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1720:     } else {
1721:       PetscFPrintf(comm, fd, "\n--- Event Stage %d: Unknown\n\n", stage);
1722:       MPI_Allreduce(&zero,                           &stageTime, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1723:       MPI_Allreduce(&zero,                           &flops,     1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1724:       MPI_Allreduce(&zero,                           &mess,      1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1725:       MPI_Allreduce(&zero,                           &messLen,   1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1726:       MPI_Allreduce(&zero,                           &red,       1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1727:     }
1728:     mess *= 0.5; messLen *= 0.5; red /= size;

1730:     /* Get total number of events in this stage --
1731:        Currently, a single processor can register more events than another, but events must all be registered in order,
1732:        just like stages. We can removed this requirement if necessary by having a global event numbering and indirection
1733:        on the event ID. This seems best accomplished by associating a communicator with each stage.

1735:        Problem: If the event did not happen on proc 1, its name will not be available.
1736:        Problem: Event visibility is not implemented
1737:     */
1738:     if (localStageUsed[stage]) {
1739:       eventInfo      = stageLog->stageInfo[stage].eventLog->eventInfo;
1740:       localNumEvents = stageLog->stageInfo[stage].eventLog->numEvents;
1741:     } else localNumEvents = 0;
1742:     MPI_Allreduce(&localNumEvents, &numEvents, 1, MPI_INT, MPI_MAX, comm);
1743:     for (event = 0; event < numEvents; event++) {
1744:       /* CANNOT use MPI_Allreduce() since it might fail the line number check */
1745:       if (localStageUsed[stage] && (event < stageLog->stageInfo[stage].eventLog->numEvents) && (eventInfo[event].depth == 0)) {
1746:         if ((eventInfo[event].count > 0) && (eventInfo[event].time > 0.0)) flopr = eventInfo[event].flops; else flopr = 0.0;
1747:         MPI_Allreduce(&flopr,                          &minf,  1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);
1748:         MPI_Allreduce(&flopr,                          &maxf,  1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1749:         MPI_Allreduce(&eventInfo[event].flops,         &totf,  1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1750:         MPI_Allreduce(&eventInfo[event].time,          &mint,  1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);
1751:         MPI_Allreduce(&eventInfo[event].time,          &maxt,  1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1752:         MPI_Allreduce(&eventInfo[event].time,          &tott,  1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1753:         MPI_Allreduce(&eventInfo[event].numMessages,   &totm,  1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1754:         MPI_Allreduce(&eventInfo[event].messageLength, &totml, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1755:         MPI_Allreduce(&eventInfo[event].numReductions, &totr,  1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1756:         MPI_Allreduce(&eventInfo[event].count,         &minC,  1, MPI_INT,             MPI_MIN, comm);
1757:         MPI_Allreduce(&eventInfo[event].count,         &maxC,  1, MPI_INT,             MPI_MAX, comm);
1758:         if (PetscLogMemory) {
1759:           MPI_Allreduce(&eventInfo[event].memIncrease,    &mem,   1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1760:           MPI_Allreduce(&eventInfo[event].mallocSpace,    &mal,   1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1761:           MPI_Allreduce(&eventInfo[event].mallocIncrease, &malmax,1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1762:           MPI_Allreduce(&eventInfo[event].mallocIncreaseEvent, &emalmax,1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1763:         }
1764:         #if defined(PETSC_HAVE_DEVICE)
1765:         MPI_Allreduce(&eventInfo[event].CpuToGpuCount,    &cct,   1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1766:         MPI_Allreduce(&eventInfo[event].GpuToCpuCount,    &gct,   1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1767:         MPI_Allreduce(&eventInfo[event].CpuToGpuSize,     &csz,   1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1768:         MPI_Allreduce(&eventInfo[event].GpuToCpuSize,     &gsz,   1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1769:         MPI_Allreduce(&eventInfo[event].GpuFlops,         &gflops,1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1770:         MPI_Allreduce(&eventInfo[event].GpuTime,          &gmaxt ,1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1771:         #endif
1772:         name = stageLog->eventLog->eventInfo[event].name;
1773:       } else {
1774:         flopr = 0.0;
1775:         MPI_Allreduce(&flopr,                         &minf,  1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);
1776:         MPI_Allreduce(&flopr,                         &maxf,  1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1777:         MPI_Allreduce(&zero,                          &totf,  1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1778:         MPI_Allreduce(&zero,                          &mint,  1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);
1779:         MPI_Allreduce(&zero,                          &maxt,  1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1780:         MPI_Allreduce(&zero,                          &tott,  1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1781:         MPI_Allreduce(&zero,                          &totm,  1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1782:         MPI_Allreduce(&zero,                          &totml, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1783:         MPI_Allreduce(&zero,                          &totr,  1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1784:         MPI_Allreduce(&ierr,                          &minC,  1, MPI_INT,             MPI_MIN, comm);
1785:         MPI_Allreduce(&ierr,                          &maxC,  1, MPI_INT,             MPI_MAX, comm);
1786:         if (PetscLogMemory) {
1787:           MPI_Allreduce(&zero,                        &mem,    1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1788:           MPI_Allreduce(&zero,                        &mal,    1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1789:           MPI_Allreduce(&zero,                        &malmax, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1790:           MPI_Allreduce(&zero,                        &emalmax,1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1791:         }
1792:         #if defined(PETSC_HAVE_DEVICE)
1793:         MPI_Allreduce(&zero,                          &cct,    1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1794:         MPI_Allreduce(&zero,                          &gct,    1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1795:         MPI_Allreduce(&zero,                          &csz,    1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1796:         MPI_Allreduce(&zero,                          &gsz,    1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1797:         MPI_Allreduce(&zero,                          &gflops, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);
1798:         MPI_Allreduce(&zero,                          &gmaxt , 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);
1799:         #endif
1800:         name  = "";
1801:       }
1802:       if (mint < 0.0) {
1803:         PetscFPrintf(comm, fd, "WARNING!!! Minimum time %g over all processors for %s is negative! This happens\n on some machines whose times cannot handle too rapid calls.!\n artificially changing minimum to zero.\n",mint,name);
1804:         mint = 0;
1805:       }
1806:       if (minf < 0.0) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Minimum flop %g over all processors for %s is negative! Not possible!",minf,name);
1807:       totm *= 0.5; totml *= 0.5; totr /= size;

1809:       if (maxC != 0) {
1810:         if (minC          != 0)   ratC             = ((PetscLogDouble)maxC)/minC;else ratC             = 0.0;
1811:         if (mint          != 0.0) ratt             = maxt/mint;                  else ratt             = 0.0;
1812:         if (minf          != 0.0) ratf             = maxf/minf;                  else ratf             = 0.0;
1813:         if (TotalTime     != 0.0) fracTime         = tott/TotalTime;             else fracTime         = 0.0;
1814:         if (TotalFlops    != 0.0) fracFlops        = totf/TotalFlops;            else fracFlops        = 0.0;
1815:         if (stageTime     != 0.0) fracStageTime    = tott/stageTime;             else fracStageTime    = 0.0;
1816:         if (flops         != 0.0) fracStageFlops   = totf/flops;                 else fracStageFlops   = 0.0;
1817:         if (numMessages   != 0.0) fracMess         = totm/numMessages;           else fracMess         = 0.0;
1818:         if (messageLength != 0.0) fracMessLen      = totml/messageLength;        else fracMessLen      = 0.0;
1819:         if (numReductions != 0.0) fracRed          = totr/numReductions;         else fracRed          = 0.0;
1820:         if (mess          != 0.0) fracStageMess    = totm/mess;                  else fracStageMess    = 0.0;
1821:         if (messLen       != 0.0) fracStageMessLen = totml/messLen;              else fracStageMessLen = 0.0;
1822:         if (red           != 0.0) fracStageRed     = totr/red;                   else fracStageRed     = 0.0;
1823:         if (totm          != 0.0) totml           /= totm;                       else totml            = 0.0;
1824:         if (maxt          != 0.0) flopr            = totf/maxt;                  else flopr            = 0.0;
1825:         if (fracStageTime > 1.00) {PetscFPrintf(comm, fd,"Warning -- total time of event greater than time of entire stage -- something is wrong with the timer\n");}
1826:         PetscFPrintf(comm, fd,
1827:                             "%-16s %7d%4.1f %5.4e%4.1f %3.2e%4.1f %2.1e %2.1e %2.1e%3.0f%3.0f%3.0f%3.0f%3.0f %3.0f%3.0f%3.0f%3.0f%3.0f %5.0f",
1828:                             name, maxC, ratC, maxt, ratt, maxf, ratf, totm, totml, totr,
1829:                             100.0*fracTime, 100.0*fracFlops, 100.0*fracMess, 100.0*fracMessLen, 100.0*fracRed,
1830:                             100.0*fracStageTime, 100.0*fracStageFlops, 100.0*fracStageMess, 100.0*fracStageMessLen, 100.0*fracStageRed,
1831:                             PetscAbs(flopr)/1.0e6);
1832:         if (PetscLogMemory) {
1833:           PetscFPrintf(comm, fd," %5.0f   %5.0f   %5.0f   %5.0f",mal/1.0e6,emalmax/1.0e6,malmax/1.0e6,mem/1.0e6);
1834:         }
1835:         #if defined(PETSC_HAVE_DEVICE)
1836:         if (totf  != 0.0) fracgflops = gflops/totf;  else fracgflops = 0.0;
1837:         if (gmaxt != 0.0) gflopr     = gflops/gmaxt; else gflopr     = 0.0;
1838:         PetscFPrintf(comm, fd,"   %5.0f   %4.0f %3.2e %4.0f %3.2e% 3.0f",PetscAbs(gflopr)/1.0e6,cct/size,csz/(1.0e6*size),gct/size,gsz/(1.0e6*size),100.0*fracgflops);
1839:         #endif
1840:         PetscFPrintf(comm, fd,"\n");
1841:       }
1842:     }
1843:   }

1845:   /* Memory usage and object creation */
1846:   PetscFPrintf(comm, fd, "------------------------------------------------------------------------------------------------------------------------");
1847:   if (PetscLogMemory) {
1848:     PetscFPrintf(comm, fd, "-----------------------------");
1849:   }
1850:   #if defined(PETSC_HAVE_DEVICE)
1851:   PetscFPrintf(comm, fd, "---------------------------------------");
1852:   #endif
1853:   PetscFPrintf(comm, fd, "\n");
1854:   PetscFPrintf(comm, fd, "\n");
1855:   PetscFPrintf(comm, fd, "Memory usage is given in bytes:\n\n");

1857:   /* Right now, only stages on the first processor are reported here, meaning only objects associated with
1858:      the global communicator, or MPI_COMM_SELF for proc 1. We really should report global stats and then
1859:      stats for stages local to processor sets.
1860:   */
1861:   /* We should figure out the longest object name here (now 20 characters) */
1862:   PetscFPrintf(comm, fd, "Object Type          Creations   Destructions     Memory  Descendants' Mem.\n");
1863:   PetscFPrintf(comm, fd, "Reports information only for process 0.\n");
1864:   for (stage = 0; stage < numStages; stage++) {
1865:     if (localStageUsed[stage]) {
1866:       classInfo = stageLog->stageInfo[stage].classLog->classInfo;
1867:       PetscFPrintf(comm, fd, "\n--- Event Stage %d: %s\n\n", stage, stageInfo[stage].name);
1868:       for (oclass = 0; oclass < stageLog->stageInfo[stage].classLog->numClasses; oclass++) {
1869:         if ((classInfo[oclass].creations > 0) || (classInfo[oclass].destructions > 0)) {
1870:           PetscFPrintf(comm, fd, "%20s %5d          %5d  %11.0f     %g\n", stageLog->classLog->classInfo[oclass].name,
1871:                               classInfo[oclass].creations, classInfo[oclass].destructions, classInfo[oclass].mem,
1872:                               classInfo[oclass].descMem);
1873:         }
1874:       }
1875:     } else {
1876:       if (!localStageVisible[stage]) continue;
1877:       PetscFPrintf(comm, fd, "\n--- Event Stage %d: Unknown\n\n", stage);
1878:     }
1879:   }

1881:   PetscFree(localStageUsed);
1882:   PetscFree(stageUsed);
1883:   PetscFree(localStageVisible);
1884:   PetscFree(stageVisible);

1886:   /* Information unrelated to this particular run */
1887:   PetscFPrintf(comm, fd, "========================================================================================================================\n");
1888:   PetscTime(&y);
1889:   PetscTime(&x);
1890:   PetscTime(&y); PetscTime(&y); PetscTime(&y); PetscTime(&y); PetscTime(&y);
1891:   PetscTime(&y); PetscTime(&y); PetscTime(&y); PetscTime(&y); PetscTime(&y);
1892:   PetscFPrintf(comm,fd,"Average time to get PetscTime(): %g\n", (y-x)/10.0);
1893:   /* MPI information */
1894:   if (size > 1) {
1895:     MPI_Status  status;
1896:     PetscMPIInt tag;
1897:     MPI_Comm    newcomm;

1899:     MPI_Barrier(comm);
1900:     PetscTime(&x);
1901:     MPI_Barrier(comm);
1902:     MPI_Barrier(comm);
1903:     MPI_Barrier(comm);
1904:     MPI_Barrier(comm);
1905:     MPI_Barrier(comm);
1906:     PetscTime(&y);
1907:     PetscFPrintf(comm, fd, "Average time for MPI_Barrier(): %g\n", (y-x)/5.0);
1908:     PetscCommDuplicate(comm,&newcomm, &tag);
1909:     MPI_Barrier(comm);
1910:     if (rank) {
1911:       MPI_Recv(NULL, 0, MPI_INT, rank-1,            tag, newcomm, &status);
1912:       MPI_Send(NULL, 0, MPI_INT, (rank+1)%size, tag, newcomm);
1913:     } else {
1914:       PetscTime(&x);
1915:       MPI_Send(NULL, 0, MPI_INT, 1,          tag, newcomm);
1916:       MPI_Recv(NULL, 0, MPI_INT, size-1, tag, newcomm, &status);
1917:       PetscTime(&y);
1918:       PetscFPrintf(comm,fd,"Average time for zero size MPI_Send(): %g\n", (y-x)/size);
1919:     }
1920:     PetscCommDestroy(&newcomm);
1921:   }
1922:   PetscOptionsView(NULL,viewer);

1924:   /* Machine and compile information */
1925: #if defined(PETSC_USE_FORTRAN_KERNELS)
1926:   PetscFPrintf(comm, fd, "Compiled with FORTRAN kernels\n");
1927: #else
1928:   PetscFPrintf(comm, fd, "Compiled without FORTRAN kernels\n");
1929: #endif
1930: #if defined(PETSC_USE_64BIT_INDICES)
1931:   PetscFPrintf(comm, fd, "Compiled with 64 bit PetscInt\n");
1932: #elif defined(PETSC_USE___FLOAT128)
1933:   PetscFPrintf(comm, fd, "Compiled with 32 bit PetscInt\n");
1934: #endif
1935: #if defined(PETSC_USE_REAL_SINGLE)
1936:   PetscFPrintf(comm, fd, "Compiled with single precision PetscScalar and PetscReal\n");
1937: #elif defined(PETSC_USE___FLOAT128)
1938:   PetscFPrintf(comm, fd, "Compiled with 128 bit precision PetscScalar and PetscReal\n");
1939: #endif
1940: #if defined(PETSC_USE_REAL_MAT_SINGLE)
1941:   PetscFPrintf(comm, fd, "Compiled with single precision matrices\n");
1942: #else
1943:   PetscFPrintf(comm, fd, "Compiled with full precision matrices (default)\n");
1944: #endif
1945:   PetscFPrintf(comm, fd, "sizeof(short) %d sizeof(int) %d sizeof(long) %d sizeof(void*) %d sizeof(PetscScalar) %d sizeof(PetscInt) %d\n",
1946:                       (int) sizeof(short), (int) sizeof(int), (int) sizeof(long), (int) sizeof(void*),(int) sizeof(PetscScalar),(int) sizeof(PetscInt));

1948:   PetscFPrintf(comm, fd, "Configure options: %s",petscconfigureoptions);
1949:   PetscFPrintf(comm, fd, "%s", petscmachineinfo);
1950:   PetscFPrintf(comm, fd, "%s", petsccompilerinfo);
1951:   PetscFPrintf(comm, fd, "%s", petsccompilerflagsinfo);
1952:   PetscFPrintf(comm, fd, "%s", petsclinkerinfo);

1954:   /* Cleanup */
1955:   PetscFPrintf(comm, fd, "\n");
1956:   PetscLogViewWarnNoGpuAwareMpi(comm,fd);
1957:   PetscLogViewWarnDebugging(comm,fd);
1958:   return(0);
1959: }

1961: /*@C
1962:   PetscLogView - Prints a summary of the logging.

1964:   Collective over MPI_Comm

1966:   Input Parameter:
1967: .  viewer - an ASCII viewer

1969:   Options Database Keys:
1970: +  -log_view [:filename] - Prints summary of log information
1971: .  -log_view :filename.py:ascii_info_detail - Saves logging information from each process as a Python file
1972: .  -log_view :filename.xml:ascii_xml - Saves a summary of the logging information in a nested format (see below for how to view it)
1973: .  -log_view :filename.txt:ascii_flamegraph - Saves logging information in a format suitable for visualising as a Flame Graph (see below for how to view it)
1974: .  -log_all - Saves a file Log.rank for each MPI process with details of each step of the computation
1975: -  -log_trace [filename] - Displays a trace of what each process is doing

1977:   Notes:
1978:   It is possible to control the logging programatically but we recommend using the options database approach whenever possible
1979:   By default the summary is printed to stdout.

1981:   Before calling this routine you must have called either PetscLogDefaultBegin() or PetscLogNestedBegin()

1983:   If PETSc is configured with --with-logging=0 then this functionality is not available

1985:   To view the nested XML format filename.xml first copy  ${PETSC_DIR}/share/petsc/xml/performance_xml2html.xsl to the current
1986:   directory then open filename.xml with your browser. Specific notes for certain browsers
1987: $    Firefox and Internet explorer - simply open the file
1988: $    Google Chrome - you must start up Chrome with the option --allow-file-access-from-files
1989: $    Safari - see https://ccm.net/faq/36342-safari-how-to-enable-local-file-access
1990:   or one can use the package http://xmlsoft.org/XSLT/xsltproc2.html to translate the xml file to html and then open it with
1991:   your browser.
1992:   Alternatively, use the script ${PETSC_DIR}/lib/petsc/bin/petsc-performance-view to automatically open a new browser
1993:   window and render the XML log file contents.

1995:   The nested XML format was kindly donated by Koos Huijssen and Christiaan M. Klaij  MARITIME  RESEARCH  INSTITUTE  NETHERLANDS

1997:   The Flame Graph output can be visualised using either the original Flame Graph script (https://github.com/brendangregg/FlameGraph)
1998:   or using speedscope (https://www.speedscope.app).
1999:   Old XML profiles may be converted into this format using the script ${PETSC_DIR}/lib/petsc/bin/xml2flamegraph.py.

2001:   Level: beginner

2003: .seealso: PetscLogDefaultBegin(), PetscLogDump()
2004: @*/
2005: PetscErrorCode  PetscLogView(PetscViewer viewer)
2006: {
2007:   PetscErrorCode    ierr;
2008:   PetscBool         isascii;
2009:   PetscViewerFormat format;
2010:   int               stage, lastStage;
2011:   PetscStageLog     stageLog;

2014:   if (!PetscLogPLB) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Must use -log_view or PetscLogDefaultBegin() before calling this routine");
2015:   /* Pop off any stages the user forgot to remove */
2016:   lastStage = 0;
2017:   PetscLogGetStageLog(&stageLog);
2018:   PetscStageLogGetCurrent(stageLog, &stage);
2019:   while (stage >= 0) {
2020:     lastStage = stage;
2021:     PetscStageLogPop(stageLog);
2022:     PetscStageLogGetCurrent(stageLog, &stage);
2023:   }
2024:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isascii);
2025:   if (!isascii) SETERRQ(PetscObjectComm((PetscObject)viewer),PETSC_ERR_SUP,"Currently can only view logging to ASCII");
2026:   PetscViewerGetFormat(viewer,&format);
2027:   if (format == PETSC_VIEWER_DEFAULT || format == PETSC_VIEWER_ASCII_INFO) {
2028:     PetscLogView_Default(viewer);
2029:   } else if (format == PETSC_VIEWER_ASCII_INFO_DETAIL) {
2030:     PetscLogView_Detailed(viewer);
2031:   } else if (format == PETSC_VIEWER_ASCII_CSV) {
2032:     PetscLogView_CSV(viewer);
2033:   } else if (format == PETSC_VIEWER_ASCII_XML) {
2034:     PetscLogView_Nested(viewer);
2035:   } else if (format == PETSC_VIEWER_ASCII_FLAMEGRAPH) {
2036:     PetscLogView_Flamegraph(viewer);
2037:   }
2038:   PetscStageLogPush(stageLog, lastStage);
2039:   return(0);
2040: }

2042: /*@C
2043:   PetscLogViewFromOptions - Processes command line options to determine if/how a PetscLog is to be viewed.

2045:   Collective on PETSC_COMM_WORLD

2047:   Not normally called by user

2049:   Level: intermediate

2051: @*/
2052: PetscErrorCode PetscLogViewFromOptions(void)
2053: {
2054:   PetscErrorCode    ierr;
2055:   PetscViewer       viewer;
2056:   PetscBool         flg;
2057:   PetscViewerFormat format;

2060:   PetscOptionsGetViewer(PETSC_COMM_WORLD,NULL,NULL,"-log_view",&viewer,&format,&flg);
2061:   if (flg) {
2062:     PetscViewerPushFormat(viewer,format);
2063:     PetscLogView(viewer);
2064:     PetscViewerPopFormat(viewer);
2065:     PetscViewerDestroy(&viewer);
2066:   }
2067:   return(0);
2068: }

2070: /*----------------------------------------------- Counter Functions -------------------------------------------------*/
2071: /*@C
2072:    PetscGetFlops - Returns the number of flops used on this processor
2073:    since the program began.

2075:    Not Collective

2077:    Output Parameter:
2078:    flops - number of floating point operations

2080:    Notes:
2081:    A global counter logs all PETSc flop counts.  The user can use
2082:    PetscLogFlops() to increment this counter to include flops for the
2083:    application code.

2085:    Level: intermediate

2087: .seealso: PetscTime(), PetscLogFlops()
2088: @*/
2089: PetscErrorCode  PetscGetFlops(PetscLogDouble *flops)
2090: {
2092:   *flops = petsc_TotalFlops;
2093:   return(0);
2094: }

2096: PetscErrorCode  PetscLogObjectState(PetscObject obj, const char format[], ...)
2097: {
2099:   size_t         fullLength;
2100:   va_list        Argp;

2103:   if (!petsc_logObjects) return(0);
2104:   va_start(Argp, format);
2105:   PetscVSNPrintf(petsc_objects[obj->id].info, 64,format,&fullLength, Argp);
2106:   va_end(Argp);
2107:   return(0);
2108: }

2110: /*MC
2111:    PetscLogFlops - Adds floating point operations to the global counter.

2113:    Synopsis:
2114: #include <petsclog.h>
2115:    PetscErrorCode PetscLogFlops(PetscLogDouble f)

2117:    Not Collective

2119:    Input Parameter:
2120: .  f - flop counter

2122:    Usage:
2123: .vb
2124:      PetscLogEvent USER_EVENT;
2125:      PetscLogEventRegister("User event",0,&USER_EVENT);
2126:      PetscLogEventBegin(USER_EVENT,0,0,0,0);
2127:         [code segment to monitor]
2128:         PetscLogFlops(user_flops)
2129:      PetscLogEventEnd(USER_EVENT,0,0,0,0);
2130: .ve

2132:    Notes:
2133:    A global counter logs all PETSc flop counts.  The user can use
2134:    PetscLogFlops() to increment this counter to include flops for the
2135:    application code.

2137:    Level: intermediate

2139: .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogEventEnd(), PetscGetFlops()

2141: M*/

2143: /*MC
2144:    PetscPreLoadBegin - Begin a segment of code that may be preloaded (run twice)
2145:     to get accurate timings

2147:    Synopsis:
2148: #include <petsclog.h>
2149:    void PetscPreLoadBegin(PetscBool  flag,char *name);

2151:    Not Collective

2153:    Input Parameters:
2154: +   flag - PETSC_TRUE to run twice, PETSC_FALSE to run once, may be overridden
2155:            with command line option -preload true or -preload false
2156: -   name - name of first stage (lines of code timed separately with -log_view) to
2157:            be preloaded

2159:    Usage:
2160: .vb
2161:      PetscPreLoadBegin(PETSC_TRUE,"first stage);
2162:        lines of code
2163:        PetscPreLoadStage("second stage");
2164:        lines of code
2165:      PetscPreLoadEnd();
2166: .ve

2168:    Notes:
2169:     Only works in C/C++, not Fortran

2171:      Flags available within the macro.
2172: +    PetscPreLoadingUsed - true if we are or have done preloading
2173: .    PetscPreLoadingOn - true if it is CURRENTLY doing preload
2174: .    PetscPreLoadIt - 0 for the first computation (with preloading turned off it is only 0) 1 for the second
2175: -    PetscPreLoadMax - number of times it will do the computation, only one when preloading is turned on
2176:      The first two variables are available throughout the program, the second two only between the PetscPreLoadBegin()
2177:      and PetscPreLoadEnd()

2179:    Level: intermediate

2181: .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogEventEnd(), PetscPreLoadEnd(), PetscPreLoadStage()

2183: M*/

2185: /*MC
2186:    PetscPreLoadEnd - End a segment of code that may be preloaded (run twice)
2187:     to get accurate timings

2189:    Synopsis:
2190: #include <petsclog.h>
2191:    void PetscPreLoadEnd(void);

2193:    Not Collective

2195:    Usage:
2196: .vb
2197:      PetscPreLoadBegin(PETSC_TRUE,"first stage);
2198:        lines of code
2199:        PetscPreLoadStage("second stage");
2200:        lines of code
2201:      PetscPreLoadEnd();
2202: .ve

2204:    Notes:
2205:     only works in C/C++ not fortran

2207:    Level: intermediate

2209: .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogEventEnd(), PetscPreLoadBegin(), PetscPreLoadStage()

2211: M*/

2213: /*MC
2214:    PetscPreLoadStage - Start a new segment of code to be timed separately.
2215:     to get accurate timings

2217:    Synopsis:
2218: #include <petsclog.h>
2219:    void PetscPreLoadStage(char *name);

2221:    Not Collective

2223:    Usage:
2224: .vb
2225:      PetscPreLoadBegin(PETSC_TRUE,"first stage);
2226:        lines of code
2227:        PetscPreLoadStage("second stage");
2228:        lines of code
2229:      PetscPreLoadEnd();
2230: .ve

2232:    Notes:
2233:     only works in C/C++ not fortran

2235:    Level: intermediate

2237: .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogEventEnd(), PetscPreLoadBegin(), PetscPreLoadEnd()

2239: M*/

2241: #if defined(PETSC_HAVE_DEVICE)

2243: #if defined(PETSC_HAVE_CUDA)
2244: #include <petscdevice.h>
2245: PETSC_EXTERN cudaEvent_t petsc_gputimer_begin;
2246: PETSC_EXTERN cudaEvent_t petsc_gputimer_end;
2247: #endif

2249: #if defined(PETSC_HAVE_HIP)
2250: #include <petscdevice.h>
2251: PETSC_EXTERN hipEvent_t petsc_gputimer_begin;
2252: PETSC_EXTERN hipEvent_t petsc_gputimer_end;
2253: #endif

2255: /*-------------------------------------------- GPU event Functions ----------------------------------------------*/
2256: /*@C
2257:   PetscLogGpuTimeBegin - Start timer for device

2259:   Notes:
2260:     When CUDA or HIP is enabled, the timer is run on the GPU, it is a separate logging of time devoted to GPU computations (excluding kernel launch times).
2261:     When CUDA or HIP is not available, the timer is run on the CPU, it is a separate logging of time devoted to GPU computations (including kernel launch times).
2262:     There is no need to call WaitForCUDA() or WaitForHIP() between PetscLogGpuTimeBegin and PetscLogGpuTimeEnd
2263:     This timer should NOT include times for data transfers between the GPU and CPU, nor setup actions such as allocating space.
2264:     The regular logging captures the time for data transfers and any CPU activites during the event
2265:     It is used to compute the flop rate on the GPU as it is actively engaged in running a kernel.

2267:   Developer Notes:
2268:     The GPU event timer captures the execution time of all the kernels launched in the default stream by the CPU between PetscLogGpuTimeBegin() and PetsLogGpuTimeEnd().
2269:     PetscLogGpuTimeBegin() and PetsLogGpuTimeEnd() insert the begin and end events into the default stream (stream 0). The device will record a time stamp for the event when it reaches that event in the stream. The function xxxEventSynchronize() is called in PetsLogGpuTimeEnd() to block CPU execution, but not continued GPU excution, until the timer event is recorded.

2271:   Level: intermediate

2273: .seealso:  PetscLogView(), PetscLogGpuFlops(), PetscLogGpuTimeEnd()
2274: @*/
2275: PetscErrorCode PetscLogGpuTimeBegin(void)
2276: {
2277: #if defined(PETSC_HAVE_CUDA)
2278:   cudaError_t    cerr;
2279: #elif defined(PETSC_HAVE_HIP)
2280:   hipError_t     cerr;
2281: #else
2283: #endif
2285: #if defined(PETSC_USE_DEBUG)
2286:   if (petsc_gtime_inuse) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Forgot to call PetscLogGpuTimeEnd()?");
2287:   petsc_gtime_inuse = PETSC_TRUE;
2288: #endif
2289:   if (!PetscLogPLB) return(0);
2290: #if defined(PETSC_HAVE_CUDA)
2291:   cerr = cudaEventRecord(petsc_gputimer_begin,PetscDefaultCudaStream);CHKERRCUDA(cerr);
2292: #elif defined(PETSC_HAVE_HIP)
2293:   cerr = hipEventRecord(petsc_gputimer_begin,PetscDefaultHipStream);CHKERRHIP(cerr);
2294: #else
2295:   PetscTimeSubtract(&petsc_gtime);
2296: #endif
2297:   return(0);
2298: }

2300: /*@C
2301:   PetscLogGpuTimeEnd - Stop timer for device

2303:   Level: intermediate

2305: .seealso:  PetscLogView(), PetscLogGpuFlops(), PetscLogGpuTimeBegin()
2306: @*/
2307: PetscErrorCode PetscLogGpuTimeEnd(void)
2308: {
2309: #if defined(PETSC_HAVE_CUDA)
2310:   float          gtime;
2311:   cudaError_t    cerr;
2312: #elif defined(PETSC_HAVE_HIP)
2313:   float          gtime;
2314:   hipError_t     cerr;
2315: #else
2317: #endif
2319: #if defined(PETSC_USE_DEBUG)
2320:   if (!petsc_gtime_inuse) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Forgot to call PetscLogGpuTimeBegin()?");
2321:   petsc_gtime_inuse = PETSC_FALSE;
2322: #endif
2323:   if (!PetscLogPLE) return(0);
2324: #if defined(PETSC_HAVE_CUDA)
2325:   cerr = cudaEventRecord(petsc_gputimer_end,PetscDefaultCudaStream);CHKERRCUDA(cerr);
2326:   cerr = cudaEventSynchronize(petsc_gputimer_end);CHKERRCUDA(cerr);
2327:   cerr = cudaEventElapsedTime(&gtime,petsc_gputimer_begin,petsc_gputimer_end);CHKERRCUDA(cerr);
2328:   petsc_gtime += (PetscLogDouble)gtime/1000.0; /* convert milliseconds to seconds */
2329: #elif defined(PETSC_HAVE_HIP)
2330:   cerr = hipEventRecord(petsc_gputimer_end,PetscDefaultHipStream);CHKERRHIP(cerr);
2331:   cerr = hipEventSynchronize(petsc_gputimer_end);CHKERRHIP(cerr);
2332:   cerr = hipEventElapsedTime(&gtime,petsc_gputimer_begin,petsc_gputimer_end);CHKERRHIP(cerr);
2333:   petsc_gtime += (PetscLogDouble)gtime/1000.0; /* convert milliseconds to seconds */
2334: #else
2335:   PetscTimeAdd(&petsc_gtime);
2336: #endif
2337:   return(0);
2338: }
2339: #endif /* end of PETSC_HAVE_DEVICE */

2341: #else /* end of -DPETSC_USE_LOG section */

2343: PetscErrorCode  PetscLogObjectState(PetscObject obj, const char format[], ...)
2344: {
2346:   return(0);
2347: }

2349: #endif /* PETSC_USE_LOG*/

2351: PetscClassId PETSC_LARGEST_CLASSID = PETSC_SMALLEST_CLASSID;
2352: PetscClassId PETSC_OBJECT_CLASSID  = 0;

2354: /*@C
2355:   PetscClassIdRegister - Registers a new class name for objects and logging operations in an application code.

2357:   Not Collective

2359:   Input Parameter:
2360: . name   - The class name

2362:   Output Parameter:
2363: . oclass - The class id or classid

2365:   Level: developer

2367: @*/
2368: PetscErrorCode  PetscClassIdRegister(const char name[],PetscClassId *oclass)
2369: {
2370: #if defined(PETSC_USE_LOG)
2371:   PetscStageLog  stageLog;
2372:   PetscInt       stage;
2374: #endif

2377:   *oclass = ++PETSC_LARGEST_CLASSID;
2378: #if defined(PETSC_USE_LOG)
2379:   PetscLogGetStageLog(&stageLog);
2380:   PetscClassRegLogRegister(stageLog->classLog, name, *oclass);
2381:   for (stage = 0; stage < stageLog->numStages; stage++) {
2382:     PetscClassPerfLogEnsureSize(stageLog->stageInfo[stage].classLog, stageLog->classLog->numClasses);
2383:   }
2384: #endif
2385:   return(0);
2386: }

2388: #if defined(PETSC_USE_LOG) && defined(PETSC_HAVE_MPE)
2389: #include <mpe.h>

2391: PetscBool PetscBeganMPE = PETSC_FALSE;

2393: PETSC_INTERN PetscErrorCode PetscLogEventBeginMPE(PetscLogEvent,int,PetscObject,PetscObject,PetscObject,PetscObject);
2394: PETSC_INTERN PetscErrorCode PetscLogEventEndMPE(PetscLogEvent,int,PetscObject,PetscObject,PetscObject,PetscObject);

2396: /*@C
2397:    PetscLogMPEBegin - Turns on MPE logging of events. This creates large log files
2398:    and slows the program down.

2400:    Collective over PETSC_COMM_WORLD

2402:    Options Database Keys:
2403: . -log_mpe - Prints extensive log information

2405:    Notes:
2406:    A related routine is PetscLogDefaultBegin() (with the options key -log_view), which is
2407:    intended for production runs since it logs only flop rates and object
2408:    creation (and should not significantly slow the programs).

2410:    Level: advanced

2412: .seealso: PetscLogDump(), PetscLogDefaultBegin(), PetscLogAllBegin(), PetscLogEventActivate(),
2413:           PetscLogEventDeactivate()
2414: @*/
2415: PetscErrorCode  PetscLogMPEBegin(void)
2416: {

2420:   /* Do MPE initialization */
2421:   if (!MPE_Initialized_logging()) { /* This function exists in mpich 1.1.2 and higher */
2422:     PetscInfo(0,"Initializing MPE.\n");
2423:     MPE_Init_log();

2425:     PetscBeganMPE = PETSC_TRUE;
2426:   } else {
2427:     PetscInfo(0,"MPE already initialized. Not attempting to reinitialize.\n");
2428:   }
2429:   PetscLogSet(PetscLogEventBeginMPE, PetscLogEventEndMPE);
2430:   return(0);
2431: }

2433: /*@C
2434:    PetscLogMPEDump - Dumps the MPE logging info to file for later use with Jumpshot.

2436:    Collective over PETSC_COMM_WORLD

2438:    Level: advanced

2440: .seealso: PetscLogDump(), PetscLogAllBegin(), PetscLogMPEBegin()
2441: @*/
2442: PetscErrorCode  PetscLogMPEDump(const char sname[])
2443: {
2444:   char           name[PETSC_MAX_PATH_LEN];

2448:   if (PetscBeganMPE) {
2449:     PetscInfo(0,"Finalizing MPE.\n");
2450:     if (sname) {
2451:       PetscStrcpy(name,sname);
2452:     } else {
2453:       PetscGetProgramName(name,sizeof(name));
2454:     }
2455:     MPE_Finish_log(name);
2456:   } else {
2457:     PetscInfo(0,"Not finalizing MPE (not started by PETSc).\n");
2458:   }
2459:   return(0);
2460: }

2462: #define PETSC_RGB_COLORS_MAX 39
2463: static const char *PetscLogMPERGBColors[PETSC_RGB_COLORS_MAX] = {
2464:   "OliveDrab:      ",
2465:   "BlueViolet:     ",
2466:   "CadetBlue:      ",
2467:   "CornflowerBlue: ",
2468:   "DarkGoldenrod:  ",
2469:   "DarkGreen:      ",
2470:   "DarkKhaki:      ",
2471:   "DarkOliveGreen: ",
2472:   "DarkOrange:     ",
2473:   "DarkOrchid:     ",
2474:   "DarkSeaGreen:   ",
2475:   "DarkSlateGray:  ",
2476:   "DarkTurquoise:  ",
2477:   "DeepPink:       ",
2478:   "DarkKhaki:      ",
2479:   "DimGray:        ",
2480:   "DodgerBlue:     ",
2481:   "GreenYellow:    ",
2482:   "HotPink:        ",
2483:   "IndianRed:      ",
2484:   "LavenderBlush:  ",
2485:   "LawnGreen:      ",
2486:   "LemonChiffon:   ",
2487:   "LightCoral:     ",
2488:   "LightCyan:      ",
2489:   "LightPink:      ",
2490:   "LightSalmon:    ",
2491:   "LightSlateGray: ",
2492:   "LightYellow:    ",
2493:   "LimeGreen:      ",
2494:   "MediumPurple:   ",
2495:   "MediumSeaGreen: ",
2496:   "MediumSlateBlue:",
2497:   "MidnightBlue:   ",
2498:   "MintCream:      ",
2499:   "MistyRose:      ",
2500:   "NavajoWhite:    ",
2501:   "NavyBlue:       ",
2502:   "OliveDrab:      "
2503: };

2505: /*@C
2506:   PetscLogMPEGetRGBColor - This routine returns a rgb color useable with PetscLogEventRegister()

2508:   Not collective. Maybe it should be?

2510:   Output Parameter:
2511: . str - character string representing the color

2513:   Level: developer

2515: .seealso: PetscLogEventRegister
2516: @*/
2517: PetscErrorCode  PetscLogMPEGetRGBColor(const char *str[])
2518: {
2519:   static int idx = 0;

2522:   *str = PetscLogMPERGBColors[idx];
2523:   idx  = (idx + 1)% PETSC_RGB_COLORS_MAX;
2524:   return(0);
2525: }

2527: #endif /* PETSC_USE_LOG && PETSC_HAVE_MPE */