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