1 2 /* 3 PETSc code to log object creation and destruction and PETSc events. 4 5 This provides the public API used by the rest of PETSc and by users. 6 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. 9 10 */ 11 #include <petsc/private/logimpl.h> /*I "petscsys.h" I*/ 12 #include <petsctime.h> 13 #include <petscviewer.h> 14 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 } 22 23 /*@C 24 PetscLogObjectMemory - Adds to an object a count of additional amount of memory that is used by the object. 25 26 Not collective. 27 28 Input Parameters: 29 + obj - the PETSc object 30 - mem - the amount of memory that is being added to the object 31 32 Level: developer 33 34 Developer Notes: Currently we do not always do a good job of associating all memory allocations with an object. 35 36 .seealso: PetscFinalize(), PetscInitializeFortran(), PetscGetArgs(), PetscInitializeNoArguments() 37 38 @*/ 39 PetscErrorCode PetscLogObjectMemory(PetscObject p,PetscLogDouble m) 40 { 41 if (!p) return 0; 42 p->mem += m; 43 return 0; 44 } 45 46 PetscLogEvent PETSC_LARGEST_EVENT = PETSC_EVENT; 47 48 #if defined(PETSC_USE_LOG) 49 #include <petscmachineinfo.h> 50 #include <petscconfiginfo.h> 51 52 /* used in the MPI_XXX() count macros in petsclog.h */ 53 54 /* Action and object logging variables */ 55 Action *petsc_actions = NULL; 56 Object *petsc_objects = NULL; 57 PetscBool petsc_logActions = PETSC_FALSE; 58 PetscBool petsc_logObjects = PETSC_FALSE; 59 int petsc_numActions = 0, petsc_maxActions = 100; 60 int petsc_numObjects = 0, petsc_maxObjects = 100; 61 int petsc_numObjectsDestroyed = 0; 62 63 /* Global counters */ 64 PetscLogDouble petsc_BaseTime = 0.0; 65 PetscLogDouble petsc_TotalFlops = 0.0; /* The number of flops */ 66 PetscLogDouble petsc_tmp_flops = 0.0; /* The incremental number of flops */ 67 PetscLogDouble petsc_send_ct = 0.0; /* The number of sends */ 68 PetscLogDouble petsc_recv_ct = 0.0; /* The number of receives */ 69 PetscLogDouble petsc_send_len = 0.0; /* The total length of all sent messages */ 70 PetscLogDouble petsc_recv_len = 0.0; /* The total length of all received messages */ 71 PetscLogDouble petsc_isend_ct = 0.0; /* The number of immediate sends */ 72 PetscLogDouble petsc_irecv_ct = 0.0; /* The number of immediate receives */ 73 PetscLogDouble petsc_isend_len = 0.0; /* The total length of all immediate send messages */ 74 PetscLogDouble petsc_irecv_len = 0.0; /* The total length of all immediate receive messages */ 75 PetscLogDouble petsc_wait_ct = 0.0; /* The number of waits */ 76 PetscLogDouble petsc_wait_any_ct = 0.0; /* The number of anywaits */ 77 PetscLogDouble petsc_wait_all_ct = 0.0; /* The number of waitalls */ 78 PetscLogDouble petsc_sum_of_waits_ct = 0.0; /* The total number of waits */ 79 PetscLogDouble petsc_allreduce_ct = 0.0; /* The number of reductions */ 80 PetscLogDouble petsc_gather_ct = 0.0; /* The number of gathers and gathervs */ 81 PetscLogDouble petsc_scatter_ct = 0.0; /* The number of scatters and scattervs */ 82 83 /* Logging functions */ 84 PetscErrorCode (*PetscLogPHC)(PetscObject) = NULL; 85 PetscErrorCode (*PetscLogPHD)(PetscObject) = NULL; 86 PetscErrorCode (*PetscLogPLB)(PetscLogEvent, int, PetscObject, PetscObject, PetscObject, PetscObject) = NULL; 87 PetscErrorCode (*PetscLogPLE)(PetscLogEvent, int, PetscObject, PetscObject, PetscObject, PetscObject) = NULL; 88 89 /* Tracing event logging variables */ 90 FILE *petsc_tracefile = NULL; 91 int petsc_tracelevel = 0; 92 const char *petsc_traceblanks = " "; 93 char petsc_tracespace[128] = " "; 94 PetscLogDouble petsc_tracetime = 0.0; 95 static PetscBool PetscLogInitializeCalled = PETSC_FALSE; 96 97 /*---------------------------------------------- General Functions --------------------------------------------------*/ 98 /*@C 99 PetscLogDestroy - Destroys the object and event logging data and resets the global counters. 100 101 Not Collective 102 103 Notes: 104 This routine should not usually be used by programmers. Instead employ 105 PetscLogStagePush() and PetscLogStagePop(). 106 107 Level: developer 108 109 .keywords: log, destroy 110 .seealso: PetscLogDump(), PetscLogAllBegin(), PetscLogView(), PetscLogStagePush(), PlogStagePop() 111 @*/ 112 PetscErrorCode PetscLogDestroy(void) 113 { 114 PetscStageLog stageLog; 115 PetscErrorCode ierr; 116 117 PetscFunctionBegin; 118 ierr = PetscFree(petsc_actions);CHKERRQ(ierr); 119 ierr = PetscFree(petsc_objects);CHKERRQ(ierr); 120 ierr = PetscLogSet(NULL, NULL);CHKERRQ(ierr); 121 122 /* Resetting phase */ 123 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 124 ierr = PetscStageLogDestroy(stageLog);CHKERRQ(ierr); 125 126 petsc_TotalFlops = 0.0; 127 petsc_numActions = 0; 128 petsc_numObjects = 0; 129 petsc_numObjectsDestroyed = 0; 130 petsc_maxActions = 100; 131 petsc_maxObjects = 100; 132 petsc_actions = NULL; 133 petsc_objects = NULL; 134 petsc_logActions = PETSC_FALSE; 135 petsc_logObjects = PETSC_FALSE; 136 petsc_BaseTime = 0.0; 137 petsc_TotalFlops = 0.0; 138 petsc_tmp_flops = 0.0; 139 petsc_send_ct = 0.0; 140 petsc_recv_ct = 0.0; 141 petsc_send_len = 0.0; 142 petsc_recv_len = 0.0; 143 petsc_isend_ct = 0.0; 144 petsc_irecv_ct = 0.0; 145 petsc_isend_len = 0.0; 146 petsc_irecv_len = 0.0; 147 petsc_wait_ct = 0.0; 148 petsc_wait_any_ct = 0.0; 149 petsc_wait_all_ct = 0.0; 150 petsc_sum_of_waits_ct = 0.0; 151 petsc_allreduce_ct = 0.0; 152 petsc_gather_ct = 0.0; 153 petsc_scatter_ct = 0.0; 154 PETSC_LARGEST_EVENT = PETSC_EVENT; 155 PetscLogPHC = NULL; 156 PetscLogPHD = NULL; 157 petsc_tracefile = NULL; 158 petsc_tracelevel = 0; 159 petsc_traceblanks = " "; 160 petsc_tracespace[0] = ' '; petsc_tracespace[1] = 0; 161 petsc_tracetime = 0.0; 162 PETSC_LARGEST_CLASSID = PETSC_SMALLEST_CLASSID; 163 PETSC_OBJECT_CLASSID = 0; 164 petsc_stageLog = 0; 165 PetscLogInitializeCalled = PETSC_FALSE; 166 PetscFunctionReturn(0); 167 } 168 169 /*@C 170 PetscLogSet - Sets the logging functions called at the beginning and ending of every event. 171 172 Not Collective 173 174 Input Parameters: 175 + b - The function called at beginning of event 176 - e - The function called at end of event 177 178 Level: developer 179 180 .seealso: PetscLogDump(), PetscLogDefaultBegin(), PetscLogAllBegin(), PetscLogTraceBegin() 181 @*/ 182 PetscErrorCode PetscLogSet(PetscErrorCode (*b)(PetscLogEvent, int, PetscObject, PetscObject, PetscObject, PetscObject), 183 PetscErrorCode (*e)(PetscLogEvent, int, PetscObject, PetscObject, PetscObject, PetscObject)) 184 { 185 PetscFunctionBegin; 186 PetscLogPLB = b; 187 PetscLogPLE = e; 188 PetscFunctionReturn(0); 189 } 190 191 /*------------------------------------------- Initialization Functions ----------------------------------------------*/ 192 /* 193 The data structures for logging are always created even if no logging is turned on. This is so events etc can 194 be registered in the code before the actually logging is turned on. 195 */ 196 PetscErrorCode PetscLogInitialize(void) 197 { 198 int stage; 199 PetscBool opt; 200 PetscErrorCode ierr; 201 202 PetscFunctionBegin; 203 if (PetscLogInitializeCalled) PetscFunctionReturn(0); 204 PetscLogInitializeCalled = PETSC_TRUE; 205 206 ierr = PetscOptionsHasName(NULL,NULL, "-log_exclude_actions", &opt);CHKERRQ(ierr); 207 if (opt) petsc_logActions = PETSC_FALSE; 208 ierr = PetscOptionsHasName(NULL,NULL, "-log_exclude_objects", &opt);CHKERRQ(ierr); 209 if (opt) petsc_logObjects = PETSC_FALSE; 210 if (petsc_logActions) { 211 ierr = PetscMalloc1(petsc_maxActions, &petsc_actions);CHKERRQ(ierr); 212 } 213 if (petsc_logObjects) { 214 ierr = PetscMalloc1(petsc_maxObjects, &petsc_objects);CHKERRQ(ierr); 215 } 216 PetscLogPHC = PetscLogObjCreateDefault; 217 PetscLogPHD = PetscLogObjDestroyDefault; 218 /* Setup default logging structures */ 219 ierr = PetscStageLogCreate(&petsc_stageLog);CHKERRQ(ierr); 220 ierr = PetscStageLogRegister(petsc_stageLog, "Main Stage", &stage);CHKERRQ(ierr); 221 222 /* All processors sync here for more consistent logging */ 223 ierr = MPI_Barrier(PETSC_COMM_WORLD);CHKERRQ(ierr); 224 PetscTime(&petsc_BaseTime); 225 ierr = PetscLogStagePush(stage);CHKERRQ(ierr); 226 PetscFunctionReturn(0); 227 } 228 229 /*@C 230 PetscLogDefaultBegin - Turns on logging of objects and events. This logs flop 231 rates and object creation and should not slow programs down too much. 232 This routine may be called more than once. 233 234 Logically Collective over PETSC_COMM_WORLD 235 236 Options Database Keys: 237 . -log_view [viewertype:filename:viewerformat] - Prints summary of flop and timing information to the 238 screen (for code configured with --with-log=1 (which is the default)) 239 240 Usage: 241 .vb 242 PetscInitialize(...); 243 PetscLogDefaultBegin(); 244 ... code ... 245 PetscLogView(viewer); or PetscLogDump(); 246 PetscFinalize(); 247 .ve 248 249 Notes: 250 PetscLogView(viewer) or PetscLogDump() actually cause the printing of 251 the logging information. 252 253 Level: advanced 254 255 .keywords: log, begin 256 .seealso: PetscLogDump(), PetscLogAllBegin(), PetscLogView(), PetscLogTraceBegin() 257 @*/ 258 PetscErrorCode PetscLogDefaultBegin(void) 259 { 260 PetscErrorCode ierr; 261 262 PetscFunctionBegin; 263 ierr = PetscLogSet(PetscLogEventBeginDefault, PetscLogEventEndDefault);CHKERRQ(ierr); 264 PetscFunctionReturn(0); 265 } 266 267 /*@C 268 PetscLogAllBegin - Turns on extensive logging of objects and events. Logs 269 all events. This creates large log files and slows the program down. 270 271 Logically Collective on PETSC_COMM_WORLD 272 273 Options Database Keys: 274 . -log_all - Prints extensive log information 275 276 Usage: 277 .vb 278 PetscInitialize(...); 279 PetscLogAllBegin(); 280 ... code ... 281 PetscLogDump(filename); 282 PetscFinalize(); 283 .ve 284 285 Notes: 286 A related routine is PetscLogDefaultBegin() (with the options key -log), which is 287 intended for production runs since it logs only flop rates and object 288 creation (and shouldn't significantly slow the programs). 289 290 Level: advanced 291 292 .keywords: log, all, begin 293 .seealso: PetscLogDump(), PetscLogDefaultBegin(), PetscLogTraceBegin() 294 @*/ 295 PetscErrorCode PetscLogAllBegin(void) 296 { 297 PetscErrorCode ierr; 298 299 PetscFunctionBegin; 300 ierr = PetscLogSet(PetscLogEventBeginComplete, PetscLogEventEndComplete);CHKERRQ(ierr); 301 PetscFunctionReturn(0); 302 } 303 304 /*@ 305 PetscLogTraceBegin - Activates trace logging. Every time a PETSc event 306 begins or ends, the event name is printed. 307 308 Logically Collective on PETSC_COMM_WORLD 309 310 Input Parameter: 311 . file - The file to print trace in (e.g. stdout) 312 313 Options Database Key: 314 . -log_trace [filename] - Activates PetscLogTraceBegin() 315 316 Notes: 317 PetscLogTraceBegin() prints the processor number, the execution time (sec), 318 then "Event begin:" or "Event end:" followed by the event name. 319 320 PetscLogTraceBegin() allows tracing of all PETSc calls, which is useful 321 to determine where a program is hanging without running in the 322 debugger. Can be used in conjunction with the -info option. 323 324 Level: intermediate 325 326 .seealso: PetscLogDump(), PetscLogAllBegin(), PetscLogView(), PetscLogDefaultBegin() 327 @*/ 328 PetscErrorCode PetscLogTraceBegin(FILE *file) 329 { 330 PetscErrorCode ierr; 331 332 PetscFunctionBegin; 333 petsc_tracefile = file; 334 335 ierr = PetscLogSet(PetscLogEventBeginTrace, PetscLogEventEndTrace);CHKERRQ(ierr); 336 PetscFunctionReturn(0); 337 } 338 339 /*@ 340 PetscLogActions - Determines whether actions are logged for the graphical viewer. 341 342 Not Collective 343 344 Input Parameter: 345 . flag - PETSC_TRUE if actions are to be logged 346 347 Level: intermediate 348 349 Note: Logging of actions continues to consume more memory as the program 350 runs. Long running programs should consider turning this feature off. 351 352 Options Database Keys: 353 . -log_exclude_actions - Turns off actions logging 354 355 .keywords: log, stage, register 356 .seealso: PetscLogStagePush(), PetscLogStagePop() 357 @*/ 358 PetscErrorCode PetscLogActions(PetscBool flag) 359 { 360 PetscFunctionBegin; 361 petsc_logActions = flag; 362 PetscFunctionReturn(0); 363 } 364 365 /*@ 366 PetscLogObjects - Determines whether objects are logged for the graphical viewer. 367 368 Not Collective 369 370 Input Parameter: 371 . flag - PETSC_TRUE if objects are to be logged 372 373 Level: intermediate 374 375 Note: Logging of objects continues to consume more memory as the program 376 runs. Long running programs should consider turning this feature off. 377 378 Options Database Keys: 379 . -log_exclude_objects - Turns off objects logging 380 381 .keywords: log, stage, register 382 .seealso: PetscLogStagePush(), PetscLogStagePop() 383 @*/ 384 PetscErrorCode PetscLogObjects(PetscBool flag) 385 { 386 PetscFunctionBegin; 387 petsc_logObjects = flag; 388 PetscFunctionReturn(0); 389 } 390 391 /*------------------------------------------------ Stage Functions --------------------------------------------------*/ 392 /*@C 393 PetscLogStageRegister - Attaches a charactor string name to a logging stage. 394 395 Not Collective 396 397 Input Parameter: 398 . sname - The name to associate with that stage 399 400 Output Parameter: 401 . stage - The stage number 402 403 Level: intermediate 404 405 .keywords: log, stage, register 406 .seealso: PetscLogStagePush(), PetscLogStagePop() 407 @*/ 408 PetscErrorCode PetscLogStageRegister(const char sname[],PetscLogStage *stage) 409 { 410 PetscStageLog stageLog; 411 PetscLogEvent event; 412 PetscErrorCode ierr; 413 414 PetscFunctionBegin; 415 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 416 ierr = PetscStageLogRegister(stageLog, sname, stage);CHKERRQ(ierr); 417 /* Copy events already changed in the main stage, this sucks */ 418 ierr = PetscEventPerfLogEnsureSize(stageLog->stageInfo[*stage].eventLog, stageLog->eventLog->numEvents);CHKERRQ(ierr); 419 for (event = 0; event < stageLog->eventLog->numEvents; event++) { 420 ierr = PetscEventPerfInfoCopy(&stageLog->stageInfo[0].eventLog->eventInfo[event],&stageLog->stageInfo[*stage].eventLog->eventInfo[event]);CHKERRQ(ierr); 421 } 422 ierr = PetscClassPerfLogEnsureSize(stageLog->stageInfo[*stage].classLog, stageLog->classLog->numClasses);CHKERRQ(ierr); 423 PetscFunctionReturn(0); 424 } 425 426 /*@C 427 PetscLogStagePush - This function pushes a stage on the stack. 428 429 Not Collective 430 431 Input Parameter: 432 . stage - The stage on which to log 433 434 Usage: 435 If the option -log_sumary is used to run the program containing the 436 following code, then 2 sets of summary data will be printed during 437 PetscFinalize(). 438 .vb 439 PetscInitialize(int *argc,char ***args,0,0); 440 [stage 0 of code] 441 PetscLogStagePush(1); 442 [stage 1 of code] 443 PetscLogStagePop(); 444 PetscBarrier(...); 445 [more stage 0 of code] 446 PetscFinalize(); 447 .ve 448 449 Notes: 450 Use PetscLogStageRegister() to register a stage. 451 452 Level: intermediate 453 454 .keywords: log, push, stage 455 .seealso: PetscLogStagePop(), PetscLogStageRegister(), PetscBarrier() 456 @*/ 457 PetscErrorCode PetscLogStagePush(PetscLogStage stage) 458 { 459 PetscStageLog stageLog; 460 PetscErrorCode ierr; 461 462 PetscFunctionBegin; 463 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 464 ierr = PetscStageLogPush(stageLog, stage);CHKERRQ(ierr); 465 PetscFunctionReturn(0); 466 } 467 468 /*@C 469 PetscLogStagePop - This function pops a stage from the stack. 470 471 Not Collective 472 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 487 488 Notes: 489 Use PetscLogStageRegister() to register a stage. 490 491 Level: intermediate 492 493 .keywords: log, pop, stage 494 .seealso: PetscLogStagePush(), PetscLogStageRegister(), PetscBarrier() 495 @*/ 496 PetscErrorCode PetscLogStagePop(void) 497 { 498 PetscStageLog stageLog; 499 PetscErrorCode ierr; 500 501 PetscFunctionBegin; 502 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 503 ierr = PetscStageLogPop(stageLog);CHKERRQ(ierr); 504 PetscFunctionReturn(0); 505 } 506 507 /*@ 508 PetscLogStageSetActive - Determines stage activity for PetscLogEventBegin() and PetscLogEventEnd(). 509 510 Not Collective 511 512 Input Parameters: 513 + stage - The stage 514 - isActive - The activity flag, PETSC_TRUE for logging, else PETSC_FALSE (defaults to PETSC_TRUE) 515 516 Level: intermediate 517 518 .seealso: PetscLogStagePush(), PetscLogStagePop(), PetscLogEventBegin(), PetscLogEventEnd(), PetscPreLoadBegin(), PetscPreLoadEnd(), PetscPreLoadStage() 519 @*/ 520 PetscErrorCode PetscLogStageSetActive(PetscLogStage stage, PetscBool isActive) 521 { 522 PetscStageLog stageLog; 523 PetscErrorCode ierr; 524 525 PetscFunctionBegin; 526 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 527 ierr = PetscStageLogSetActive(stageLog, stage, isActive);CHKERRQ(ierr); 528 PetscFunctionReturn(0); 529 } 530 531 /*@ 532 PetscLogStageGetActive - Returns stage activity for PetscLogEventBegin() and PetscLogEventEnd(). 533 534 Not Collective 535 536 Input Parameter: 537 . stage - The stage 538 539 Output Parameter: 540 . isActive - The activity flag, PETSC_TRUE for logging, else PETSC_FALSE (defaults to PETSC_TRUE) 541 542 Level: intermediate 543 544 .seealso: PetscLogStagePush(), PetscLogStagePop(), PetscLogEventBegin(), PetscLogEventEnd(), PetscPreLoadBegin(), PetscPreLoadEnd(), PetscPreLoadStage() 545 @*/ 546 PetscErrorCode PetscLogStageGetActive(PetscLogStage stage, PetscBool *isActive) 547 { 548 PetscStageLog stageLog; 549 PetscErrorCode ierr; 550 551 PetscFunctionBegin; 552 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 553 ierr = PetscStageLogGetActive(stageLog, stage, isActive);CHKERRQ(ierr); 554 PetscFunctionReturn(0); 555 } 556 557 /*@ 558 PetscLogStageSetVisible - Determines stage visibility in PetscLogView() 559 560 Not Collective 561 562 Input Parameters: 563 + stage - The stage 564 - isVisible - The visibility flag, PETSC_TRUE to print, else PETSC_FALSE (defaults to PETSC_TRUE) 565 566 Level: intermediate 567 568 .seealso: PetscLogStagePush(), PetscLogStagePop(), PetscLogView() 569 @*/ 570 PetscErrorCode PetscLogStageSetVisible(PetscLogStage stage, PetscBool isVisible) 571 { 572 PetscStageLog stageLog; 573 PetscErrorCode ierr; 574 575 PetscFunctionBegin; 576 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 577 ierr = PetscStageLogSetVisible(stageLog, stage, isVisible);CHKERRQ(ierr); 578 PetscFunctionReturn(0); 579 } 580 581 /*@ 582 PetscLogStageGetVisible - Returns stage visibility in PetscLogView() 583 584 Not Collective 585 586 Input Parameter: 587 . stage - The stage 588 589 Output Parameter: 590 . isVisible - The visibility flag, PETSC_TRUE to print, else PETSC_FALSE (defaults to PETSC_TRUE) 591 592 Level: intermediate 593 594 .seealso: PetscLogStagePush(), PetscLogStagePop(), PetscLogView() 595 @*/ 596 PetscErrorCode PetscLogStageGetVisible(PetscLogStage stage, PetscBool *isVisible) 597 { 598 PetscStageLog stageLog; 599 PetscErrorCode ierr; 600 601 PetscFunctionBegin; 602 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 603 ierr = PetscStageLogGetVisible(stageLog, stage, isVisible);CHKERRQ(ierr); 604 PetscFunctionReturn(0); 605 } 606 607 /*@C 608 PetscLogStageGetId - Returns the stage id when given the stage name. 609 610 Not Collective 611 612 Input Parameter: 613 . name - The stage name 614 615 Output Parameter: 616 . stage - The stage, , or -1 if no stage with that name exists 617 618 Level: intermediate 619 620 .seealso: PetscLogStagePush(), PetscLogStagePop(), PetscPreLoadBegin(), PetscPreLoadEnd(), PetscPreLoadStage() 621 @*/ 622 PetscErrorCode PetscLogStageGetId(const char name[], PetscLogStage *stage) 623 { 624 PetscStageLog stageLog; 625 PetscErrorCode ierr; 626 627 PetscFunctionBegin; 628 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 629 ierr = PetscStageLogGetStage(stageLog, name, stage);CHKERRQ(ierr); 630 PetscFunctionReturn(0); 631 } 632 633 /*------------------------------------------------ Event Functions --------------------------------------------------*/ 634 /*@C 635 PetscLogEventRegister - Registers an event name for logging operations in an application code. 636 637 Not Collective 638 639 Input Parameter: 640 + name - The name associated with the event 641 - classid - The classid associated to the class for this event, obtain either with 642 PetscClassIdRegister() or use a predefined one such as KSP_CLASSID, SNES_CLASSID, the predefined ones 643 are only available in C code 644 645 Output Parameter: 646 . event - The event id for use with PetscLogEventBegin() and PetscLogEventEnd(). 647 648 Example of Usage: 649 .vb 650 PetscLogEvent USER_EVENT; 651 PetscClassId classid; 652 PetscLogDouble user_event_flops; 653 PetscClassIdRegister("class name",&classid); 654 PetscLogEventRegister("User event name",classid,&USER_EVENT); 655 PetscLogEventBegin(USER_EVENT,0,0,0,0); 656 [code segment to monitor] 657 PetscLogFlops(user_event_flops); 658 PetscLogEventEnd(USER_EVENT,0,0,0,0); 659 .ve 660 661 Notes: 662 PETSc automatically logs library events if the code has been 663 configured with --with-log (which is the default) and 664 -log_view or -log_all is specified. PetscLogEventRegister() is 665 intended for logging user events to supplement this PETSc 666 information. 667 668 PETSc can gather data for use with the utilities Jumpshot 669 (part of the MPICH distribution). If PETSc has been compiled 670 with flag -DPETSC_HAVE_MPE (MPE is an additional utility within 671 MPICH), the user can employ another command line option, -log_mpe, 672 to create a logfile, "mpe.log", which can be visualized 673 Jumpshot. 674 675 The classid is associated with each event so that classes of events 676 can be disabled simultaneously, such as all matrix events. The user 677 can either use an existing classid, such as MAT_CLASSID, or create 678 their own as shown in the example. 679 680 If an existing event with the same name exists, its event handle is 681 returned instead of creating a new event. 682 683 Level: intermediate 684 685 .keywords: log, event, register 686 .seealso: PetscLogEventBegin(), PetscLogEventEnd(), PetscLogFlops(), 687 PetscLogEventActivate(), PetscLogEventDeactivate(), PetscClassIdRegister() 688 @*/ 689 PetscErrorCode PetscLogEventRegister(const char name[],PetscClassId classid,PetscLogEvent *event) 690 { 691 PetscStageLog stageLog; 692 int stage; 693 PetscErrorCode ierr; 694 695 PetscFunctionBegin; 696 *event = PETSC_DECIDE; 697 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 698 ierr = PetscEventRegLogGetEvent(stageLog->eventLog, name, event);CHKERRQ(ierr); 699 if (*event > 0) PetscFunctionReturn(0); 700 ierr = PetscEventRegLogRegister(stageLog->eventLog, name, classid, event);CHKERRQ(ierr); 701 for (stage = 0; stage < stageLog->numStages; stage++) { 702 ierr = PetscEventPerfLogEnsureSize(stageLog->stageInfo[stage].eventLog, stageLog->eventLog->numEvents);CHKERRQ(ierr); 703 ierr = PetscClassPerfLogEnsureSize(stageLog->stageInfo[stage].classLog, stageLog->classLog->numClasses);CHKERRQ(ierr); 704 } 705 PetscFunctionReturn(0); 706 } 707 708 /*@ 709 PetscLogEventActivate - Indicates that a particular event should be logged. 710 711 Not Collective 712 713 Input Parameter: 714 . event - The event id 715 716 Usage: 717 .vb 718 PetscLogEventDeactivate(VEC_SetValues); 719 [code where you do not want to log VecSetValues()] 720 PetscLogEventActivate(VEC_SetValues); 721 [code where you do want to log VecSetValues()] 722 .ve 723 724 Note: 725 The event may be either a pre-defined PETSc event (found in include/petsclog.h) 726 or an event number obtained with PetscLogEventRegister(). 727 728 Level: advanced 729 730 .keywords: log, event, activate 731 .seealso: PlogEventDeactivate() 732 @*/ 733 PetscErrorCode PetscLogEventActivate(PetscLogEvent event) 734 { 735 PetscStageLog stageLog; 736 int stage; 737 PetscErrorCode ierr; 738 739 PetscFunctionBegin; 740 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 741 ierr = PetscStageLogGetCurrent(stageLog, &stage);CHKERRQ(ierr); 742 ierr = PetscEventPerfLogActivate(stageLog->stageInfo[stage].eventLog, event);CHKERRQ(ierr); 743 PetscFunctionReturn(0); 744 } 745 746 /*@ 747 PetscLogEventDeactivate - Indicates that a particular event should not be logged. 748 749 Not Collective 750 751 Input Parameter: 752 . event - The event id 753 754 Usage: 755 .vb 756 PetscLogEventDeactivate(VEC_SetValues); 757 [code where you do not want to log VecSetValues()] 758 PetscLogEventActivate(VEC_SetValues); 759 [code where you do want to log VecSetValues()] 760 .ve 761 762 Note: 763 The event may be either a pre-defined PETSc event (found in 764 include/petsclog.h) or an event number obtained with PetscLogEventRegister()). 765 766 Level: advanced 767 768 .keywords: log, event, deactivate 769 .seealso: PlogEventActivate() 770 @*/ 771 PetscErrorCode PetscLogEventDeactivate(PetscLogEvent event) 772 { 773 PetscStageLog stageLog; 774 int stage; 775 PetscErrorCode ierr; 776 777 PetscFunctionBegin; 778 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 779 ierr = PetscStageLogGetCurrent(stageLog, &stage);CHKERRQ(ierr); 780 ierr = PetscEventPerfLogDeactivate(stageLog->stageInfo[stage].eventLog, event);CHKERRQ(ierr); 781 PetscFunctionReturn(0); 782 } 783 784 /*@ 785 PetscLogEventSetActiveAll - Sets the event activity in every stage. 786 787 Not Collective 788 789 Input Parameters: 790 + event - The event id 791 - isActive - The activity flag determining whether the event is logged 792 793 Level: advanced 794 795 .keywords: log, event, activate 796 .seealso: PlogEventActivate(),PlogEventDeactivate() 797 @*/ 798 PetscErrorCode PetscLogEventSetActiveAll(PetscLogEvent event, PetscBool isActive) 799 { 800 PetscStageLog stageLog; 801 int stage; 802 PetscErrorCode ierr; 803 804 PetscFunctionBegin; 805 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 806 for (stage = 0; stage < stageLog->numStages; stage++) { 807 if (isActive) { 808 ierr = PetscEventPerfLogActivate(stageLog->stageInfo[stage].eventLog, event);CHKERRQ(ierr); 809 } else { 810 ierr = PetscEventPerfLogDeactivate(stageLog->stageInfo[stage].eventLog, event);CHKERRQ(ierr); 811 } 812 } 813 PetscFunctionReturn(0); 814 } 815 816 /*@ 817 PetscLogEventActivateClass - Activates event logging for a PETSc object class. 818 819 Not Collective 820 821 Input Parameter: 822 . classid - The event class, for example MAT_CLASSID, SNES_CLASSID, etc. 823 824 Level: developer 825 826 .keywords: log, event, activate, class 827 .seealso: PetscInfoActivate(),PetscInfo(),PetscInfoAllow(),PetscLogEventDeactivateClass(), PetscLogEventActivate(),PetscLogEventDeactivate() 828 @*/ 829 PetscErrorCode PetscLogEventActivateClass(PetscClassId classid) 830 { 831 PetscStageLog stageLog; 832 int stage; 833 PetscErrorCode ierr; 834 835 PetscFunctionBegin; 836 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 837 ierr = PetscStageLogGetCurrent(stageLog, &stage);CHKERRQ(ierr); 838 ierr = PetscEventPerfLogActivateClass(stageLog->stageInfo[stage].eventLog, stageLog->eventLog, classid);CHKERRQ(ierr); 839 PetscFunctionReturn(0); 840 } 841 842 /*@ 843 PetscLogEventDeactivateClass - Deactivates event logging for a PETSc object class. 844 845 Not Collective 846 847 Input Parameter: 848 . classid - The event class, for example MAT_CLASSID, SNES_CLASSID, etc. 849 850 Level: developer 851 852 .keywords: log, event, deactivate, class 853 .seealso: PetscInfoActivate(),PetscInfo(),PetscInfoAllow(),PetscLogEventActivateClass(), PetscLogEventActivate(),PetscLogEventDeactivate() 854 @*/ 855 PetscErrorCode PetscLogEventDeactivateClass(PetscClassId classid) 856 { 857 PetscStageLog stageLog; 858 int stage; 859 PetscErrorCode ierr; 860 861 PetscFunctionBegin; 862 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 863 ierr = PetscStageLogGetCurrent(stageLog, &stage);CHKERRQ(ierr); 864 ierr = PetscEventPerfLogDeactivateClass(stageLog->stageInfo[stage].eventLog, stageLog->eventLog, classid);CHKERRQ(ierr); 865 PetscFunctionReturn(0); 866 } 867 868 /*MC 869 PetscLogEventBegin - Logs the beginning of a user event. 870 871 Synopsis: 872 #include <petsclog.h> 873 PetscErrorCode PetscLogEventBegin(int e,PetscObject o1,PetscObject o2,PetscObject o3,PetscObject o4) 874 875 Not Collective 876 877 Input Parameters: 878 + e - integer associated with the event obtained from PetscLogEventRegister() 879 - o1,o2,o3,o4 - objects associated with the event, or 0 880 881 882 Fortran Synopsis: 883 void PetscLogEventBegin(int e,PetscErrorCode ierr) 884 885 Usage: 886 .vb 887 PetscLogEvent USER_EVENT; 888 PetscLogDouble user_event_flops; 889 PetscLogEventRegister("User event",0,&USER_EVENT); 890 PetscLogEventBegin(USER_EVENT,0,0,0,0); 891 [code segment to monitor] 892 PetscLogFlops(user_event_flops); 893 PetscLogEventEnd(USER_EVENT,0,0,0,0); 894 .ve 895 896 Notes: 897 You need to register each integer event with the command 898 PetscLogEventRegister(). 899 900 Level: intermediate 901 902 .seealso: PetscLogEventRegister(), PetscLogEventEnd(), PetscLogFlops() 903 904 .keywords: log, event, begin 905 M*/ 906 907 /*MC 908 PetscLogEventEnd - Log the end of a user event. 909 910 Synopsis: 911 #include <petsclog.h> 912 PetscErrorCode PetscLogEventEnd(int e,PetscObject o1,PetscObject o2,PetscObject o3,PetscObject o4) 913 914 Not Collective 915 916 Input Parameters: 917 + e - integer associated with the event obtained with PetscLogEventRegister() 918 - o1,o2,o3,o4 - objects associated with the event, or 0 919 920 921 Fortran Synopsis: 922 void PetscLogEventEnd(int e,PetscErrorCode ierr) 923 924 Usage: 925 .vb 926 PetscLogEvent USER_EVENT; 927 PetscLogDouble user_event_flops; 928 PetscLogEventRegister("User event",0,&USER_EVENT,); 929 PetscLogEventBegin(USER_EVENT,0,0,0,0); 930 [code segment to monitor] 931 PetscLogFlops(user_event_flops); 932 PetscLogEventEnd(USER_EVENT,0,0,0,0); 933 .ve 934 935 Notes: 936 You should also register each additional integer event with the command 937 PetscLogEventRegister(). 938 939 Level: intermediate 940 941 .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogFlops() 942 943 .keywords: log, event, end 944 M*/ 945 946 /*MC 947 PetscLogEventBarrierBegin - Logs the time in a barrier before an event. 948 949 Synopsis: 950 #include <petsclog.h> 951 PetscErrorCode PetscLogEventBarrierBegin(int e,PetscObject o1,PetscObject o2,PetscObject o3,PetscObject o4,MPI_Comm comm) 952 953 Not Collective 954 955 Input Parameters: 956 . e - integer associated with the event obtained from PetscLogEventRegister() 957 . o1,o2,o3,o4 - objects associated with the event, or 0 958 . comm - communicator the barrier takes place over 959 960 961 Usage: 962 .vb 963 PetscLogEventBarrierBegin(VEC_NormBarrier,0,0,0,0,comm); 964 MPIU_Allreduce() 965 PetscLogEventBarrierEnd(VEC_NormBarrier,0,0,0,0,comm); 966 .ve 967 968 Notes: 969 This is for logging the amount of time spent in a barrier for an event 970 that requires synchronization. 971 972 Additional Notes: 973 Synchronization events always come in pairs; for example, VEC_NormBarrier and 974 VEC_NormComm = VEC_NormBarrier + 1 975 976 Level: advanced 977 978 .seealso: PetscLogEventRegister(), PetscLogEventEnd(), PetscLogFlops(), PetscLogEventBegin(), 979 PetscLogEventBarrierEnd() 980 981 .keywords: log, event, begin, barrier 982 M*/ 983 984 /*MC 985 PetscLogEventBarrierEnd - Logs the time in a barrier before an event. 986 987 Synopsis: 988 #include <petsclog.h> 989 PetscErrorCode PetscLogEventBarrierEnd(int e,PetscObject o1,PetscObject o2,PetscObject o3,PetscObject o4,MPI_Comm comm) 990 991 Logically Collective on MPI_Comm 992 993 Input Parameters: 994 . e - integer associated with the event obtained from PetscLogEventRegister() 995 . o1,o2,o3,o4 - objects associated with the event, or 0 996 . comm - communicator the barrier takes place over 997 998 999 Usage: 1000 .vb 1001 PetscLogEventBarrierBegin(VEC_NormBarrier,0,0,0,0,comm); 1002 MPIU_Allreduce() 1003 PetscLogEventBarrierEnd(VEC_NormBarrier,0,0,0,0,comm); 1004 .ve 1005 1006 Notes: 1007 This is for logging the amount of time spent in a barrier for an event 1008 that requires synchronization. 1009 1010 Additional Notes: 1011 Synchronization events always come in pairs; for example, VEC_NormBarrier and 1012 VEC_NormComm = VEC_NormBarrier + 1 1013 1014 Level: advanced 1015 1016 .seealso: PetscLogEventRegister(), PetscLogEventEnd(), PetscLogFlops(), PetscLogEventBegin(), 1017 PetscLogEventBarrierBegin() 1018 1019 .keywords: log, event, begin, barrier 1020 M*/ 1021 1022 /*@C 1023 PetscLogEventGetId - Returns the event id when given the event name. 1024 1025 Not Collective 1026 1027 Input Parameter: 1028 . name - The event name 1029 1030 Output Parameter: 1031 . event - The event, or -1 if no event with that name exists 1032 1033 Level: intermediate 1034 1035 .seealso: PetscLogEventBegin(), PetscLogEventEnd(), PetscLogStageGetId() 1036 @*/ 1037 PetscErrorCode PetscLogEventGetId(const char name[], PetscLogEvent *event) 1038 { 1039 PetscStageLog stageLog; 1040 PetscErrorCode ierr; 1041 1042 PetscFunctionBegin; 1043 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 1044 ierr = PetscEventRegLogGetEvent(stageLog->eventLog, name, event);CHKERRQ(ierr); 1045 PetscFunctionReturn(0); 1046 } 1047 1048 1049 /*------------------------------------------------ Output Functions -------------------------------------------------*/ 1050 /*@C 1051 PetscLogDump - Dumps logs of objects to a file. This file is intended to 1052 be read by bin/petscview. This program no longer exists. 1053 1054 Collective on PETSC_COMM_WORLD 1055 1056 Input Parameter: 1057 . name - an optional file name 1058 1059 Usage: 1060 .vb 1061 PetscInitialize(...); 1062 PetscLogDefaultBegin(); or PetscLogAllBegin(); 1063 ... code ... 1064 PetscLogDump(filename); 1065 PetscFinalize(); 1066 .ve 1067 1068 Notes: 1069 The default file name is 1070 $ Log.<rank> 1071 where <rank> is the processor number. If no name is specified, 1072 this file will be used. 1073 1074 Level: advanced 1075 1076 .keywords: log, dump 1077 .seealso: PetscLogDefaultBegin(), PetscLogAllBegin(), PetscLogView() 1078 @*/ 1079 PetscErrorCode PetscLogDump(const char sname[]) 1080 { 1081 PetscStageLog stageLog; 1082 PetscEventPerfInfo *eventInfo; 1083 FILE *fd; 1084 char file[PETSC_MAX_PATH_LEN], fname[PETSC_MAX_PATH_LEN]; 1085 PetscLogDouble flops, _TotalTime; 1086 PetscMPIInt rank; 1087 int action, object, curStage; 1088 PetscLogEvent event; 1089 PetscErrorCode ierr; 1090 1091 PetscFunctionBegin; 1092 /* Calculate the total elapsed time */ 1093 PetscTime(&_TotalTime); 1094 _TotalTime -= petsc_BaseTime; 1095 /* Open log file */ 1096 ierr = MPI_Comm_rank(PETSC_COMM_WORLD, &rank);CHKERRQ(ierr); 1097 if (sname) sprintf(file, "%s.%d", sname, rank); 1098 else sprintf(file, "Log.%d", rank); 1099 ierr = PetscFixFilename(file, fname);CHKERRQ(ierr); 1100 ierr = PetscFOpen(PETSC_COMM_WORLD, fname, "w", &fd);CHKERRQ(ierr); 1101 if ((!rank) && (!fd)) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN, "Cannot open file: %s", fname); 1102 /* Output totals */ 1103 ierr = PetscFPrintf(PETSC_COMM_WORLD, fd, "Total Flop %14e %16.8e\n", petsc_TotalFlops, _TotalTime);CHKERRQ(ierr); 1104 ierr = PetscFPrintf(PETSC_COMM_WORLD, fd, "Clock Resolution %g\n", 0.0);CHKERRQ(ierr); 1105 /* Output actions */ 1106 if (petsc_logActions) { 1107 ierr = PetscFPrintf(PETSC_COMM_WORLD, fd, "Actions accomplished %d\n", petsc_numActions);CHKERRQ(ierr); 1108 for (action = 0; action < petsc_numActions; action++) { 1109 ierr = PetscFPrintf(PETSC_COMM_WORLD, fd, "%g %d %d %d %d %d %d %g %g %g\n", 1110 petsc_actions[action].time, petsc_actions[action].action, (int)petsc_actions[action].event, (int)petsc_actions[action].classid, petsc_actions[action].id1, 1111 petsc_actions[action].id2, petsc_actions[action].id3, petsc_actions[action].flops, petsc_actions[action].mem, petsc_actions[action].maxmem);CHKERRQ(ierr); 1112 } 1113 } 1114 /* Output objects */ 1115 if (petsc_logObjects) { 1116 ierr = PetscFPrintf(PETSC_COMM_WORLD, fd, "Objects created %d destroyed %d\n", petsc_numObjects, petsc_numObjectsDestroyed);CHKERRQ(ierr); 1117 for (object = 0; object < petsc_numObjects; object++) { 1118 ierr = PetscFPrintf(PETSC_COMM_WORLD, fd, "Parent ID: %d Memory: %d\n", petsc_objects[object].parent, (int) petsc_objects[object].mem);CHKERRQ(ierr); 1119 if (!petsc_objects[object].name[0]) { 1120 ierr = PetscFPrintf(PETSC_COMM_WORLD, fd,"No Name\n");CHKERRQ(ierr); 1121 } else { 1122 ierr = PetscFPrintf(PETSC_COMM_WORLD, fd, "Name: %s\n", petsc_objects[object].name);CHKERRQ(ierr); 1123 } 1124 if (petsc_objects[object].info[0] != 0) { 1125 ierr = PetscFPrintf(PETSC_COMM_WORLD, fd, "No Info\n");CHKERRQ(ierr); 1126 } else { 1127 ierr = PetscFPrintf(PETSC_COMM_WORLD, fd, "Info: %s\n", petsc_objects[object].info);CHKERRQ(ierr); 1128 } 1129 } 1130 } 1131 /* Output events */ 1132 ierr = PetscFPrintf(PETSC_COMM_WORLD, fd, "Event log:\n");CHKERRQ(ierr); 1133 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 1134 ierr = PetscIntStackTop(stageLog->stack, &curStage);CHKERRQ(ierr); 1135 eventInfo = stageLog->stageInfo[curStage].eventLog->eventInfo; 1136 for (event = 0; event < stageLog->stageInfo[curStage].eventLog->numEvents; event++) { 1137 if (eventInfo[event].time != 0.0) flops = eventInfo[event].flops/eventInfo[event].time; 1138 else flops = 0.0; 1139 ierr = PetscFPrintf(PETSC_COMM_WORLD, fd, "%d %16d %16g %16g %16g\n", event, eventInfo[event].count, 1140 eventInfo[event].flops, eventInfo[event].time, flops);CHKERRQ(ierr); 1141 } 1142 ierr = PetscFClose(PETSC_COMM_WORLD, fd);CHKERRQ(ierr); 1143 PetscFunctionReturn(0); 1144 } 1145 1146 /* 1147 PetscLogView_Detailed - Each process prints the times for its own events 1148 1149 */ 1150 PetscErrorCode PetscLogView_Detailed(PetscViewer viewer) 1151 { 1152 MPI_Comm comm = PetscObjectComm((PetscObject) viewer); 1153 PetscEventPerfInfo *eventInfo = NULL; 1154 PetscLogDouble locTotalTime, numRed, maxMem; 1155 PetscStageLog stageLog; 1156 int numStages,numEvents,stage,event; 1157 PetscMPIInt rank,size; 1158 PetscErrorCode ierr; 1159 1160 PetscFunctionBegin; 1161 ierr = MPI_Comm_size(comm, &size);CHKERRQ(ierr); 1162 ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr); 1163 /* Must preserve reduction count before we go on */ 1164 numRed = petsc_allreduce_ct + petsc_gather_ct + petsc_scatter_ct; 1165 /* Get the total elapsed time */ 1166 PetscTime(&locTotalTime); locTotalTime -= petsc_BaseTime; 1167 ierr = PetscViewerASCIIPrintf(viewer,"size = %d\n",size);CHKERRQ(ierr); 1168 ierr = PetscViewerASCIIPrintf(viewer,"LocalTimes = {}\n");CHKERRQ(ierr); 1169 ierr = PetscViewerASCIIPrintf(viewer,"LocalFlop = {}\n");CHKERRQ(ierr); 1170 ierr = PetscViewerASCIIPrintf(viewer,"LocalMessageLens = {}\n");CHKERRQ(ierr); 1171 ierr = PetscViewerASCIIPrintf(viewer,"LocalMessages = {}\n");CHKERRQ(ierr); 1172 ierr = PetscViewerASCIIPrintf(viewer,"LocalReductions = {}\n");CHKERRQ(ierr); 1173 ierr = PetscViewerASCIIPrintf(viewer,"LocalObjects = {}\n");CHKERRQ(ierr); 1174 ierr = PetscViewerASCIIPrintf(viewer,"LocalMemory = {}\n");CHKERRQ(ierr); 1175 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 1176 ierr = MPIU_Allreduce(&stageLog->numStages, &numStages, 1, MPI_INT, MPI_MAX, comm);CHKERRQ(ierr); 1177 ierr = PetscViewerASCIIPrintf(viewer,"Stages = {}\n");CHKERRQ(ierr); 1178 for (stage=0; stage<numStages; stage++) { 1179 ierr = PetscViewerASCIIPrintf(viewer,"Stages[\"%s\"] = {}\n",stageLog->stageInfo[stage].name);CHKERRQ(ierr); 1180 ierr = PetscViewerASCIIPrintf(viewer,"Stages[\"%s\"][\"summary\"] = {}\n",stageLog->stageInfo[stage].name);CHKERRQ(ierr); 1181 ierr = MPIU_Allreduce(&stageLog->stageInfo[stage].eventLog->numEvents, &numEvents, 1, MPI_INT, MPI_MAX, comm);CHKERRQ(ierr); 1182 for (event = 0; event < numEvents; event++) { 1183 ierr = PetscViewerASCIIPrintf(viewer,"Stages[\"%s\"][\"%s\"] = {}\n",stageLog->stageInfo[stage].name,stageLog->eventLog->eventInfo[event].name);CHKERRQ(ierr); 1184 } 1185 } 1186 ierr = PetscViewerASCIIPushSynchronized(viewer);CHKERRQ(ierr); 1187 ierr = PetscViewerASCIISynchronizedPrintf(viewer,"LocalTimes[%d] = %g\n",rank,locTotalTime);CHKERRQ(ierr); 1188 ierr = PetscViewerASCIISynchronizedPrintf(viewer,"LocalFlop[%d] = %g\n",rank,petsc_TotalFlops);CHKERRQ(ierr); 1189 ierr = PetscViewerASCIISynchronizedPrintf(viewer,"LocalMessageLens[%d] = %g\n",rank,(petsc_irecv_len + petsc_isend_len + petsc_recv_len + petsc_send_len));CHKERRQ(ierr); 1190 ierr = PetscViewerASCIISynchronizedPrintf(viewer,"LocalMessages[%d] = %g\n",rank,(petsc_irecv_ct + petsc_isend_ct + petsc_recv_ct + petsc_send_ct));CHKERRQ(ierr); 1191 ierr = PetscViewerASCIISynchronizedPrintf(viewer,"LocalReductions[%d] = %g\n",rank,numRed);CHKERRQ(ierr); 1192 ierr = PetscViewerASCIISynchronizedPrintf(viewer,"LocalObjects[%d] = %d\n",rank,petsc_numObjects);CHKERRQ(ierr); 1193 ierr = PetscMallocGetMaximumUsage(&maxMem);CHKERRQ(ierr); 1194 ierr = PetscViewerASCIISynchronizedPrintf(viewer,"LocalMemory[%d] = %g\n",rank,maxMem);CHKERRQ(ierr); 1195 ierr = PetscViewerFlush(viewer);CHKERRQ(ierr); 1196 for (stage=0; stage<numStages; stage++) { 1197 ierr = PetscViewerASCIISynchronizedPrintf(viewer,"Stages[\"%s\"][\"summary\"][%d] = {\"time\" : %g, \"numMessages\" : %g, \"messageLength\" : %g, \"numReductions\" : %g, \"flop\" : %g}\n", 1198 stageLog->stageInfo[stage].name,rank, 1199 stageLog->stageInfo[stage].perfInfo.time,stageLog->stageInfo[stage].perfInfo.numMessages,stageLog->stageInfo[stage].perfInfo.messageLength, 1200 stageLog->stageInfo[stage].perfInfo.numReductions,stageLog->stageInfo[stage].perfInfo.flops);CHKERRQ(ierr); 1201 ierr = MPIU_Allreduce(&stageLog->stageInfo[stage].eventLog->numEvents, &numEvents, 1, MPI_INT, MPI_MAX, comm);CHKERRQ(ierr); 1202 for (event = 0; event < numEvents; event++) { 1203 eventInfo = stageLog->stageInfo[stage].eventLog->eventInfo; 1204 ierr = PetscViewerASCIISynchronizedPrintf(viewer,"Stages[\"%s\"][\"%s\"][%d] = {\"count\" : %D, \"time\" : %g, \"numMessages\" : %g, \"messageLength\" : %g, \"numReductions\" : %g, \"flop\" : %g}\n",stageLog->stageInfo[stage].name,stageLog->eventLog->eventInfo[event].name,rank, 1205 eventInfo[event].count, eventInfo[event].time,eventInfo[event].numMessages, eventInfo[event].messageLength, 1206 eventInfo[event].numReductions,eventInfo[event].flops);CHKERRQ(ierr); 1207 } 1208 } 1209 ierr = PetscViewerFlush(viewer);CHKERRQ(ierr); 1210 ierr = PetscViewerASCIIPopSynchronized(viewer);CHKERRQ(ierr); 1211 PetscFunctionReturn(0); 1212 } 1213 1214 static PetscErrorCode PetscLogViewWarnDebugging(MPI_Comm comm,FILE *fd) 1215 { 1216 #if defined(PETSC_USE_DEBUG) 1217 PetscErrorCode ierr; 1218 1219 PetscFunctionBegin; 1220 ierr = PetscFPrintf(comm, fd, "\n\n");CHKERRQ(ierr); 1221 ierr = PetscFPrintf(comm, fd, " ##########################################################\n");CHKERRQ(ierr); 1222 ierr = PetscFPrintf(comm, fd, " # #\n");CHKERRQ(ierr); 1223 ierr = PetscFPrintf(comm, fd, " # WARNING!!! #\n");CHKERRQ(ierr); 1224 ierr = PetscFPrintf(comm, fd, " # #\n");CHKERRQ(ierr); 1225 ierr = PetscFPrintf(comm, fd, " # This code was compiled with a debugging option, #\n");CHKERRQ(ierr); 1226 ierr = PetscFPrintf(comm, fd, " # To get timing results run ./configure #\n");CHKERRQ(ierr); 1227 ierr = PetscFPrintf(comm, fd, " # using --with-debugging=no, the performance will #\n");CHKERRQ(ierr); 1228 ierr = PetscFPrintf(comm, fd, " # be generally two or three times faster. #\n");CHKERRQ(ierr); 1229 ierr = PetscFPrintf(comm, fd, " # #\n");CHKERRQ(ierr); 1230 ierr = PetscFPrintf(comm, fd, " ##########################################################\n\n\n");CHKERRQ(ierr); 1231 PetscFunctionReturn(0); 1232 #else 1233 return 0; 1234 #endif 1235 } 1236 1237 PetscErrorCode PetscLogView_Default(PetscViewer viewer) 1238 { 1239 FILE *fd; 1240 PetscLogDouble zero = 0.0; 1241 PetscStageLog stageLog; 1242 PetscStageInfo *stageInfo = NULL; 1243 PetscEventPerfInfo *eventInfo = NULL; 1244 PetscClassPerfInfo *classInfo; 1245 char arch[128],hostname[128],username[128],pname[PETSC_MAX_PATH_LEN],date[128]; 1246 const char *name; 1247 PetscLogDouble locTotalTime, TotalTime, TotalFlops; 1248 PetscLogDouble numMessages, messageLength, avgMessLen, numReductions; 1249 PetscLogDouble stageTime, flops, flopr, mem, mess, messLen, red; 1250 PetscLogDouble fracTime, fracFlops, fracMessages, fracLength, fracReductions, fracMess, fracMessLen, fracRed; 1251 PetscLogDouble fracStageTime, fracStageFlops, fracStageMess, fracStageMessLen, fracStageRed; 1252 PetscLogDouble min, max, tot, ratio, avg, x, y; 1253 PetscLogDouble minf, maxf, totf, ratf, mint, maxt, tott, ratt, ratCt, totm, totml, totr; 1254 PetscMPIInt minCt, maxCt; 1255 PetscMPIInt size, rank; 1256 PetscBool *localStageUsed, *stageUsed; 1257 PetscBool *localStageVisible, *stageVisible; 1258 int numStages, localNumEvents, numEvents; 1259 int stage, oclass; 1260 PetscLogEvent event; 1261 PetscErrorCode ierr; 1262 char version[256]; 1263 MPI_Comm comm; 1264 1265 PetscFunctionBegin; 1266 ierr = PetscObjectGetComm((PetscObject)viewer,&comm);CHKERRQ(ierr); 1267 ierr = PetscViewerASCIIGetPointer(viewer,&fd);CHKERRQ(ierr); 1268 ierr = MPI_Comm_size(comm, &size);CHKERRQ(ierr); 1269 ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr); 1270 /* Get the total elapsed time */ 1271 PetscTime(&locTotalTime); locTotalTime -= petsc_BaseTime; 1272 1273 ierr = PetscFPrintf(comm, fd, "************************************************************************************************************************\n");CHKERRQ(ierr); 1274 ierr = PetscFPrintf(comm, fd, "*** WIDEN YOUR WINDOW TO 120 CHARACTERS. Use 'enscript -r -fCourier9' to print this document ***\n");CHKERRQ(ierr); 1275 ierr = PetscFPrintf(comm, fd, "************************************************************************************************************************\n");CHKERRQ(ierr); 1276 ierr = PetscFPrintf(comm, fd, "\n---------------------------------------------- PETSc Performance Summary: ----------------------------------------------\n\n");CHKERRQ(ierr); 1277 ierr = PetscLogViewWarnDebugging(comm,fd);CHKERRQ(ierr); 1278 ierr = PetscGetArchType(arch,sizeof(arch));CHKERRQ(ierr); 1279 ierr = PetscGetHostName(hostname,sizeof(hostname));CHKERRQ(ierr); 1280 ierr = PetscGetUserName(username,sizeof(username));CHKERRQ(ierr); 1281 ierr = PetscGetProgramName(pname,sizeof(pname));CHKERRQ(ierr); 1282 ierr = PetscGetDate(date,sizeof(date));CHKERRQ(ierr); 1283 ierr = PetscGetVersion(version,sizeof(version));CHKERRQ(ierr); 1284 if (size == 1) { 1285 ierr = PetscFPrintf(comm,fd,"%s on a %s named %s with %d processor, by %s %s\n", pname, arch, hostname, size, username, date);CHKERRQ(ierr); 1286 } else { 1287 ierr = PetscFPrintf(comm,fd,"%s on a %s named %s with %d processors, by %s %s\n", pname, arch, hostname, size, username, date);CHKERRQ(ierr); 1288 } 1289 1290 ierr = PetscFPrintf(comm, fd, "Using %s\n", version);CHKERRQ(ierr); 1291 1292 /* Must preserve reduction count before we go on */ 1293 red = petsc_allreduce_ct + petsc_gather_ct + petsc_scatter_ct; 1294 1295 /* Calculate summary information */ 1296 ierr = PetscFPrintf(comm, fd, "\n Max Max/Min Avg Total \n");CHKERRQ(ierr); 1297 /* Time */ 1298 ierr = MPIU_Allreduce(&locTotalTime, &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);CHKERRQ(ierr); 1299 ierr = MPIU_Allreduce(&locTotalTime, &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);CHKERRQ(ierr); 1300 ierr = MPIU_Allreduce(&locTotalTime, &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1301 avg = (tot)/((PetscLogDouble) size); 1302 if (min != 0.0) ratio = max/min; 1303 else ratio = 0.0; 1304 ierr = PetscFPrintf(comm, fd, "Time (sec): %5.3e %10.5f %5.3e\n", max, ratio, avg);CHKERRQ(ierr); 1305 TotalTime = tot; 1306 /* Objects */ 1307 avg = (PetscLogDouble) petsc_numObjects; 1308 ierr = MPIU_Allreduce(&avg, &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);CHKERRQ(ierr); 1309 ierr = MPIU_Allreduce(&avg, &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);CHKERRQ(ierr); 1310 ierr = MPIU_Allreduce(&avg, &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1311 avg = (tot)/((PetscLogDouble) size); 1312 if (min != 0.0) ratio = max/min; 1313 else ratio = 0.0; 1314 ierr = PetscFPrintf(comm, fd, "Objects: %5.3e %10.5f %5.3e\n", max, ratio, avg);CHKERRQ(ierr); 1315 /* Flops */ 1316 ierr = MPIU_Allreduce(&petsc_TotalFlops, &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);CHKERRQ(ierr); 1317 ierr = MPIU_Allreduce(&petsc_TotalFlops, &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);CHKERRQ(ierr); 1318 ierr = MPIU_Allreduce(&petsc_TotalFlops, &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1319 avg = (tot)/((PetscLogDouble) size); 1320 if (min != 0.0) ratio = max/min; 1321 else ratio = 0.0; 1322 ierr = PetscFPrintf(comm, fd, "Flop: %5.3e %10.5f %5.3e %5.3e\n", max, ratio, avg, tot);CHKERRQ(ierr); 1323 TotalFlops = tot; 1324 /* Flops/sec -- Must talk to Barry here */ 1325 if (locTotalTime != 0.0) flops = petsc_TotalFlops/locTotalTime; 1326 else flops = 0.0; 1327 ierr = MPIU_Allreduce(&flops, &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);CHKERRQ(ierr); 1328 ierr = MPIU_Allreduce(&flops, &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);CHKERRQ(ierr); 1329 ierr = MPIU_Allreduce(&flops, &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1330 avg = (tot)/((PetscLogDouble) size); 1331 if (min != 0.0) ratio = max/min; 1332 else ratio = 0.0; 1333 ierr = PetscFPrintf(comm, fd, "Flop/sec: %5.3e %10.5f %5.3e %5.3e\n", max, ratio, avg, tot);CHKERRQ(ierr); 1334 /* Memory */ 1335 ierr = PetscMallocGetMaximumUsage(&mem);CHKERRQ(ierr); 1336 if (mem > 0.0) { 1337 ierr = MPIU_Allreduce(&mem, &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);CHKERRQ(ierr); 1338 ierr = MPIU_Allreduce(&mem, &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);CHKERRQ(ierr); 1339 ierr = MPIU_Allreduce(&mem, &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1340 avg = (tot)/((PetscLogDouble) size); 1341 if (min != 0.0) ratio = max/min; 1342 else ratio = 0.0; 1343 ierr = PetscFPrintf(comm, fd, "Memory: %5.3e %10.5f %5.3e\n", max, ratio, tot);CHKERRQ(ierr); 1344 } 1345 /* Messages */ 1346 mess = 0.5*(petsc_irecv_ct + petsc_isend_ct + petsc_recv_ct + petsc_send_ct); 1347 ierr = MPIU_Allreduce(&mess, &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);CHKERRQ(ierr); 1348 ierr = MPIU_Allreduce(&mess, &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);CHKERRQ(ierr); 1349 ierr = MPIU_Allreduce(&mess, &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1350 avg = (tot)/((PetscLogDouble) size); 1351 if (min != 0.0) ratio = max/min; 1352 else ratio = 0.0; 1353 ierr = PetscFPrintf(comm, fd, "MPI Messages: %5.3e %10.5f %5.3e %5.3e\n", max, ratio, avg, tot);CHKERRQ(ierr); 1354 numMessages = tot; 1355 /* Message Lengths */ 1356 mess = 0.5*(petsc_irecv_len + petsc_isend_len + petsc_recv_len + petsc_send_len); 1357 ierr = MPIU_Allreduce(&mess, &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);CHKERRQ(ierr); 1358 ierr = MPIU_Allreduce(&mess, &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);CHKERRQ(ierr); 1359 ierr = MPIU_Allreduce(&mess, &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1360 if (numMessages != 0) avg = (tot)/(numMessages); 1361 else avg = 0.0; 1362 if (min != 0.0) ratio = max/min; 1363 else ratio = 0.0; 1364 ierr = PetscFPrintf(comm, fd, "MPI Message Lengths: %5.3e %10.5f %5.3e %5.3e\n", max, ratio, avg, tot);CHKERRQ(ierr); 1365 messageLength = tot; 1366 /* Reductions */ 1367 ierr = MPIU_Allreduce(&red, &min, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);CHKERRQ(ierr); 1368 ierr = MPIU_Allreduce(&red, &max, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);CHKERRQ(ierr); 1369 ierr = MPIU_Allreduce(&red, &tot, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1370 if (min != 0.0) ratio = max/min; 1371 else ratio = 0.0; 1372 ierr = PetscFPrintf(comm, fd, "MPI Reductions: %5.3e %10.5f\n", max, ratio);CHKERRQ(ierr); 1373 numReductions = red; /* wrong because uses count from process zero */ 1374 ierr = PetscFPrintf(comm, fd, "\nFlop counting convention: 1 flop = 1 real number operation of type (multiply/divide/add/subtract)\n");CHKERRQ(ierr); 1375 ierr = PetscFPrintf(comm, fd, " e.g., VecAXPY() for real vectors of length N --> 2N flop\n");CHKERRQ(ierr); 1376 ierr = PetscFPrintf(comm, fd, " and VecAXPY() for complex vectors of length N --> 8N flop\n");CHKERRQ(ierr); 1377 1378 /* Get total number of stages -- 1379 Currently, a single processor can register more stages than another, but stages must all be registered in order. 1380 We can removed this requirement if necessary by having a global stage numbering and indirection on the stage ID. 1381 This seems best accomplished by assoicating a communicator with each stage. 1382 */ 1383 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 1384 ierr = MPIU_Allreduce(&stageLog->numStages, &numStages, 1, MPI_INT, MPI_MAX, comm);CHKERRQ(ierr); 1385 ierr = PetscMalloc1(numStages, &localStageUsed);CHKERRQ(ierr); 1386 ierr = PetscMalloc1(numStages, &stageUsed);CHKERRQ(ierr); 1387 ierr = PetscMalloc1(numStages, &localStageVisible);CHKERRQ(ierr); 1388 ierr = PetscMalloc1(numStages, &stageVisible);CHKERRQ(ierr); 1389 if (numStages > 0) { 1390 stageInfo = stageLog->stageInfo; 1391 for (stage = 0; stage < numStages; stage++) { 1392 if (stage < stageLog->numStages) { 1393 localStageUsed[stage] = stageInfo[stage].used; 1394 localStageVisible[stage] = stageInfo[stage].perfInfo.visible; 1395 } else { 1396 localStageUsed[stage] = PETSC_FALSE; 1397 localStageVisible[stage] = PETSC_TRUE; 1398 } 1399 } 1400 ierr = MPIU_Allreduce(localStageUsed, stageUsed, numStages, MPIU_BOOL, MPI_LOR, comm);CHKERRQ(ierr); 1401 ierr = MPIU_Allreduce(localStageVisible, stageVisible, numStages, MPIU_BOOL, MPI_LAND, comm);CHKERRQ(ierr); 1402 for (stage = 0; stage < numStages; stage++) { 1403 if (stageUsed[stage]) { 1404 ierr = PetscFPrintf(comm, fd, "\nSummary of Stages: ----- Time ------ ----- Flop ----- --- Messages --- -- Message Lengths -- -- Reductions --\n");CHKERRQ(ierr); 1405 ierr = PetscFPrintf(comm, fd, " Avg %%Total Avg %%Total counts %%Total Avg %%Total counts %%Total \n");CHKERRQ(ierr); 1406 break; 1407 } 1408 } 1409 for (stage = 0; stage < numStages; stage++) { 1410 if (!stageUsed[stage]) continue; 1411 /* CANNOT use MPIU_Allreduce() since it might fail the line number check */ 1412 if (localStageUsed[stage]) { 1413 ierr = MPI_Allreduce(&stageInfo[stage].perfInfo.time, &stageTime, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1414 ierr = MPI_Allreduce(&stageInfo[stage].perfInfo.flops, &flops, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1415 ierr = MPI_Allreduce(&stageInfo[stage].perfInfo.numMessages, &mess, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1416 ierr = MPI_Allreduce(&stageInfo[stage].perfInfo.messageLength, &messLen, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1417 ierr = MPI_Allreduce(&stageInfo[stage].perfInfo.numReductions, &red, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1418 name = stageInfo[stage].name; 1419 } else { 1420 ierr = MPI_Allreduce(&zero, &stageTime, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1421 ierr = MPI_Allreduce(&zero, &flops, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1422 ierr = MPI_Allreduce(&zero, &mess, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1423 ierr = MPI_Allreduce(&zero, &messLen, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1424 ierr = MPI_Allreduce(&zero, &red, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1425 name = ""; 1426 } 1427 mess *= 0.5; messLen *= 0.5; red /= size; 1428 if (TotalTime != 0.0) fracTime = stageTime/TotalTime; else fracTime = 0.0; 1429 if (TotalFlops != 0.0) fracFlops = flops/TotalFlops; else fracFlops = 0.0; 1430 /* Talk to Barry if (stageTime != 0.0) flops = (size*flops)/stageTime; else flops = 0.0; */ 1431 if (numMessages != 0.0) fracMessages = mess/numMessages; else fracMessages = 0.0; 1432 if (numMessages != 0.0) avgMessLen = messLen/numMessages; else avgMessLen = 0.0; 1433 if (messageLength != 0.0) fracLength = messLen/messageLength; else fracLength = 0.0; 1434 if (numReductions != 0.0) fracReductions = red/numReductions; else fracReductions = 0.0; 1435 ierr = 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", 1436 stage, name, stageTime/size, 100.0*fracTime, flops, 100.0*fracFlops, 1437 mess, 100.0*fracMessages, avgMessLen, 100.0*fracLength, red, 100.0*fracReductions);CHKERRQ(ierr); 1438 } 1439 } 1440 1441 ierr = PetscFPrintf(comm, fd,"\n------------------------------------------------------------------------------------------------------------------------\n");CHKERRQ(ierr); 1442 ierr = PetscFPrintf(comm, fd, "See the 'Profiling' chapter of the users' manual for details on interpreting output.\n");CHKERRQ(ierr); 1443 ierr = PetscFPrintf(comm, fd, "Phase summary info:\n");CHKERRQ(ierr); 1444 ierr = PetscFPrintf(comm, fd, " Count: number of times phase was executed\n");CHKERRQ(ierr); 1445 ierr = PetscFPrintf(comm, fd, " Time and Flop: Max - maximum over all processors\n");CHKERRQ(ierr); 1446 ierr = PetscFPrintf(comm, fd, " Ratio - ratio of maximum to minimum over all processors\n");CHKERRQ(ierr); 1447 ierr = PetscFPrintf(comm, fd, " Mess: number of messages sent\n");CHKERRQ(ierr); 1448 ierr = PetscFPrintf(comm, fd, " Avg. len: average message length (bytes)\n");CHKERRQ(ierr); 1449 ierr = PetscFPrintf(comm, fd, " Reduct: number of global reductions\n");CHKERRQ(ierr); 1450 ierr = PetscFPrintf(comm, fd, " Global: entire computation\n");CHKERRQ(ierr); 1451 ierr = PetscFPrintf(comm, fd, " Stage: stages of a computation. Set stages with PetscLogStagePush() and PetscLogStagePop().\n");CHKERRQ(ierr); 1452 ierr = PetscFPrintf(comm, fd, " %%T - percent time in this phase %%F - percent flop in this phase\n");CHKERRQ(ierr); 1453 ierr = PetscFPrintf(comm, fd, " %%M - percent messages in this phase %%L - percent message lengths in this phase\n");CHKERRQ(ierr); 1454 ierr = PetscFPrintf(comm, fd, " %%R - percent reductions in this phase\n");CHKERRQ(ierr); 1455 ierr = PetscFPrintf(comm, fd, " Total Mflop/s: 10e-6 * (sum of flop over all processors)/(max time over all processors)\n");CHKERRQ(ierr); 1456 ierr = PetscFPrintf(comm, fd, "------------------------------------------------------------------------------------------------------------------------\n");CHKERRQ(ierr); 1457 1458 ierr = PetscLogViewWarnDebugging(comm,fd);CHKERRQ(ierr); 1459 1460 /* Report events */ 1461 ierr = PetscFPrintf(comm, fd,"Event Count Time (sec) Flop --- Global --- --- Stage --- Total\n");CHKERRQ(ierr); 1462 ierr = PetscFPrintf(comm, fd," Max Ratio Max Ratio Max Ratio Mess Avg len Reduct %%T %%F %%M %%L %%R %%T %%F %%M %%L %%R Mflop/s\n");CHKERRQ(ierr); 1463 ierr = PetscFPrintf(comm,fd,"------------------------------------------------------------------------------------------------------------------------\n");CHKERRQ(ierr); 1464 1465 /* Problem: The stage name will not show up unless the stage executed on proc 1 */ 1466 for (stage = 0; stage < numStages; stage++) { 1467 if (!stageVisible[stage]) continue; 1468 /* CANNOT use MPIU_Allreduce() since it might fail the line number check */ 1469 if (localStageUsed[stage]) { 1470 ierr = PetscFPrintf(comm, fd, "\n--- Event Stage %d: %s\n\n", stage, stageInfo[stage].name);CHKERRQ(ierr); 1471 ierr = MPI_Allreduce(&stageInfo[stage].perfInfo.time, &stageTime, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1472 ierr = MPI_Allreduce(&stageInfo[stage].perfInfo.flops, &flops, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1473 ierr = MPI_Allreduce(&stageInfo[stage].perfInfo.numMessages, &mess, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1474 ierr = MPI_Allreduce(&stageInfo[stage].perfInfo.messageLength, &messLen, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1475 ierr = MPI_Allreduce(&stageInfo[stage].perfInfo.numReductions, &red, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1476 } else { 1477 ierr = PetscFPrintf(comm, fd, "\n--- Event Stage %d: Unknown\n\n", stage);CHKERRQ(ierr); 1478 ierr = MPI_Allreduce(&zero, &stageTime, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1479 ierr = MPI_Allreduce(&zero, &flops, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1480 ierr = MPI_Allreduce(&zero, &mess, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1481 ierr = MPI_Allreduce(&zero, &messLen, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1482 ierr = MPI_Allreduce(&zero, &red, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1483 } 1484 mess *= 0.5; messLen *= 0.5; red /= size; 1485 1486 /* Get total number of events in this stage -- 1487 Currently, a single processor can register more events than another, but events must all be registered in order, 1488 just like stages. We can removed this requirement if necessary by having a global event numbering and indirection 1489 on the event ID. This seems best accomplished by assoicating a communicator with each stage. 1490 1491 Problem: If the event did not happen on proc 1, its name will not be available. 1492 Problem: Event visibility is not implemented 1493 */ 1494 if (localStageUsed[stage]) { 1495 eventInfo = stageLog->stageInfo[stage].eventLog->eventInfo; 1496 localNumEvents = stageLog->stageInfo[stage].eventLog->numEvents; 1497 } else localNumEvents = 0; 1498 ierr = MPIU_Allreduce(&localNumEvents, &numEvents, 1, MPI_INT, MPI_MAX, comm);CHKERRQ(ierr); 1499 for (event = 0; event < numEvents; event++) { 1500 /* CANNOT use MPIU_Allreduce() since it might fail the line number check */ 1501 if (localStageUsed[stage] && (event < stageLog->stageInfo[stage].eventLog->numEvents) && (eventInfo[event].depth == 0)) { 1502 if ((eventInfo[event].count > 0) && (eventInfo[event].time > 0.0)) flopr = eventInfo[event].flops; 1503 else flopr = 0.0; 1504 1505 ierr = MPI_Allreduce(&flopr, &minf, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);CHKERRQ(ierr); 1506 ierr = MPI_Allreduce(&flopr, &maxf, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);CHKERRQ(ierr); 1507 ierr = MPI_Allreduce(&eventInfo[event].flops, &totf, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1508 ierr = MPI_Allreduce(&eventInfo[event].time, &mint, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);CHKERRQ(ierr); 1509 ierr = MPI_Allreduce(&eventInfo[event].time, &maxt, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);CHKERRQ(ierr); 1510 ierr = MPI_Allreduce(&eventInfo[event].time, &tott, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1511 ierr = MPI_Allreduce(&eventInfo[event].numMessages, &totm, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1512 ierr = MPI_Allreduce(&eventInfo[event].messageLength, &totml, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1513 ierr = MPI_Allreduce(&eventInfo[event].numReductions, &totr, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1514 ierr = MPI_Allreduce(&eventInfo[event].count, &minCt, 1, MPI_INT, MPI_MIN, comm);CHKERRQ(ierr); 1515 ierr = MPI_Allreduce(&eventInfo[event].count, &maxCt, 1, MPI_INT, MPI_MAX, comm);CHKERRQ(ierr); 1516 name = stageLog->eventLog->eventInfo[event].name; 1517 } else { 1518 flopr = 0.0; 1519 ierr = MPI_Allreduce(&flopr, &minf, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);CHKERRQ(ierr); 1520 ierr = MPI_Allreduce(&flopr, &maxf, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);CHKERRQ(ierr); 1521 ierr = MPI_Allreduce(&zero, &totf, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1522 ierr = MPI_Allreduce(&zero, &mint, 1, MPIU_PETSCLOGDOUBLE, MPI_MIN, comm);CHKERRQ(ierr); 1523 ierr = MPI_Allreduce(&zero, &maxt, 1, MPIU_PETSCLOGDOUBLE, MPI_MAX, comm);CHKERRQ(ierr); 1524 ierr = MPI_Allreduce(&zero, &tott, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1525 ierr = MPI_Allreduce(&zero, &totm, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1526 ierr = MPI_Allreduce(&zero, &totml, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1527 ierr = MPI_Allreduce(&zero, &totr, 1, MPIU_PETSCLOGDOUBLE, MPI_SUM, comm);CHKERRQ(ierr); 1528 ierr = MPI_Allreduce(&ierr, &minCt, 1, MPI_INT, MPI_MIN, comm);CHKERRQ(ierr); 1529 ierr = MPI_Allreduce(&ierr, &maxCt, 1, MPI_INT, MPI_MAX, comm);CHKERRQ(ierr); 1530 name = ""; 1531 } 1532 if (mint < 0.0) { 1533 ierr = 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); 1534 mint = 0; 1535 } 1536 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); 1537 totm *= 0.5; totml *= 0.5; totr /= size; 1538 1539 if (maxCt != 0) { 1540 if (minCt != 0) ratCt = ((PetscLogDouble) maxCt)/minCt; else ratCt = 0.0; 1541 if (mint != 0.0) ratt = maxt/mint; else ratt = 0.0; 1542 if (minf != 0.0) ratf = maxf/minf; else ratf = 0.0; 1543 if (TotalTime != 0.0) fracTime = tott/TotalTime; else fracTime = 0.0; 1544 if (TotalFlops != 0.0) fracFlops = totf/TotalFlops; else fracFlops = 0.0; 1545 if (stageTime != 0.0) fracStageTime = tott/stageTime; else fracStageTime = 0.0; 1546 if (flops != 0.0) fracStageFlops = totf/flops; else fracStageFlops = 0.0; 1547 if (numMessages != 0.0) fracMess = totm/numMessages; else fracMess = 0.0; 1548 if (messageLength != 0.0) fracMessLen = totml/messageLength; else fracMessLen = 0.0; 1549 if (numReductions != 0.0) fracRed = totr/numReductions; else fracRed = 0.0; 1550 if (mess != 0.0) fracStageMess = totm/mess; else fracStageMess = 0.0; 1551 if (messLen != 0.0) fracStageMessLen = totml/messLen; else fracStageMessLen = 0.0; 1552 if (red != 0.0) fracStageRed = totr/red; else fracStageRed = 0.0; 1553 if (totm != 0.0) totml /= totm; else totml = 0.0; 1554 if (maxt != 0.0) flopr = totf/maxt; else flopr = 0.0; 1555 if (fracStageTime > 1.00) ierr = PetscFPrintf(comm, fd,"Warning -- total time of event greater than time of entire stage -- something is wrong with the timer\n");CHKERRQ(ierr); 1556 ierr = PetscFPrintf(comm, fd, 1557 "%-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\n", 1558 name, maxCt, ratCt, maxt, ratt, maxf, ratf, totm, totml, totr, 1559 100.0*fracTime, 100.0*fracFlops, 100.0*fracMess, 100.0*fracMessLen, 100.0*fracRed, 1560 100.0*fracStageTime, 100.0*fracStageFlops, 100.0*fracStageMess, 100.0*fracStageMessLen, 100.0*fracStageRed, 1561 PetscAbsReal(flopr/1.0e6));CHKERRQ(ierr); 1562 } 1563 } 1564 } 1565 1566 /* Memory usage and object creation */ 1567 ierr = PetscFPrintf(comm, fd, "------------------------------------------------------------------------------------------------------------------------\n");CHKERRQ(ierr); 1568 ierr = PetscFPrintf(comm, fd, "\n");CHKERRQ(ierr); 1569 ierr = PetscFPrintf(comm, fd, "Memory usage is given in bytes:\n\n");CHKERRQ(ierr); 1570 1571 /* Right now, only stages on the first processor are reported here, meaning only objects associated with 1572 the global communicator, or MPI_COMM_SELF for proc 1. We really should report global stats and then 1573 stats for stages local to processor sets. 1574 */ 1575 /* We should figure out the longest object name here (now 20 characters) */ 1576 ierr = PetscFPrintf(comm, fd, "Object Type Creations Destructions Memory Descendants' Mem.\n");CHKERRQ(ierr); 1577 ierr = PetscFPrintf(comm, fd, "Reports information only for process 0.\n");CHKERRQ(ierr); 1578 for (stage = 0; stage < numStages; stage++) { 1579 if (localStageUsed[stage]) { 1580 classInfo = stageLog->stageInfo[stage].classLog->classInfo; 1581 ierr = PetscFPrintf(comm, fd, "\n--- Event Stage %d: %s\n\n", stage, stageInfo[stage].name);CHKERRQ(ierr); 1582 for (oclass = 0; oclass < stageLog->stageInfo[stage].classLog->numClasses; oclass++) { 1583 if ((classInfo[oclass].creations > 0) || (classInfo[oclass].destructions > 0)) { 1584 ierr = PetscFPrintf(comm, fd, "%20s %5d %5d %11.0f %g\n", stageLog->classLog->classInfo[oclass].name, 1585 classInfo[oclass].creations, classInfo[oclass].destructions, classInfo[oclass].mem, 1586 classInfo[oclass].descMem);CHKERRQ(ierr); 1587 } 1588 } 1589 } else { 1590 ierr = PetscFPrintf(comm, fd, "\n--- Event Stage %d: Unknown\n\n", stage);CHKERRQ(ierr); 1591 } 1592 } 1593 1594 ierr = PetscFree(localStageUsed);CHKERRQ(ierr); 1595 ierr = PetscFree(stageUsed);CHKERRQ(ierr); 1596 ierr = PetscFree(localStageVisible);CHKERRQ(ierr); 1597 ierr = PetscFree(stageVisible);CHKERRQ(ierr); 1598 1599 /* Information unrelated to this particular run */ 1600 ierr = PetscFPrintf(comm, fd, "========================================================================================================================\n");CHKERRQ(ierr); 1601 PetscTime(&y); 1602 PetscTime(&x); 1603 PetscTime(&y); PetscTime(&y); PetscTime(&y); PetscTime(&y); PetscTime(&y); 1604 PetscTime(&y); PetscTime(&y); PetscTime(&y); PetscTime(&y); PetscTime(&y); 1605 ierr = PetscFPrintf(comm,fd,"Average time to get PetscTime(): %g\n", (y-x)/10.0);CHKERRQ(ierr); 1606 /* MPI information */ 1607 if (size > 1) { 1608 MPI_Status status; 1609 PetscMPIInt tag; 1610 MPI_Comm newcomm; 1611 1612 ierr = MPI_Barrier(comm);CHKERRQ(ierr); 1613 PetscTime(&x); 1614 ierr = MPI_Barrier(comm);CHKERRQ(ierr); 1615 ierr = MPI_Barrier(comm);CHKERRQ(ierr); 1616 ierr = MPI_Barrier(comm);CHKERRQ(ierr); 1617 ierr = MPI_Barrier(comm);CHKERRQ(ierr); 1618 ierr = MPI_Barrier(comm);CHKERRQ(ierr); 1619 PetscTime(&y); 1620 ierr = PetscFPrintf(comm, fd, "Average time for MPI_Barrier(): %g\n", (y-x)/5.0);CHKERRQ(ierr); 1621 ierr = PetscCommDuplicate(comm,&newcomm, &tag);CHKERRQ(ierr); 1622 ierr = MPI_Barrier(comm);CHKERRQ(ierr); 1623 if (rank) { 1624 ierr = MPI_Recv(0, 0, MPI_INT, rank-1, tag, newcomm, &status);CHKERRQ(ierr); 1625 ierr = MPI_Send(0, 0, MPI_INT, (rank+1)%size, tag, newcomm);CHKERRQ(ierr); 1626 } else { 1627 PetscTime(&x); 1628 ierr = MPI_Send(0, 0, MPI_INT, 1, tag, newcomm);CHKERRQ(ierr); 1629 ierr = MPI_Recv(0, 0, MPI_INT, size-1, tag, newcomm, &status);CHKERRQ(ierr); 1630 PetscTime(&y); 1631 ierr = PetscFPrintf(comm,fd,"Average time for zero size MPI_Send(): %g\n", (y-x)/size);CHKERRQ(ierr); 1632 } 1633 ierr = PetscCommDestroy(&newcomm);CHKERRQ(ierr); 1634 } 1635 ierr = PetscOptionsView(NULL,viewer);CHKERRQ(ierr); 1636 1637 /* Machine and compile information */ 1638 #if defined(PETSC_USE_FORTRAN_KERNELS) 1639 ierr = PetscFPrintf(comm, fd, "Compiled with FORTRAN kernels\n");CHKERRQ(ierr); 1640 #else 1641 ierr = PetscFPrintf(comm, fd, "Compiled without FORTRAN kernels\n");CHKERRQ(ierr); 1642 #endif 1643 #if defined(PETSC_USE_REAL_SINGLE) 1644 ierr = PetscFPrintf(comm, fd, "Compiled with single precision PetscScalar and PetscReal\n");CHKERRQ(ierr); 1645 #elif defined(PETSC_USE_LONGDOUBLE) 1646 ierr = PetscFPrintf(comm, fd, "Compiled with long double precision PetscScalar and PetscReal\n");CHKERRQ(ierr); 1647 #endif 1648 1649 #if defined(PETSC_USE_REAL_MAT_SINGLE) 1650 ierr = PetscFPrintf(comm, fd, "Compiled with single precision matrices\n");CHKERRQ(ierr); 1651 #else 1652 ierr = PetscFPrintf(comm, fd, "Compiled with full precision matrices (default)\n");CHKERRQ(ierr); 1653 #endif 1654 ierr = PetscFPrintf(comm, fd, "sizeof(short) %d sizeof(int) %d sizeof(long) %d sizeof(void*) %d sizeof(PetscScalar) %d sizeof(PetscInt) %d\n", 1655 (int) sizeof(short), (int) sizeof(int), (int) sizeof(long), (int) sizeof(void*),(int) sizeof(PetscScalar),(int) sizeof(PetscInt));CHKERRQ(ierr); 1656 1657 ierr = PetscFPrintf(comm, fd, "Configure options: %s",petscconfigureoptions);CHKERRQ(ierr); 1658 ierr = PetscFPrintf(comm, fd, "%s", petscmachineinfo);CHKERRQ(ierr); 1659 ierr = PetscFPrintf(comm, fd, "%s", petsccompilerinfo);CHKERRQ(ierr); 1660 ierr = PetscFPrintf(comm, fd, "%s", petsccompilerflagsinfo);CHKERRQ(ierr); 1661 ierr = PetscFPrintf(comm, fd, "%s", petsclinkerinfo);CHKERRQ(ierr); 1662 1663 /* Cleanup */ 1664 ierr = PetscFPrintf(comm, fd, "\n");CHKERRQ(ierr); 1665 ierr = PetscLogViewWarnDebugging(comm,fd);CHKERRQ(ierr); 1666 PetscFunctionReturn(0); 1667 } 1668 1669 PetscErrorCode PetscLogView_Nested(PetscViewer); 1670 1671 /*@C 1672 PetscLogView - Prints a summary of the logging. 1673 1674 Collective over MPI_Comm 1675 1676 Input Parameter: 1677 . viewer - an ASCII viewer 1678 1679 Options Database Keys: 1680 + -log_view [:filename] - Prints summary of log information 1681 . -log_view :filename.py:ascii_info_detail - Saves logging information from each process as a Python file 1682 . -log_view :filename.xml:ascii_xml - Saves a summary of the logging information in a nested format, use a browser to open this file, for example on 1683 Apple MacOS systems use open -a Safari filename.xml 1684 . -log_all - Saves a file Log.rank for each MPI process with details of each step of the computation 1685 - -log_trace [filename] - Displays a trace of what each process is doing 1686 1687 Notes: 1688 It is possible to control the logging programatically but we recommend using the options database approach whenever possible 1689 By default the summary is printed to stdout. 1690 1691 Before calling this routine you must have called either PetscLogDefaultBegin() or PetscLogNestedBegin() 1692 1693 If PETSc is configured with --with-logging=0 then this functionality is not available 1694 1695 The nested XML format was kindly donated by Koos Huijssen and Christiaan M. Klaij MARITIME RESEARCH INSTITUTE NETHERLANDS 1696 1697 Level: beginner 1698 1699 .keywords: log, dump, print 1700 .seealso: PetscLogDefaultBegin(), PetscLogDump() 1701 @*/ 1702 PetscErrorCode PetscLogView(PetscViewer viewer) 1703 { 1704 PetscErrorCode ierr; 1705 PetscBool isascii; 1706 PetscViewerFormat format; 1707 int stage, lastStage; 1708 PetscStageLog stageLog; 1709 1710 PetscFunctionBegin; 1711 if (!PetscLogPLB) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Must use -log_view or PetscLogDefaultBegin() before calling this routine"); 1712 /* Pop off any stages the user forgot to remove */ 1713 lastStage = 0; 1714 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 1715 ierr = PetscStageLogGetCurrent(stageLog, &stage);CHKERRQ(ierr); 1716 while (stage >= 0) { 1717 lastStage = stage; 1718 ierr = PetscStageLogPop(stageLog);CHKERRQ(ierr); 1719 ierr = PetscStageLogGetCurrent(stageLog, &stage);CHKERRQ(ierr); 1720 } 1721 ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isascii);CHKERRQ(ierr); 1722 if (!isascii) SETERRQ(PetscObjectComm((PetscObject)viewer),PETSC_ERR_SUP,"Currently can only view logging to ASCII"); 1723 ierr = PetscViewerGetFormat(viewer,&format);CHKERRQ(ierr); 1724 if (format == PETSC_VIEWER_DEFAULT || format == PETSC_VIEWER_ASCII_INFO) { 1725 ierr = PetscLogView_Default(viewer);CHKERRQ(ierr); 1726 } else if (format == PETSC_VIEWER_ASCII_INFO_DETAIL) { 1727 ierr = PetscLogView_Detailed(viewer);CHKERRQ(ierr); 1728 } else if (format == PETSC_VIEWER_ASCII_XML) { 1729 ierr = PetscLogView_Nested(viewer);CHKERRQ(ierr); 1730 } 1731 ierr = PetscStageLogPush(stageLog, lastStage);CHKERRQ(ierr); 1732 PetscFunctionReturn(0); 1733 } 1734 1735 /*@C 1736 PetscLogViewFromOptions - Processes command line options to determine if/how a PetscLog is to be viewed. 1737 1738 Collective on PETSC_COMM_WORLD 1739 1740 Not normally called by user 1741 1742 Level: intermediate 1743 1744 @*/ 1745 PetscErrorCode PetscLogViewFromOptions(void) 1746 { 1747 PetscErrorCode ierr; 1748 PetscViewer viewer; 1749 PetscBool flg; 1750 PetscViewerFormat format; 1751 1752 PetscFunctionBegin; 1753 ierr = PetscOptionsGetViewer(PETSC_COMM_WORLD,NULL,"-log_view",&viewer,&format,&flg);CHKERRQ(ierr); 1754 if (flg) { 1755 ierr = PetscViewerPushFormat(viewer,format);CHKERRQ(ierr); 1756 ierr = PetscLogView(viewer);CHKERRQ(ierr); 1757 ierr = PetscViewerPopFormat(viewer);CHKERRQ(ierr); 1758 ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr); 1759 } 1760 PetscFunctionReturn(0); 1761 } 1762 1763 1764 1765 /*----------------------------------------------- Counter Functions -------------------------------------------------*/ 1766 /*@C 1767 PetscGetFlops - Returns the number of flops used on this processor 1768 since the program began. 1769 1770 Not Collective 1771 1772 Output Parameter: 1773 flops - number of floating point operations 1774 1775 Notes: 1776 A global counter logs all PETSc flop counts. The user can use 1777 PetscLogFlops() to increment this counter to include flops for the 1778 application code. 1779 1780 Level: intermediate 1781 1782 .keywords: log, flops, floating point operations 1783 1784 .seealso: PetscTime(), PetscLogFlops() 1785 @*/ 1786 PetscErrorCode PetscGetFlops(PetscLogDouble *flops) 1787 { 1788 PetscFunctionBegin; 1789 *flops = petsc_TotalFlops; 1790 PetscFunctionReturn(0); 1791 } 1792 1793 PetscErrorCode PetscLogObjectState(PetscObject obj, const char format[], ...) 1794 { 1795 PetscErrorCode ierr; 1796 size_t fullLength; 1797 va_list Argp; 1798 1799 PetscFunctionBegin; 1800 if (!petsc_logObjects) PetscFunctionReturn(0); 1801 va_start(Argp, format); 1802 ierr = PetscVSNPrintf(petsc_objects[obj->id].info, 64,format,&fullLength, Argp);CHKERRQ(ierr); 1803 va_end(Argp); 1804 PetscFunctionReturn(0); 1805 } 1806 1807 1808 /*MC 1809 PetscLogFlops - Adds floating point operations to the global counter. 1810 1811 Synopsis: 1812 #include <petsclog.h> 1813 PetscErrorCode PetscLogFlops(PetscLogDouble f) 1814 1815 Not Collective 1816 1817 Input Parameter: 1818 . f - flop counter 1819 1820 1821 Usage: 1822 .vb 1823 PetscLogEvent USER_EVENT; 1824 PetscLogEventRegister("User event",0,&USER_EVENT); 1825 PetscLogEventBegin(USER_EVENT,0,0,0,0); 1826 [code segment to monitor] 1827 PetscLogFlops(user_flops) 1828 PetscLogEventEnd(USER_EVENT,0,0,0,0); 1829 .ve 1830 1831 Notes: 1832 A global counter logs all PETSc flop counts. The user can use 1833 PetscLogFlops() to increment this counter to include flops for the 1834 application code. 1835 1836 Level: intermediate 1837 1838 .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogEventEnd(), PetscGetFlops() 1839 1840 .keywords: log, flops, floating point operations 1841 M*/ 1842 1843 /*MC 1844 PetscPreLoadBegin - Begin a segment of code that may be preloaded (run twice) 1845 to get accurate timings 1846 1847 Synopsis: 1848 #include <petsclog.h> 1849 void PetscPreLoadBegin(PetscBool flag,char *name); 1850 1851 Not Collective 1852 1853 Input Parameter: 1854 + flag - PETSC_TRUE to run twice, PETSC_FALSE to run once, may be overridden 1855 with command line option -preload true or -preload false 1856 - name - name of first stage (lines of code timed separately with -log_view) to 1857 be preloaded 1858 1859 Usage: 1860 .vb 1861 PetscPreLoadBegin(PETSC_TRUE,"first stage); 1862 lines of code 1863 PetscPreLoadStage("second stage"); 1864 lines of code 1865 PetscPreLoadEnd(); 1866 .ve 1867 1868 Notes: Only works in C/C++, not Fortran 1869 1870 Flags available within the macro. 1871 + PetscPreLoadingUsed - true if we are or have done preloading 1872 . PetscPreLoadingOn - true if it is CURRENTLY doing preload 1873 . PetscPreLoadIt - 0 for the first computation (with preloading turned off it is only 0) 1 for the second 1874 - PetscPreLoadMax - number of times it will do the computation, only one when preloading is turned on 1875 The first two variables are available throughout the program, the second two only between the PetscPreLoadBegin() 1876 and PetscPreLoadEnd() 1877 1878 Level: intermediate 1879 1880 .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogEventEnd(), PetscPreLoadEnd(), PetscPreLoadStage() 1881 1882 Concepts: preloading 1883 Concepts: timing^accurate 1884 Concepts: paging^eliminating effects of 1885 1886 1887 M*/ 1888 1889 /*MC 1890 PetscPreLoadEnd - End a segment of code that may be preloaded (run twice) 1891 to get accurate timings 1892 1893 Synopsis: 1894 #include <petsclog.h> 1895 void PetscPreLoadEnd(void); 1896 1897 Not Collective 1898 1899 Usage: 1900 .vb 1901 PetscPreLoadBegin(PETSC_TRUE,"first stage); 1902 lines of code 1903 PetscPreLoadStage("second stage"); 1904 lines of code 1905 PetscPreLoadEnd(); 1906 .ve 1907 1908 Notes: only works in C/C++ not fortran 1909 1910 Level: intermediate 1911 1912 .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogEventEnd(), PetscPreLoadBegin(), PetscPreLoadStage() 1913 1914 M*/ 1915 1916 /*MC 1917 PetscPreLoadStage - Start a new segment of code to be timed separately. 1918 to get accurate timings 1919 1920 Synopsis: 1921 #include <petsclog.h> 1922 void PetscPreLoadStage(char *name); 1923 1924 Not Collective 1925 1926 Usage: 1927 .vb 1928 PetscPreLoadBegin(PETSC_TRUE,"first stage); 1929 lines of code 1930 PetscPreLoadStage("second stage"); 1931 lines of code 1932 PetscPreLoadEnd(); 1933 .ve 1934 1935 Notes: only works in C/C++ not fortran 1936 1937 Level: intermediate 1938 1939 .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogEventEnd(), PetscPreLoadBegin(), PetscPreLoadEnd() 1940 1941 M*/ 1942 1943 1944 #else /* end of -DPETSC_USE_LOG section */ 1945 1946 PetscErrorCode PetscLogObjectState(PetscObject obj, const char format[], ...) 1947 { 1948 PetscFunctionBegin; 1949 PetscFunctionReturn(0); 1950 } 1951 1952 #endif /* PETSC_USE_LOG*/ 1953 1954 1955 PetscClassId PETSC_LARGEST_CLASSID = PETSC_SMALLEST_CLASSID; 1956 PetscClassId PETSC_OBJECT_CLASSID = 0; 1957 1958 /*@C 1959 PetscClassIdRegister - Registers a new class name for objects and logging operations in an application code. 1960 1961 Not Collective 1962 1963 Input Parameter: 1964 . name - The class name 1965 1966 Output Parameter: 1967 . oclass - The class id or classid 1968 1969 Level: developer 1970 1971 .keywords: log, class, register 1972 1973 @*/ 1974 PetscErrorCode PetscClassIdRegister(const char name[],PetscClassId *oclass) 1975 { 1976 #if defined(PETSC_USE_LOG) 1977 PetscStageLog stageLog; 1978 PetscInt stage; 1979 PetscErrorCode ierr; 1980 #endif 1981 1982 PetscFunctionBegin; 1983 *oclass = ++PETSC_LARGEST_CLASSID; 1984 #if defined(PETSC_USE_LOG) 1985 ierr = PetscLogGetStageLog(&stageLog);CHKERRQ(ierr); 1986 ierr = PetscClassRegLogRegister(stageLog->classLog, name, *oclass);CHKERRQ(ierr); 1987 for (stage = 0; stage < stageLog->numStages; stage++) { 1988 ierr = PetscClassPerfLogEnsureSize(stageLog->stageInfo[stage].classLog, stageLog->classLog->numClasses);CHKERRQ(ierr); 1989 } 1990 #endif 1991 PetscFunctionReturn(0); 1992 } 1993 1994 #if defined(PETSC_USE_LOG) && defined(PETSC_HAVE_MPE) 1995 #include <mpe.h> 1996 1997 PetscBool PetscBeganMPE = PETSC_FALSE; 1998 1999 PETSC_INTERN PetscErrorCode PetscLogEventBeginMPE(PetscLogEvent,int,PetscObject,PetscObject,PetscObject,PetscObject); 2000 PETSC_INTERN PetscErrorCode PetscLogEventEndMPE(PetscLogEvent,int,PetscObject,PetscObject,PetscObject,PetscObject); 2001 2002 /*@C 2003 PetscLogMPEBegin - Turns on MPE logging of events. This creates large log files 2004 and slows the program down. 2005 2006 Collective over PETSC_COMM_WORLD 2007 2008 Options Database Keys: 2009 . -log_mpe - Prints extensive log information 2010 2011 Notes: 2012 A related routine is PetscLogDefaultBegin() (with the options key -log_view), which is 2013 intended for production runs since it logs only flop rates and object 2014 creation (and should not significantly slow the programs). 2015 2016 Level: advanced 2017 2018 Concepts: logging^MPE 2019 Concepts: logging^message passing 2020 2021 .seealso: PetscLogDump(), PetscLogDefaultBegin(), PetscLogAllBegin(), PetscLogEventActivate(), 2022 PetscLogEventDeactivate() 2023 @*/ 2024 PetscErrorCode PetscLogMPEBegin(void) 2025 { 2026 PetscErrorCode ierr; 2027 2028 PetscFunctionBegin; 2029 /* Do MPE initialization */ 2030 if (!MPE_Initialized_logging()) { /* This function exists in mpich 1.1.2 and higher */ 2031 ierr = PetscInfo(0,"Initializing MPE.\n");CHKERRQ(ierr); 2032 ierr = MPE_Init_log();CHKERRQ(ierr); 2033 2034 PetscBeganMPE = PETSC_TRUE; 2035 } else { 2036 ierr = PetscInfo(0,"MPE already initialized. Not attempting to reinitialize.\n");CHKERRQ(ierr); 2037 } 2038 ierr = PetscLogSet(PetscLogEventBeginMPE, PetscLogEventEndMPE);CHKERRQ(ierr); 2039 PetscFunctionReturn(0); 2040 } 2041 2042 /*@C 2043 PetscLogMPEDump - Dumps the MPE logging info to file for later use with Jumpshot. 2044 2045 Collective over PETSC_COMM_WORLD 2046 2047 Level: advanced 2048 2049 .seealso: PetscLogDump(), PetscLogAllBegin(), PetscLogMPEBegin() 2050 @*/ 2051 PetscErrorCode PetscLogMPEDump(const char sname[]) 2052 { 2053 char name[PETSC_MAX_PATH_LEN]; 2054 PetscErrorCode ierr; 2055 2056 PetscFunctionBegin; 2057 if (PetscBeganMPE) { 2058 ierr = PetscInfo(0,"Finalizing MPE.\n");CHKERRQ(ierr); 2059 if (sname) { 2060 ierr = PetscStrcpy(name,sname);CHKERRQ(ierr); 2061 } else { 2062 ierr = PetscGetProgramName(name,PETSC_MAX_PATH_LEN);CHKERRQ(ierr); 2063 } 2064 ierr = MPE_Finish_log(name);CHKERRQ(ierr); 2065 } else { 2066 ierr = PetscInfo(0,"Not finalizing MPE (not started by PETSc).\n");CHKERRQ(ierr); 2067 } 2068 PetscFunctionReturn(0); 2069 } 2070 2071 #define PETSC_RGB_COLORS_MAX 39 2072 static const char *PetscLogMPERGBColors[PETSC_RGB_COLORS_MAX] = { 2073 "OliveDrab: ", 2074 "BlueViolet: ", 2075 "CadetBlue: ", 2076 "CornflowerBlue: ", 2077 "DarkGoldenrod: ", 2078 "DarkGreen: ", 2079 "DarkKhaki: ", 2080 "DarkOliveGreen: ", 2081 "DarkOrange: ", 2082 "DarkOrchid: ", 2083 "DarkSeaGreen: ", 2084 "DarkSlateGray: ", 2085 "DarkTurquoise: ", 2086 "DeepPink: ", 2087 "DarkKhaki: ", 2088 "DimGray: ", 2089 "DodgerBlue: ", 2090 "GreenYellow: ", 2091 "HotPink: ", 2092 "IndianRed: ", 2093 "LavenderBlush: ", 2094 "LawnGreen: ", 2095 "LemonChiffon: ", 2096 "LightCoral: ", 2097 "LightCyan: ", 2098 "LightPink: ", 2099 "LightSalmon: ", 2100 "LightSlateGray: ", 2101 "LightYellow: ", 2102 "LimeGreen: ", 2103 "MediumPurple: ", 2104 "MediumSeaGreen: ", 2105 "MediumSlateBlue:", 2106 "MidnightBlue: ", 2107 "MintCream: ", 2108 "MistyRose: ", 2109 "NavajoWhite: ", 2110 "NavyBlue: ", 2111 "OliveDrab: " 2112 }; 2113 2114 /*@C 2115 PetscLogMPEGetRGBColor - This routine returns a rgb color useable with PetscLogEventRegister() 2116 2117 Not collective. Maybe it should be? 2118 2119 Output Parameter 2120 . str - character string representing the color 2121 2122 Level: developer 2123 2124 .keywords: log, mpe , color 2125 .seealso: PetscLogEventRegister 2126 @*/ 2127 PetscErrorCode PetscLogMPEGetRGBColor(const char *str[]) 2128 { 2129 static int idx = 0; 2130 2131 PetscFunctionBegin; 2132 *str = PetscLogMPERGBColors[idx]; 2133 idx = (idx + 1)% PETSC_RGB_COLORS_MAX; 2134 PetscFunctionReturn(0); 2135 } 2136 2137 #endif /* PETSC_USE_LOG && PETSC_HAVE_MPE */ 2138