1 /* 2 3 This file defines part of the initialization of PETSc 4 5 This file uses regular malloc and free because it cannot be known 6 what malloc is being used until it has already processed the input. 7 */ 8 #include <petsc/private/petscimpl.h> /*I "petscsys.h" I*/ 9 10 #if defined(PETSC_HAVE_UNISTD_H) 11 #include <unistd.h> 12 #endif 13 14 /* ------------------------Nasty global variables -------------------------------*/ 15 /* 16 Indicates if PETSc started up MPI, or it was 17 already started before PETSc was initialized. 18 */ 19 PetscBool PetscBeganMPI = PETSC_FALSE; 20 PetscBool PetscErrorHandlingInitialized = PETSC_FALSE; 21 PetscBool PetscInitializeCalled = PETSC_FALSE; 22 PetscBool PetscFinalizeCalled = PETSC_FALSE; 23 24 PetscMPIInt PetscGlobalRank = -1; 25 PetscMPIInt PetscGlobalSize = -1; 26 27 #if defined(PETSC_HAVE_KOKKOS) 28 PetscBool PetscBeganKokkos = PETSC_FALSE; 29 #endif 30 31 #if defined(PETSC_HAVE_NVSHMEM) 32 PetscBool PetscBeganNvshmem = PETSC_FALSE; 33 PetscBool PetscNvshmemInitialized = PETSC_FALSE; 34 #endif 35 36 PetscBool use_gpu_aware_mpi = PetscDefined(HAVE_MPIUNI) ? PETSC_FALSE : PETSC_TRUE; 37 38 PetscBool PetscPrintFunctionList = PETSC_FALSE; 39 40 #if defined(PETSC_HAVE_COMPLEX) 41 #if defined(PETSC_COMPLEX_INSTANTIATE) 42 template <> 43 class std::complex<double>; /* instantiate complex template class */ 44 #endif 45 46 /*MC 47 PETSC_i - the imaginary number i 48 49 Synopsis: 50 #include <petscsys.h> 51 PetscComplex PETSC_i; 52 53 Level: beginner 54 55 Note: 56 Complex numbers are automatically available if PETSc located a working complex implementation 57 58 .seealso: `PetscRealPart()`, `PetscImaginaryPart()`, `PetscRealPartComplex()`, `PetscImaginaryPartComplex()` 59 M*/ 60 PetscComplex PETSC_i; 61 MPI_Datatype MPIU___COMPLEX128 = 0; 62 #endif /* PETSC_HAVE_COMPLEX */ 63 #if defined(PETSC_HAVE_REAL___FLOAT128) 64 MPI_Datatype MPIU___FLOAT128 = 0; 65 #endif 66 #if defined(PETSC_HAVE_REAL___FP16) 67 MPI_Datatype MPIU___FP16 = 0; 68 #endif 69 MPI_Datatype MPIU_2SCALAR = 0; 70 MPI_Datatype MPIU_REAL_INT = 0; 71 MPI_Datatype MPIU_SCALAR_INT = 0; 72 #if defined(PETSC_USE_64BIT_INDICES) 73 MPI_Datatype MPIU_2INT = 0; 74 #endif 75 MPI_Datatype MPI_4INT = 0; 76 MPI_Datatype MPIU_4INT = 0; 77 MPI_Datatype MPIU_BOOL; 78 MPI_Datatype MPIU_ENUM; 79 MPI_Datatype MPIU_FORTRANADDR; 80 MPI_Datatype MPIU_SIZE_T; 81 82 /* 83 Function that is called to display all error messages 84 */ 85 PetscErrorCode (*PetscErrorPrintf)(const char[], ...) = PetscErrorPrintfDefault; 86 PetscErrorCode (*PetscHelpPrintf)(MPI_Comm, const char[], ...) = PetscHelpPrintfDefault; 87 PetscErrorCode (*PetscVFPrintf)(FILE *, const char[], va_list) = PetscVFPrintfDefault; 88 89 /* 90 Optional file where all PETSc output from various prints is saved 91 */ 92 PETSC_INTERN FILE *petsc_history; 93 FILE *petsc_history = NULL; 94 95 PetscErrorCode PetscOpenHistoryFile(const char filename[], FILE **fd) 96 { 97 PetscMPIInt rank, size; 98 char pfile[PETSC_MAX_PATH_LEN], pname[PETSC_MAX_PATH_LEN], fname[PETSC_MAX_PATH_LEN], date[64]; 99 char version[256]; 100 101 PetscFunctionBegin; 102 PetscCallMPI(MPI_Comm_rank(PETSC_COMM_WORLD, &rank)); 103 if (rank == 0) { 104 char arch[10]; 105 106 PetscCall(PetscGetArchType(arch, 10)); 107 PetscCall(PetscGetDate(date, 64)); 108 PetscCall(PetscGetVersion(version, 256)); 109 PetscCallMPI(MPI_Comm_size(PETSC_COMM_WORLD, &size)); 110 if (filename) { 111 PetscCall(PetscFixFilename(filename, fname)); 112 } else { 113 PetscCall(PetscGetHomeDirectory(pfile, sizeof(pfile))); 114 PetscCall(PetscStrlcat(pfile, "/.petschistory", sizeof(pfile))); 115 PetscCall(PetscFixFilename(pfile, fname)); 116 } 117 118 *fd = fopen(fname, "a"); 119 PetscCheck(fd, PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Cannot open file: %s", fname); 120 121 PetscCall(PetscFPrintf(PETSC_COMM_SELF, *fd, "----------------------------------------\n")); 122 PetscCall(PetscFPrintf(PETSC_COMM_SELF, *fd, "%s %s\n", version, date)); 123 PetscCall(PetscGetProgramName(pname, sizeof(pname))); 124 PetscCall(PetscFPrintf(PETSC_COMM_SELF, *fd, "%s on a %s, %d proc. with options:\n", pname, arch, size)); 125 PetscCall(PetscFPrintf(PETSC_COMM_SELF, *fd, "----------------------------------------\n")); 126 127 PetscCall(PetscFFlush(*fd)); 128 } 129 PetscFunctionReturn(PETSC_SUCCESS); 130 } 131 132 PETSC_INTERN PetscErrorCode PetscCloseHistoryFile(FILE **fd) 133 { 134 PetscMPIInt rank; 135 136 PetscFunctionBegin; 137 PetscCallMPI(MPI_Comm_rank(PETSC_COMM_WORLD, &rank)); 138 if (rank == 0) { 139 char date[64]; 140 int err; 141 142 PetscCall(PetscGetDate(date, sizeof(date))); 143 PetscCall(PetscFPrintf(PETSC_COMM_SELF, *fd, "----------------------------------------\n")); 144 PetscCall(PetscFPrintf(PETSC_COMM_SELF, *fd, "Finished at %s\n", date)); 145 PetscCall(PetscFPrintf(PETSC_COMM_SELF, *fd, "----------------------------------------\n")); 146 PetscCall(PetscFFlush(*fd)); 147 err = fclose(*fd); 148 PetscCheck(!err, PETSC_COMM_SELF, PETSC_ERR_SYS, "fclose() failed on file"); 149 } 150 PetscFunctionReturn(PETSC_SUCCESS); 151 } 152 153 /* 154 This is ugly and probably belongs somewhere else, but I want to 155 be able to put a true MPI abort error handler with command line args. 156 157 This is so MPI errors in the debugger will leave all the stack 158 frames. The default MP_Abort() cleans up and exits thus providing no useful information 159 in the debugger hence we call abort() instead of MPI_Abort(). 160 */ 161 162 void Petsc_MPI_AbortOnError(PETSC_UNUSED MPI_Comm *comm, PetscMPIInt *flag, ...) 163 { 164 PetscFunctionBegin; 165 PetscCallContinue((*PetscErrorPrintf)("MPI error %d\n", *flag)); 166 abort(); 167 } 168 169 void Petsc_MPI_DebuggerOnError(MPI_Comm *comm, PetscMPIInt *flag, ...) 170 { 171 PetscFunctionBegin; 172 PetscCallContinue((*PetscErrorPrintf)("MPI error %d\n", *flag)); 173 if (PetscAttachDebugger()) PETSCABORT(*comm, (PetscErrorCode)*flag); /* hopeless so get out */ 174 } 175 176 /*@C 177 PetscEnd - Calls `PetscFinalize()` and then ends the program. This is useful if one 178 wishes a clean exit somewhere deep in the program. 179 180 Collective on `PETSC_COMM_WORLD` 181 182 Options Database Keys are the same as for `PetscFinalize()` 183 184 Level: advanced 185 186 Note: 187 See `PetscInitialize()` for more general runtime options. 188 189 .seealso: `PetscInitialize()`, `PetscOptionsView()`, `PetscMallocDump()`, `PetscMPIDump()`, `PetscFinalize()` 190 @*/ 191 PetscErrorCode PetscEnd(void) 192 { 193 PetscFunctionBegin; 194 PetscCall(PetscFinalize()); 195 exit(0); 196 return PETSC_SUCCESS; 197 } 198 199 PetscBool PetscOptionsPublish = PETSC_FALSE; 200 PETSC_INTERN PetscErrorCode PetscSetUseHBWMalloc_Private(void); 201 PETSC_INTERN PetscBool petscsetmallocvisited; 202 static char emacsmachinename[256]; 203 204 PetscErrorCode (*PetscExternalVersionFunction)(MPI_Comm) = NULL; 205 PetscErrorCode (*PetscExternalHelpFunction)(MPI_Comm) = NULL; 206 207 #if PetscDefined(USE_LOG) 208 #include <petscviewer.h> 209 #endif 210 211 /*@C 212 PetscSetHelpVersionFunctions - Sets functions that print help and version information 213 before the PETSc help and version information is printed. Must call BEFORE `PetscInitialize()`. 214 This routine enables a "higher-level" package that uses PETSc to print its messages first and control 215 how the PETSc help messages are printed. 216 217 Input Parameters: 218 + help - the help function (may be `NULL`) 219 - version - the version function (may be `NULL`) 220 221 Level: developer 222 223 .seealso: `PetscInitialize()` 224 @*/ 225 PetscErrorCode PetscSetHelpVersionFunctions(PetscErrorCode (*help)(MPI_Comm), PetscErrorCode (*version)(MPI_Comm)) 226 { 227 PetscFunctionBegin; 228 PetscExternalHelpFunction = help; 229 PetscExternalVersionFunction = version; 230 PetscFunctionReturn(PETSC_SUCCESS); 231 } 232 233 #if defined(PETSC_USE_LOG) 234 PETSC_INTERN PetscBool PetscObjectsLog; 235 #endif 236 237 PETSC_INTERN PetscErrorCode PetscOptionsCheckInitial_Private(const char help[]) 238 { 239 char string[64]; 240 MPI_Comm comm = PETSC_COMM_WORLD; 241 PetscBool flg1 = PETSC_FALSE, flg2 = PETSC_FALSE, flag, hasHelp; 242 PetscBool checkstack = PETSC_FALSE; 243 PetscReal si; 244 PetscInt intensity; 245 int i; 246 PetscMPIInt rank; 247 char version[256]; 248 #if defined(PETSC_USE_LOG) 249 char mname[PETSC_MAX_PATH_LEN]; 250 PetscViewerFormat format; 251 PetscBool flg4 = PETSC_FALSE; 252 #endif 253 254 PetscFunctionBegin; 255 PetscCallMPI(MPI_Comm_rank(comm, &rank)); 256 257 if (PetscDefined(USE_DEBUG) && !PetscDefined(HAVE_THREADSAFETY)) checkstack = PETSC_TRUE; 258 PetscCall(PetscOptionsGetBool(NULL, NULL, "-checkstack", &checkstack, NULL)); 259 PetscCall(PetscStackSetCheck(checkstack)); 260 261 PetscCall(PetscOptionsGetBool(NULL, NULL, "-checkfunctionlist", &PetscPrintFunctionList, NULL)); 262 263 #if !defined(PETSC_HAVE_THREADSAFETY) 264 if (!(PETSC_RUNNING_ON_VALGRIND)) { 265 /* 266 Setup the memory management; support for tracing malloc() usage 267 */ 268 PetscBool mdebug = PETSC_FALSE, eachcall = PETSC_FALSE, initializenan = PETSC_FALSE, mlog = PETSC_FALSE; 269 PetscBool flg3 = PETSC_FALSE; 270 271 if (PetscDefined(USE_DEBUG)) { 272 mdebug = PETSC_TRUE; 273 initializenan = PETSC_TRUE; 274 PetscCall(PetscOptionsHasName(NULL, NULL, "-malloc_test", &flg1)); 275 } else { 276 /* don't warn about unused option */ 277 PetscCall(PetscOptionsHasName(NULL, NULL, "-malloc_test", &flg1)); 278 flg1 = PETSC_FALSE; 279 } 280 PetscCall(PetscOptionsGetBool(NULL, NULL, "-malloc_debug", &flg2, &flg3)); 281 if (flg1 || flg2) { 282 mdebug = PETSC_TRUE; 283 eachcall = PETSC_TRUE; 284 initializenan = PETSC_TRUE; 285 } else if (flg3 && !flg2) { 286 mdebug = PETSC_FALSE; 287 eachcall = PETSC_FALSE; 288 initializenan = PETSC_FALSE; 289 } 290 291 PetscCall(PetscOptionsGetBool(NULL, NULL, "-malloc_requested_size", &flg1, &flg2)); 292 if (flg2) PetscCall(PetscMallocLogRequestedSizeSet(flg1)); 293 294 PetscCall(PetscOptionsHasName(NULL, NULL, "-malloc_view", &mlog)); 295 if (mlog) mdebug = PETSC_TRUE; 296 /* the next line is deprecated */ 297 PetscCall(PetscOptionsGetBool(NULL, NULL, "-malloc", &mdebug, NULL)); 298 PetscCall(PetscOptionsGetBool(NULL, NULL, "-malloc_dump", &mdebug, NULL)); 299 PetscCall(PetscOptionsGetBool(NULL, NULL, "-log_view_memory", &mdebug, NULL)); 300 if (mdebug) PetscCall(PetscMallocSetDebug(eachcall, initializenan)); 301 if (mlog) { 302 PetscReal logthreshold = 0; 303 PetscCall(PetscOptionsGetReal(NULL, NULL, "-malloc_view_threshold", &logthreshold, NULL)); 304 PetscCall(PetscMallocViewSet(logthreshold)); 305 } 306 #if defined(PETSC_USE_LOG) 307 PetscCall(PetscOptionsGetBool(NULL, NULL, "-log_view_memory", &PetscLogMemory, NULL)); 308 #endif 309 } 310 311 PetscCall(PetscOptionsGetBool(NULL, NULL, "-malloc_coalesce", &flg1, &flg2)); 312 if (flg2) PetscCall(PetscMallocSetCoalesce(flg1)); 313 flg1 = PETSC_FALSE; 314 PetscCall(PetscOptionsGetBool(NULL, NULL, "-malloc_hbw", &flg1, NULL)); 315 /* ignore this option if malloc is already set */ 316 if (flg1 && !petscsetmallocvisited) PetscCall(PetscSetUseHBWMalloc_Private()); 317 318 PetscCall(PetscOptionsDeprecatedNoObject("-malloc_info", "-memory_view", "3.15", NULL)); 319 flg1 = PETSC_FALSE; 320 flg1 = PETSC_FALSE; 321 PetscCall(PetscOptionsGetBool(NULL, NULL, "-memory_view", &flg1, NULL)); 322 if (flg1) PetscCall(PetscMemorySetGetMaximumUsage()); 323 #endif 324 325 #if defined(PETSC_USE_LOG) 326 PetscCall(PetscOptionsHasName(NULL, NULL, "-objects_dump", &PetscObjectsLog)); 327 #endif 328 329 /* 330 Set the display variable for graphics 331 */ 332 PetscCall(PetscSetDisplay()); 333 334 /* 335 Print main application help message 336 */ 337 PetscCall(PetscOptionsHasHelp(NULL, &hasHelp)); 338 if (help && hasHelp) { 339 PetscCall(PetscPrintf(comm, "%s", help)); 340 PetscCall(PetscPrintf(comm, "----------------------------------------\n")); 341 } 342 343 /* 344 Print the PETSc version information 345 */ 346 PetscCall(PetscOptionsHasName(NULL, NULL, "-version", &flg1)); 347 if (flg1 || hasHelp) { 348 /* 349 Print "higher-level" package version message 350 */ 351 if (PetscExternalVersionFunction) PetscCall((*PetscExternalVersionFunction)(comm)); 352 353 PetscCall(PetscGetVersion(version, 256)); 354 PetscCall((*PetscHelpPrintf)(comm, "%s\n", version)); 355 PetscCall((*PetscHelpPrintf)(comm, "%s", PETSC_AUTHOR_INFO)); 356 PetscCall((*PetscHelpPrintf)(comm, "See https://petsc.org/release/changes for recent updates.\n")); 357 PetscCall((*PetscHelpPrintf)(comm, "See https://petsc.org/release/faq for problems.\n")); 358 PetscCall((*PetscHelpPrintf)(comm, "See https://petsc.org/release/manualpages for help. \n")); 359 PetscCall((*PetscHelpPrintf)(comm, "Libraries linked from %s\n", PETSC_LIB_DIR)); 360 PetscCall((*PetscHelpPrintf)(comm, "----------------------------------------\n")); 361 } 362 363 /* 364 Print "higher-level" package help message 365 */ 366 if (hasHelp) { 367 PetscBool hasHelpIntro; 368 369 if (PetscExternalHelpFunction) PetscCall((*PetscExternalHelpFunction)(comm)); 370 PetscCall(PetscOptionsHasHelpIntro_Internal(NULL, &hasHelpIntro)); 371 if (hasHelpIntro) { 372 PetscCall(PetscOptionsDestroyDefault()); 373 PetscCall(PetscFreeMPIResources()); 374 PetscCallMPI(MPI_Finalize()); 375 exit(0); 376 } 377 } 378 379 /* 380 Setup the error handling 381 */ 382 flg1 = PETSC_FALSE; 383 PetscCall(PetscOptionsGetBool(NULL, NULL, "-on_error_abort", &flg1, NULL)); 384 if (flg1) { 385 PetscCallMPI(MPI_Comm_set_errhandler(comm, MPI_ERRORS_ARE_FATAL)); 386 PetscCall(PetscPushErrorHandler(PetscAbortErrorHandler, NULL)); 387 } 388 flg1 = PETSC_FALSE; 389 PetscCall(PetscOptionsGetBool(NULL, NULL, "-on_error_mpiabort", &flg1, NULL)); 390 if (flg1) PetscCall(PetscPushErrorHandler(PetscMPIAbortErrorHandler, NULL)); 391 flg1 = PETSC_FALSE; 392 PetscCall(PetscOptionsGetBool(NULL, NULL, "-mpi_return_on_error", &flg1, NULL)); 393 if (flg1) PetscCallMPI(MPI_Comm_set_errhandler(comm, MPI_ERRORS_RETURN)); 394 flg1 = PETSC_FALSE; 395 PetscCall(PetscOptionsGetBool(NULL, NULL, "-no_signal_handler", &flg1, NULL)); 396 if (!flg1) PetscCall(PetscPushSignalHandler(PetscSignalHandlerDefault, (void *)0)); 397 398 /* 399 Setup debugger information 400 */ 401 PetscCall(PetscSetDefaultDebugger()); 402 PetscCall(PetscOptionsGetString(NULL, NULL, "-on_error_attach_debugger", string, sizeof(string), &flg1)); 403 if (flg1) { 404 MPI_Errhandler err_handler; 405 406 PetscCall(PetscSetDebuggerFromString(string)); 407 PetscCallMPI(MPI_Comm_create_errhandler(Petsc_MPI_DebuggerOnError, &err_handler)); 408 PetscCallMPI(MPI_Comm_set_errhandler(comm, err_handler)); 409 PetscCall(PetscPushErrorHandler(PetscAttachDebuggerErrorHandler, NULL)); 410 } 411 PetscCall(PetscOptionsGetString(NULL, NULL, "-debug_terminal", string, sizeof(string), &flg1)); 412 if (flg1) PetscCall(PetscSetDebugTerminal(string)); 413 PetscCall(PetscOptionsGetString(NULL, NULL, "-start_in_debugger", string, sizeof(string), &flg1)); 414 PetscCall(PetscOptionsGetString(NULL, NULL, "-stop_for_debugger", string, sizeof(string), &flg2)); 415 if (flg1 || flg2) { 416 PetscMPIInt size; 417 PetscInt lsize, *ranks; 418 MPI_Errhandler err_handler; 419 /* 420 we have to make sure that all processors have opened 421 connections to all other processors, otherwise once the 422 debugger has stated it is likely to receive a SIGUSR1 423 and kill the program. 424 */ 425 PetscCallMPI(MPI_Comm_size(comm, &size)); 426 if (size > 2) { 427 PetscMPIInt dummy = 0; 428 MPI_Status status; 429 for (i = 0; i < size; i++) { 430 if (rank != i) PetscCallMPI(MPI_Send(&dummy, 1, MPI_INT, i, 109, comm)); 431 } 432 for (i = 0; i < size; i++) { 433 if (rank != i) PetscCallMPI(MPI_Recv(&dummy, 1, MPI_INT, i, 109, comm, &status)); 434 } 435 } 436 /* check if this processor node should be in debugger */ 437 PetscCall(PetscMalloc1(size, &ranks)); 438 lsize = size; 439 /* Deprecated in 3.14 */ 440 PetscCall(PetscOptionsGetIntArray(NULL, NULL, "-debugger_nodes", ranks, &lsize, &flag)); 441 if (flag) { 442 const char *const quietopt = "-options_suppress_deprecated_warnings"; 443 char msg[4096]; 444 PetscBool quiet = PETSC_FALSE; 445 446 PetscCall(PetscOptionsGetBool(NULL, NULL, quietopt, &quiet, NULL)); 447 if (!quiet) { 448 PetscCall(PetscStrncpy(msg, "** PETSc DEPRECATION WARNING ** : the option ", sizeof(msg))); 449 PetscCall(PetscStrlcat(msg, "-debugger_nodes", sizeof(msg))); 450 PetscCall(PetscStrlcat(msg, " is deprecated as of version ", sizeof(msg))); 451 PetscCall(PetscStrlcat(msg, "3.14", sizeof(msg))); 452 PetscCall(PetscStrlcat(msg, " and will be removed in a future release.", sizeof(msg))); 453 PetscCall(PetscStrlcat(msg, " Please use the option ", sizeof(msg))); 454 PetscCall(PetscStrlcat(msg, "-debugger_ranks", sizeof(msg))); 455 PetscCall(PetscStrlcat(msg, " instead.", sizeof(msg))); 456 PetscCall(PetscStrlcat(msg, " (Silence this warning with ", sizeof(msg))); 457 PetscCall(PetscStrlcat(msg, quietopt, sizeof(msg))); 458 PetscCall(PetscStrlcat(msg, ")\n", sizeof(msg))); 459 PetscCall(PetscPrintf(comm, "%s", msg)); 460 } 461 } else { 462 lsize = size; 463 PetscCall(PetscOptionsGetIntArray(NULL, NULL, "-debugger_ranks", ranks, &lsize, &flag)); 464 } 465 if (flag) { 466 for (i = 0; i < lsize; i++) { 467 if (ranks[i] == rank) { 468 flag = PETSC_FALSE; 469 break; 470 } 471 } 472 } 473 if (!flag) { 474 PetscCall(PetscSetDebuggerFromString(string)); 475 PetscCall(PetscPushErrorHandler(PetscAbortErrorHandler, NULL)); 476 if (flg1) { 477 PetscCall(PetscAttachDebugger()); 478 } else { 479 PetscCall(PetscStopForDebugger()); 480 } 481 PetscCallMPI(MPI_Comm_create_errhandler(Petsc_MPI_AbortOnError, &err_handler)); 482 PetscCallMPI(MPI_Comm_set_errhandler(comm, err_handler)); 483 } else { 484 PetscCall(PetscWaitOnError()); 485 } 486 PetscCall(PetscFree(ranks)); 487 } 488 489 PetscCall(PetscOptionsGetString(NULL, NULL, "-on_error_emacs", emacsmachinename, sizeof(emacsmachinename), &flg1)); 490 if (flg1 && rank == 0) PetscCall(PetscPushErrorHandler(PetscEmacsClientErrorHandler, emacsmachinename)); 491 492 /* 493 Setup profiling and logging 494 */ 495 #if defined(PETSC_USE_INFO) 496 { 497 PetscCall(PetscInfoSetFromOptions(NULL)); 498 } 499 #endif 500 PetscCall(PetscDetermineInitialFPTrap()); 501 flg1 = PETSC_FALSE; 502 PetscCall(PetscOptionsGetBool(NULL, NULL, "-fp_trap", &flg1, &flag)); 503 if (flag) PetscCall(PetscSetFPTrap(flg1 ? PETSC_FP_TRAP_ON : PETSC_FP_TRAP_OFF)); 504 PetscCall(PetscOptionsGetInt(NULL, NULL, "-check_pointer_intensity", &intensity, &flag)); 505 if (flag) PetscCall(PetscCheckPointerSetIntensity(intensity)); 506 #if defined(PETSC_USE_LOG) 507 mname[0] = 0; 508 PetscCall(PetscOptionsGetString(NULL, NULL, "-history", mname, sizeof(mname), &flg1)); 509 if (flg1) { 510 if (mname[0]) { 511 PetscCall(PetscOpenHistoryFile(mname, &petsc_history)); 512 } else { 513 PetscCall(PetscOpenHistoryFile(NULL, &petsc_history)); 514 } 515 } 516 517 PetscCall(PetscOptionsGetBool(NULL, NULL, "-log_sync", &PetscLogSyncOn, NULL)); 518 519 PetscBool flg3 = PETSC_FALSE; 520 #if defined(PETSC_HAVE_MPE) 521 flg1 = PETSC_FALSE; 522 PetscCall(PetscOptionsHasName(NULL, NULL, "-log_mpe", &flg1)); 523 if (flg1) PetscCall(PetscLogMPEBegin()); 524 #endif 525 flg1 = PETSC_FALSE; 526 PetscCall(PetscOptionsGetBool(NULL, NULL, "-log_all", &flg1, NULL)); 527 PetscCall(PetscOptionsHasName(NULL, NULL, "-log_summary", &flg3)); 528 if (flg1) PetscCall(PetscLogAllBegin()); 529 else if (flg3) PetscCall(PetscLogDefaultBegin()); 530 531 PetscCall(PetscOptionsGetString(NULL, NULL, "-log_trace", mname, sizeof(mname), &flg1)); 532 if (flg1) { 533 char name[PETSC_MAX_PATH_LEN], fname[PETSC_MAX_PATH_LEN]; 534 FILE *file; 535 if (mname[0]) { 536 PetscCall(PetscSNPrintf(name, PETSC_MAX_PATH_LEN, "%s.%d", mname, rank)); 537 PetscCall(PetscFixFilename(name, fname)); 538 file = fopen(fname, "w"); 539 PetscCheck(file, PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Unable to open trace file: %s", fname); 540 } else file = PETSC_STDOUT; 541 PetscCall(PetscLogTraceBegin(file)); 542 } 543 544 PetscCall(PetscOptionsGetViewer(comm, NULL, NULL, "-log_view", NULL, &format, &flg4)); 545 if (flg4) { 546 if (format == PETSC_VIEWER_ASCII_XML || format == PETSC_VIEWER_ASCII_FLAMEGRAPH) { 547 PetscCall(PetscLogNestedBegin()); 548 } else { 549 PetscCall(PetscLogDefaultBegin()); 550 } 551 } 552 if (flg4 && (format == PETSC_VIEWER_ASCII_XML || format == PETSC_VIEWER_ASCII_FLAMEGRAPH)) { 553 PetscReal threshold = PetscRealConstant(0.01); 554 PetscCall(PetscOptionsGetReal(NULL, NULL, "-log_threshold", &threshold, &flg1)); 555 if (flg1) PetscCall(PetscLogSetThreshold((PetscLogDouble)threshold, NULL)); 556 } 557 #endif 558 559 PetscCall(PetscOptionsGetBool(NULL, NULL, "-saws_options", &PetscOptionsPublish, NULL)); 560 PetscCall(PetscOptionsGetBool(NULL, NULL, "-use_gpu_aware_mpi", &use_gpu_aware_mpi, &flg1)); 561 if (!flg1) PetscCall(PetscOptionsGetBool(NULL, NULL, "-sf_use_gpu_aware_mpi", &use_gpu_aware_mpi, &flg1)); // an alias option 562 563 /* 564 Print basic help message 565 */ 566 if (hasHelp) { 567 PetscCall((*PetscHelpPrintf)(comm, "Options for all PETSc programs:\n")); 568 PetscCall((*PetscHelpPrintf)(comm, " -version: prints PETSc version\n")); 569 PetscCall((*PetscHelpPrintf)(comm, " -help intro: prints example description and PETSc version, and exits\n")); 570 PetscCall((*PetscHelpPrintf)(comm, " -help: prints example description, PETSc version, and available options for used routines\n")); 571 PetscCall((*PetscHelpPrintf)(comm, " -on_error_abort: cause an abort when an error is detected. Useful \n ")); 572 PetscCall((*PetscHelpPrintf)(comm, " only when run in the debugger\n")); 573 PetscCall((*PetscHelpPrintf)(comm, " -on_error_attach_debugger [gdb,dbx,xxgdb,ups,noxterm]\n")); 574 PetscCall((*PetscHelpPrintf)(comm, " start the debugger in new xterm\n")); 575 PetscCall((*PetscHelpPrintf)(comm, " unless noxterm is given\n")); 576 PetscCall((*PetscHelpPrintf)(comm, " -start_in_debugger [gdb,dbx,xxgdb,ups,noxterm]\n")); 577 PetscCall((*PetscHelpPrintf)(comm, " start all processes in the debugger\n")); 578 PetscCall((*PetscHelpPrintf)(comm, " -on_error_emacs <machinename>\n")); 579 PetscCall((*PetscHelpPrintf)(comm, " emacs jumps to error file\n")); 580 PetscCall((*PetscHelpPrintf)(comm, " -debugger_ranks [n1,n2,..] Ranks to start in debugger\n")); 581 PetscCall((*PetscHelpPrintf)(comm, " -debugger_pause [m] : delay (in seconds) to attach debugger\n")); 582 PetscCall((*PetscHelpPrintf)(comm, " -stop_for_debugger : prints message on how to attach debugger manually\n")); 583 PetscCall((*PetscHelpPrintf)(comm, " waits the delay for you to attach\n")); 584 PetscCall((*PetscHelpPrintf)(comm, " -display display: Location where X window graphics and debuggers are displayed\n")); 585 PetscCall((*PetscHelpPrintf)(comm, " -no_signal_handler: do not trap error signals\n")); 586 PetscCall((*PetscHelpPrintf)(comm, " -mpi_return_on_error: MPI returns error code, rather than abort on internal error\n")); 587 PetscCall((*PetscHelpPrintf)(comm, " -fp_trap: stop on floating point exceptions\n")); 588 PetscCall((*PetscHelpPrintf)(comm, " note on IBM RS6000 this slows run greatly\n")); 589 PetscCall((*PetscHelpPrintf)(comm, " -malloc_dump <optional filename>: dump list of unfreed memory at conclusion\n")); 590 PetscCall((*PetscHelpPrintf)(comm, " -malloc: use PETSc error checking malloc (deprecated, use -malloc_debug)\n")); 591 PetscCall((*PetscHelpPrintf)(comm, " -malloc no: don't use PETSc error checking malloc (deprecated, use -malloc_debug no)\n")); 592 PetscCall((*PetscHelpPrintf)(comm, " -malloc_info: prints total memory usage (deprecated, use -memory_view\n")); 593 PetscCall((*PetscHelpPrintf)(comm, " -malloc_view <optional filename>: keeps log of all memory allocations, displays in PetscFinalize()\n")); 594 PetscCall((*PetscHelpPrintf)(comm, " -malloc_debug <true or false>: enables or disables extended checking for memory corruption\n")); 595 PetscCall((*PetscHelpPrintf)(comm, " -options_view: dump list of options inputted\n")); 596 PetscCall((*PetscHelpPrintf)(comm, " -options_left: dump list of unused options\n")); 597 PetscCall((*PetscHelpPrintf)(comm, " -options_left no: don't dump list of unused options\n")); 598 PetscCall((*PetscHelpPrintf)(comm, " -tmp tmpdir: alternative /tmp directory\n")); 599 PetscCall((*PetscHelpPrintf)(comm, " -shared_tmp: tmp directory is shared by all processors\n")); 600 PetscCall((*PetscHelpPrintf)(comm, " -not_shared_tmp: each processor has separate tmp directory\n")); 601 PetscCall((*PetscHelpPrintf)(comm, " -memory_view: print memory usage at end of run\n")); 602 #if defined(PETSC_USE_LOG) 603 PetscCall((*PetscHelpPrintf)(comm, " -get_total_flops: total flops over all processors\n")); 604 PetscCall((*PetscHelpPrintf)(comm, " -log_view [:filename:[format]]: logging objects and events\n")); 605 PetscCall((*PetscHelpPrintf)(comm, " -log_trace [filename]: prints trace of all PETSc calls\n")); 606 PetscCall((*PetscHelpPrintf)(comm, " -log_exclude <list,of,classnames>: exclude given classes from logging\n")); 607 #if defined(PETSC_HAVE_DEVICE) 608 PetscCall((*PetscHelpPrintf)(comm, " -log_view_gpu_time: log the GPU time for each and event\n")); 609 #endif 610 #if defined(PETSC_HAVE_MPE) 611 PetscCall((*PetscHelpPrintf)(comm, " -log_mpe: Also create logfile viewable through Jumpshot\n")); 612 #endif 613 #endif 614 #if defined(PETSC_USE_INFO) 615 PetscCall((*PetscHelpPrintf)(comm, " -info [filename][:[~]<list,of,classnames>[:[~]self]]: print verbose information\n")); 616 #endif 617 PetscCall((*PetscHelpPrintf)(comm, " -options_file <file>: reads options from file\n")); 618 PetscCall((*PetscHelpPrintf)(comm, " -options_monitor: monitor options to standard output, including that set previously e.g. in option files\n")); 619 PetscCall((*PetscHelpPrintf)(comm, " -options_monitor_cancel: cancels all hardwired option monitors\n")); 620 PetscCall((*PetscHelpPrintf)(comm, " -petsc_sleep n: sleeps n seconds before running program\n")); 621 } 622 623 #if defined(PETSC_HAVE_POPEN) 624 { 625 char machine[128]; 626 PetscCall(PetscOptionsGetString(NULL, NULL, "-popen_machine", machine, sizeof(machine), &flg1)); 627 if (flg1) PetscCall(PetscPOpenSetMachine(machine)); 628 } 629 #endif 630 631 PetscCall(PetscOptionsGetReal(NULL, NULL, "-petsc_sleep", &si, &flg1)); 632 if (flg1) PetscCall(PetscSleep(si)); 633 PetscFunctionReturn(PETSC_SUCCESS); 634 } 635