1 #define PETSC_DESIRE_FEATURE_TEST_MACROS 2 /* 3 This file defines the initialization of PETSc, including PetscInitialize() 4 */ 5 #include <petsc/private/petscimpl.h> /*I "petscsys.h" I*/ 6 #include <petscviewer.h> 7 8 #if !defined(PETSC_HAVE_WINDOWS_COMPILERS) 9 #include <petsc/private/valgrind/valgrind.h> 10 #endif 11 12 #if defined(PETSC_HAVE_FORTRAN) 13 #include <petsc/private/fortranimpl.h> 14 #endif 15 16 #if defined(PETSC_USE_GCOV) 17 EXTERN_C_BEGIN 18 #if defined(PETSC_HAVE___GCOV_DUMP) 19 #define __gcov_flush(x) __gcov_dump(x) 20 #endif 21 void __gcov_flush(void); 22 EXTERN_C_END 23 #endif 24 25 #if defined(PETSC_SERIALIZE_FUNCTIONS) 26 PETSC_INTERN PetscFPT PetscFPTData; 27 PetscFPT PetscFPTData = 0; 28 #endif 29 30 #if PetscDefined(HAVE_SAWS) 31 #include <petscviewersaws.h> 32 #endif 33 34 /* -----------------------------------------------------------------------------------------*/ 35 36 PETSC_INTERN FILE *petsc_history; 37 38 PETSC_INTERN PetscErrorCode PetscInitialize_DynamicLibraries(void); 39 PETSC_INTERN PetscErrorCode PetscFinalize_DynamicLibraries(void); 40 PETSC_INTERN PetscErrorCode PetscSequentialPhaseBegin_Private(MPI_Comm, int); 41 PETSC_INTERN PetscErrorCode PetscSequentialPhaseEnd_Private(MPI_Comm, int); 42 PETSC_INTERN PetscErrorCode PetscCloseHistoryFile(FILE **); 43 44 /* user may set these BEFORE calling PetscInitialize() */ 45 MPI_Comm PETSC_COMM_WORLD = MPI_COMM_NULL; 46 #if PetscDefined(HAVE_MPI_INIT_THREAD) 47 PetscMPIInt PETSC_MPI_THREAD_REQUIRED = MPI_THREAD_FUNNELED; 48 #else 49 PetscMPIInt PETSC_MPI_THREAD_REQUIRED = 0; 50 #endif 51 52 PetscMPIInt Petsc_Counter_keyval = MPI_KEYVAL_INVALID; 53 PetscMPIInt Petsc_InnerComm_keyval = MPI_KEYVAL_INVALID; 54 PetscMPIInt Petsc_OuterComm_keyval = MPI_KEYVAL_INVALID; 55 PetscMPIInt Petsc_ShmComm_keyval = MPI_KEYVAL_INVALID; 56 57 /* 58 Declare and set all the string names of the PETSc enums 59 */ 60 const char *const PetscBools[] = {"FALSE", "TRUE", "PetscBool", "PETSC_", NULL}; 61 const char *const PetscCopyModes[] = {"COPY_VALUES", "OWN_POINTER", "USE_POINTER", "PetscCopyMode", "PETSC_", NULL}; 62 63 PetscBool PetscPreLoadingUsed = PETSC_FALSE; 64 PetscBool PetscPreLoadingOn = PETSC_FALSE; 65 66 PetscInt PetscHotRegionDepth; 67 68 PetscBool PETSC_RUNNING_ON_VALGRIND = PETSC_FALSE; 69 70 #if defined(PETSC_HAVE_THREADSAFETY) 71 PetscSpinlock PetscViewerASCIISpinLockOpen; 72 PetscSpinlock PetscViewerASCIISpinLockStdout; 73 PetscSpinlock PetscViewerASCIISpinLockStderr; 74 PetscSpinlock PetscCommSpinLock; 75 #endif 76 77 /* 78 PetscInitializeNoPointers - Calls PetscInitialize() from C/C++ without the pointers to argc and args 79 80 Collective 81 82 Level: advanced 83 84 Notes: 85 this is called only by the PETSc Julia interface. Even though it might start MPI it sets the flag to 86 indicate that it did NOT start MPI so that the PetscFinalize() does not end MPI, thus allowing PetscInitialize() to 87 be called multiple times from Julia without the problem of trying to initialize MPI more than once. 88 89 Developer Note: Turns off PETSc signal handling to allow Julia to manage signals 90 91 .seealso: `PetscInitialize()`, `PetscInitializeFortran()`, `PetscInitializeNoArguments()` 92 */ 93 PetscErrorCode PetscInitializeNoPointers(int argc, char **args, const char *filename, const char *help) { 94 int myargc = argc; 95 char **myargs = args; 96 97 PetscFunctionBegin; 98 PetscCall(PetscInitialize(&myargc, &myargs, filename, help)); 99 PetscCall(PetscPopSignalHandler()); 100 PetscBeganMPI = PETSC_FALSE; 101 PetscFunctionReturn(0); 102 } 103 104 /* 105 Used by Julia interface to get communicator 106 */ 107 PetscErrorCode PetscGetPETSC_COMM_SELF(MPI_Comm *comm) { 108 PetscFunctionBegin; 109 if (PetscInitializeCalled) PetscValidPointer(comm, 1); 110 *comm = PETSC_COMM_SELF; 111 PetscFunctionReturn(0); 112 } 113 114 /*@C 115 PetscInitializeNoArguments - Calls PetscInitialize() from C/C++ without 116 the command line arguments. 117 118 Collective 119 120 Level: advanced 121 122 .seealso: `PetscInitialize()`, `PetscInitializeFortran()` 123 @*/ 124 PetscErrorCode PetscInitializeNoArguments(void) { 125 int argc = 0; 126 char **args = NULL; 127 128 PetscFunctionBegin; 129 PetscCall(PetscInitialize(&argc, &args, NULL, NULL)); 130 PetscFunctionReturn(0); 131 } 132 133 /*@ 134 PetscInitialized - Determine whether PETSc is initialized. 135 136 Level: beginner 137 138 .seealso: `PetscInitialize()`, `PetscInitializeNoArguments()`, `PetscInitializeFortran()` 139 @*/ 140 PetscErrorCode PetscInitialized(PetscBool *isInitialized) { 141 PetscFunctionBegin; 142 if (PetscInitializeCalled) PetscValidBoolPointer(isInitialized, 1); 143 *isInitialized = PetscInitializeCalled; 144 PetscFunctionReturn(0); 145 } 146 147 /*@ 148 PetscFinalized - Determine whether PetscFinalize() has been called yet 149 150 Level: developer 151 152 .seealso: `PetscInitialize()`, `PetscInitializeNoArguments()`, `PetscInitializeFortran()` 153 @*/ 154 PetscErrorCode PetscFinalized(PetscBool *isFinalized) { 155 PetscFunctionBegin; 156 if (!PetscFinalizeCalled) PetscValidBoolPointer(isFinalized, 1); 157 *isFinalized = PetscFinalizeCalled; 158 PetscFunctionReturn(0); 159 } 160 161 PETSC_INTERN PetscErrorCode PetscOptionsCheckInitial_Private(const char[]); 162 163 /* 164 This function is the MPI reduction operation used to compute the sum of the 165 first half of the datatype and the max of the second half. 166 */ 167 MPI_Op MPIU_MAXSUM_OP = 0; 168 169 PETSC_INTERN void MPIAPI MPIU_MaxSum_Local(void *in, void *out, int *cnt, MPI_Datatype *datatype) { 170 PetscInt *xin = (PetscInt *)in, *xout = (PetscInt *)out, i, count = *cnt; 171 172 PetscFunctionBegin; 173 if (*datatype != MPIU_2INT) { 174 (*PetscErrorPrintf)("Can only handle MPIU_2INT data types"); 175 PETSCABORT(MPI_COMM_SELF, PETSC_ERR_ARG_WRONG); 176 } 177 178 for (i = 0; i < count; i++) { 179 xout[2 * i] = PetscMax(xout[2 * i], xin[2 * i]); 180 xout[2 * i + 1] += xin[2 * i + 1]; 181 } 182 PetscFunctionReturnVoid(); 183 } 184 185 /* 186 Returns the max of the first entry owned by this processor and the 187 sum of the second entry. 188 189 The reason sizes[2*i] contains lengths sizes[2*i+1] contains flag of 1 if length is nonzero 190 is so that the MPIU_MAXSUM_OP() can set TWO values, if we passed in only sizes[i] with lengths 191 there would be no place to store the both needed results. 192 */ 193 PetscErrorCode PetscMaxSum(MPI_Comm comm, const PetscInt sizes[], PetscInt *max, PetscInt *sum) { 194 PetscFunctionBegin; 195 #if defined(PETSC_HAVE_MPI_REDUCE_SCATTER_BLOCK) 196 { 197 struct { 198 PetscInt max, sum; 199 } work; 200 PetscCallMPI(MPI_Reduce_scatter_block((void *)sizes, &work, 1, MPIU_2INT, MPIU_MAXSUM_OP, comm)); 201 *max = work.max; 202 *sum = work.sum; 203 } 204 #else 205 { 206 PetscMPIInt size, rank; 207 struct { 208 PetscInt max, sum; 209 } * work; 210 PetscCallMPI(MPI_Comm_size(comm, &size)); 211 PetscCallMPI(MPI_Comm_rank(comm, &rank)); 212 PetscCall(PetscMalloc1(size, &work)); 213 PetscCall(MPIU_Allreduce((void *)sizes, work, size, MPIU_2INT, MPIU_MAXSUM_OP, comm)); 214 *max = work[rank].max; 215 *sum = work[rank].sum; 216 PetscCall(PetscFree(work)); 217 } 218 #endif 219 PetscFunctionReturn(0); 220 } 221 222 /* ----------------------------------------------------------------------------*/ 223 224 #if defined(PETSC_HAVE_REAL___FLOAT128) || defined(PETSC_USE_REAL___FP16) 225 #if defined(PETSC_HAVE_REAL___FLOAT128) 226 #include <quadmath.h> 227 MPI_Op MPIU_SUM___FLOAT128 = 0; 228 #endif 229 #if defined(PETSC_USE_REAL___FLOAT128) || defined(PETSC_USE_REAL___FP16) 230 MPI_Op MPIU_SUM = 0; 231 #endif 232 233 PETSC_EXTERN void MPIAPI PetscSum_Local(void *in, void *out, PetscMPIInt *cnt, MPI_Datatype *datatype) { 234 PetscInt i, count = *cnt; 235 236 PetscFunctionBegin; 237 if (*datatype == MPIU_REAL) { 238 PetscReal *xin = (PetscReal *)in, *xout = (PetscReal *)out; 239 for (i = 0; i < count; i++) xout[i] += xin[i]; 240 } 241 #if defined(PETSC_HAVE_COMPLEX) 242 else if (*datatype == MPIU_COMPLEX) { 243 PetscComplex *xin = (PetscComplex *)in, *xout = (PetscComplex *)out; 244 for (i = 0; i < count; i++) xout[i] += xin[i]; 245 } 246 #endif 247 #if defined(PETSC_HAVE_REAL___FLOAT128) 248 else if (*datatype == MPIU___FLOAT128) { 249 __float128 *xin = (__float128 *)in, *xout = (__float128 *)out; 250 for (i = 0; i < count; i++) xout[i] += xin[i]; 251 } else if (*datatype == MPIU___COMPLEX128) { 252 __complex128 *xin = (__complex128 *)in, *xout = (__complex128 *)out; 253 for (i = 0; i < count; i++) xout[i] += xin[i]; 254 } 255 #endif 256 else { 257 #if !defined(PETSC_HAVE_REAL___FLOAT128) 258 (*PetscErrorPrintf)("Can only handle MPIU_REAL or MPIU_COMPLEX data types"); 259 #else 260 (*PetscErrorPrintf)("Can only handle MPIU_REAL, MPIU_COMPLEX, MPIU___FLOAT128, or MPIU___COMPLEX128 data types"); 261 #endif 262 PETSCABORT(MPI_COMM_SELF, PETSC_ERR_ARG_WRONG); 263 } 264 PetscFunctionReturnVoid(); 265 } 266 #endif 267 268 #if defined(PETSC_USE_REAL___FLOAT128) || defined(PETSC_USE_REAL___FP16) 269 MPI_Op MPIU_MAX = 0; 270 MPI_Op MPIU_MIN = 0; 271 272 PETSC_EXTERN void MPIAPI PetscMax_Local(void *in, void *out, PetscMPIInt *cnt, MPI_Datatype *datatype) { 273 PetscInt i, count = *cnt; 274 275 PetscFunctionBegin; 276 if (*datatype == MPIU_REAL) { 277 PetscReal *xin = (PetscReal *)in, *xout = (PetscReal *)out; 278 for (i = 0; i < count; i++) xout[i] = PetscMax(xout[i], xin[i]); 279 } 280 #if defined(PETSC_HAVE_COMPLEX) 281 else if (*datatype == MPIU_COMPLEX) { 282 PetscComplex *xin = (PetscComplex *)in, *xout = (PetscComplex *)out; 283 for (i = 0; i < count; i++) { xout[i] = PetscRealPartComplex(xout[i]) < PetscRealPartComplex(xin[i]) ? xin[i] : xout[i]; } 284 } 285 #endif 286 else { 287 (*PetscErrorPrintf)("Can only handle MPIU_REAL or MPIU_COMPLEX data types"); 288 PETSCABORT(MPI_COMM_SELF, PETSC_ERR_ARG_WRONG); 289 } 290 PetscFunctionReturnVoid(); 291 } 292 293 PETSC_EXTERN void MPIAPI PetscMin_Local(void *in, void *out, PetscMPIInt *cnt, MPI_Datatype *datatype) { 294 PetscInt i, count = *cnt; 295 296 PetscFunctionBegin; 297 if (*datatype == MPIU_REAL) { 298 PetscReal *xin = (PetscReal *)in, *xout = (PetscReal *)out; 299 for (i = 0; i < count; i++) xout[i] = PetscMin(xout[i], xin[i]); 300 } 301 #if defined(PETSC_HAVE_COMPLEX) 302 else if (*datatype == MPIU_COMPLEX) { 303 PetscComplex *xin = (PetscComplex *)in, *xout = (PetscComplex *)out; 304 for (i = 0; i < count; i++) { xout[i] = PetscRealPartComplex(xout[i]) > PetscRealPartComplex(xin[i]) ? xin[i] : xout[i]; } 305 } 306 #endif 307 else { 308 (*PetscErrorPrintf)("Can only handle MPIU_REAL or MPIU_SCALAR data (i.e. double or complex) types"); 309 PETSCABORT(MPI_COMM_SELF, PETSC_ERR_ARG_WRONG); 310 } 311 PetscFunctionReturnVoid(); 312 } 313 #endif 314 315 /* 316 Private routine to delete internal tag/name counter storage when a communicator is freed. 317 318 This is called by MPI, not by users. This is called by MPI_Comm_free() when the communicator that has this data as an attribute is freed. 319 320 Note: this is declared extern "C" because it is passed to MPI_Comm_create_keyval() 321 322 */ 323 PETSC_EXTERN PetscMPIInt MPIAPI Petsc_Counter_Attr_Delete_Fn(MPI_Comm comm, PetscMPIInt keyval, void *count_val, void *extra_state) { 324 PetscCommCounter *counter = (PetscCommCounter *)count_val; 325 struct PetscCommStash *comms = counter->comms, *pcomm; 326 327 PetscFunctionBegin; 328 PetscCallMPI(PetscInfo(NULL, "Deleting counter data in an MPI_Comm %ld\n", (long)comm)); 329 PetscCallMPI(PetscFree(counter->iflags)); 330 while (comms) { 331 PetscCallMPI(MPI_Comm_free(&comms->comm)); 332 pcomm = comms; 333 comms = comms->next; 334 PetscCall(PetscFree(pcomm)); 335 } 336 PetscCallMPI(PetscFree(counter)); 337 PetscFunctionReturn(MPI_SUCCESS); 338 } 339 340 /* 341 This is invoked on the outer comm as a result of either PetscCommDestroy() (via MPI_Comm_delete_attr) or when the user 342 calls MPI_Comm_free(). 343 344 This is the only entry point for breaking the links between inner and outer comms. 345 346 This is called by MPI, not by users. This is called when MPI_Comm_free() is called on the communicator. 347 348 Note: this is declared extern "C" because it is passed to MPI_Comm_create_keyval() 349 350 */ 351 PETSC_EXTERN PetscMPIInt MPIAPI Petsc_InnerComm_Attr_Delete_Fn(MPI_Comm comm, PetscMPIInt keyval, void *attr_val, void *extra_state) { 352 union 353 { 354 MPI_Comm comm; 355 void *ptr; 356 } icomm; 357 358 PetscFunctionBegin; 359 if (keyval != Petsc_InnerComm_keyval) SETERRMPI(PETSC_COMM_SELF, PETSC_ERR_ARG_CORRUPT, "Unexpected keyval"); 360 icomm.ptr = attr_val; 361 if (PetscDefined(USE_DEBUG)) { 362 /* Error out if the inner/outer comms are not correctly linked through their Outer/InnterComm attributes */ 363 PetscMPIInt flg; 364 union 365 { 366 MPI_Comm comm; 367 void *ptr; 368 } ocomm; 369 PetscCallMPI(MPI_Comm_get_attr(icomm.comm, Petsc_OuterComm_keyval, &ocomm, &flg)); 370 if (!flg) SETERRMPI(PETSC_COMM_SELF, PETSC_ERR_ARG_CORRUPT, "Inner comm does not have OuterComm attribute"); 371 if (ocomm.comm != comm) SETERRMPI(PETSC_COMM_SELF, PETSC_ERR_ARG_CORRUPT, "Inner comm's OuterComm attribute does not point to outer PETSc comm"); 372 } 373 PetscCallMPI(MPI_Comm_delete_attr(icomm.comm, Petsc_OuterComm_keyval)); 374 PetscCallMPI(PetscInfo(NULL, "User MPI_Comm %ld is being unlinked from inner PETSc comm %ld\n", (long)comm, (long)icomm.comm)); 375 PetscFunctionReturn(MPI_SUCCESS); 376 } 377 378 /* 379 * This is invoked on the inner comm when Petsc_InnerComm_Attr_Delete_Fn calls MPI_Comm_delete_attr(). It should not be reached any other way. 380 */ 381 PETSC_EXTERN PetscMPIInt MPIAPI Petsc_OuterComm_Attr_Delete_Fn(MPI_Comm comm, PetscMPIInt keyval, void *attr_val, void *extra_state) { 382 PetscFunctionBegin; 383 PetscCallMPI(PetscInfo(NULL, "Removing reference to PETSc communicator embedded in a user MPI_Comm %ld\n", (long)comm)); 384 PetscFunctionReturn(MPI_SUCCESS); 385 } 386 387 PETSC_EXTERN PetscMPIInt MPIAPI Petsc_ShmComm_Attr_Delete_Fn(MPI_Comm, PetscMPIInt, void *, void *); 388 389 #if defined(PETSC_USE_PETSC_MPI_EXTERNAL32) 390 PETSC_EXTERN PetscMPIInt PetscDataRep_extent_fn(MPI_Datatype, MPI_Aint *, void *); 391 PETSC_EXTERN PetscMPIInt PetscDataRep_read_conv_fn(void *, MPI_Datatype, PetscMPIInt, void *, MPI_Offset, void *); 392 PETSC_EXTERN PetscMPIInt PetscDataRep_write_conv_fn(void *, MPI_Datatype, PetscMPIInt, void *, MPI_Offset, void *); 393 #endif 394 395 PetscMPIInt PETSC_MPI_ERROR_CLASS = MPI_ERR_LASTCODE, PETSC_MPI_ERROR_CODE; 396 397 PETSC_INTERN int PetscGlobalArgc; 398 PETSC_INTERN char **PetscGlobalArgs; 399 int PetscGlobalArgc = 0; 400 char **PetscGlobalArgs = NULL; 401 PetscSegBuffer PetscCitationsList; 402 403 PetscErrorCode PetscCitationsInitialize(void) { 404 PetscFunctionBegin; 405 PetscCall(PetscSegBufferCreate(1, 10000, &PetscCitationsList)); 406 407 PetscCall(PetscCitationsRegister("@TechReport{petsc-user-ref,\n\ 408 Author = {Satish Balay and Shrirang Abhyankar and Mark~F. Adams and Steven Benson and Jed Brown\n\ 409 and Peter Brune and Kris Buschelman and Emil Constantinescu and Lisandro Dalcin and Alp Dener\n\ 410 and Victor Eijkhout and William~D. Gropp and V\'{a}clav Hapla and Tobin Isaac and Pierre Jolivet\n\ 411 and Dmitry Karpeev and Dinesh Kaushik and Matthew~G. Knepley and Fande Kong and Scott Kruger\n\ 412 and Dave~A. May and Lois Curfman McInnes and Richard Tran Mills and Lawrence Mitchell and Todd Munson\n\ 413 and Jose~E. Roman and Karl Rupp and Patrick Sanan and Jason Sarich and Barry~F. Smith\n\ 414 and Stefano Zampini and Hong Zhang and Hong Zhang and Junchao Zhang},\n\ 415 Title = {{PETSc/TAO} Users Manual},\n\ 416 Number = {ANL-21/39 - Revision 3.17},\n\ 417 Institution = {Argonne National Laboratory},\n\ 418 Year = {2022}\n}\n", 419 NULL)); 420 421 PetscCall(PetscCitationsRegister("@InProceedings{petsc-efficient,\n\ 422 Author = {Satish Balay and William D. Gropp and Lois Curfman McInnes and Barry F. Smith},\n\ 423 Title = {Efficient Management of Parallelism in Object Oriented Numerical Software Libraries},\n\ 424 Booktitle = {Modern Software Tools in Scientific Computing},\n\ 425 Editor = {E. Arge and A. M. Bruaset and H. P. Langtangen},\n\ 426 Pages = {163--202},\n\ 427 Publisher = {Birkh{\\\"{a}}user Press},\n\ 428 Year = {1997}\n}\n", 429 NULL)); 430 431 PetscFunctionReturn(0); 432 } 433 434 static char programname[PETSC_MAX_PATH_LEN] = ""; /* HP includes entire path in name */ 435 436 PetscErrorCode PetscSetProgramName(const char name[]) { 437 PetscFunctionBegin; 438 PetscCall(PetscStrncpy(programname, name, sizeof(programname))); 439 PetscFunctionReturn(0); 440 } 441 442 /*@C 443 PetscGetProgramName - Gets the name of the running program. 444 445 Not Collective 446 447 Input Parameter: 448 . len - length of the string name 449 450 Output Parameter: 451 . name - the name of the running program 452 453 Level: advanced 454 455 Notes: 456 The name of the program is copied into the user-provided character 457 array of length len. On some machines the program name includes 458 its entire path, so one should generally set len >= PETSC_MAX_PATH_LEN. 459 @*/ 460 PetscErrorCode PetscGetProgramName(char name[], size_t len) { 461 PetscFunctionBegin; 462 PetscCall(PetscStrncpy(name, programname, len)); 463 PetscFunctionReturn(0); 464 } 465 466 /*@C 467 PetscGetArgs - Allows you to access the raw command line arguments anywhere 468 after PetscInitialize() is called but before PetscFinalize(). 469 470 Not Collective 471 472 Output Parameters: 473 + argc - count of number of command line arguments 474 - args - the command line arguments 475 476 Level: intermediate 477 478 Notes: 479 This is usually used to pass the command line arguments into other libraries 480 that are called internally deep in PETSc or the application. 481 482 The first argument contains the program name as is normal for C arguments. 483 484 .seealso: `PetscFinalize()`, `PetscInitializeFortran()`, `PetscGetArguments()` 485 486 @*/ 487 PetscErrorCode PetscGetArgs(int *argc, char ***args) { 488 PetscFunctionBegin; 489 PetscCheck(PetscInitializeCalled || !PetscFinalizeCalled, PETSC_COMM_SELF, PETSC_ERR_ORDER, "You must call after PetscInitialize() but before PetscFinalize()"); 490 *argc = PetscGlobalArgc; 491 *args = PetscGlobalArgs; 492 PetscFunctionReturn(0); 493 } 494 495 /*@C 496 PetscGetArguments - Allows you to access the command line arguments anywhere 497 after PetscInitialize() is called but before PetscFinalize(). 498 499 Not Collective 500 501 Output Parameters: 502 . args - the command line arguments 503 504 Level: intermediate 505 506 Notes: 507 This does NOT start with the program name and IS null terminated (final arg is void) 508 509 .seealso: `PetscFinalize()`, `PetscInitializeFortran()`, `PetscGetArgs()`, `PetscFreeArguments()` 510 511 @*/ 512 PetscErrorCode PetscGetArguments(char ***args) { 513 PetscInt i, argc = PetscGlobalArgc; 514 515 PetscFunctionBegin; 516 PetscCheck(PetscInitializeCalled || !PetscFinalizeCalled, PETSC_COMM_SELF, PETSC_ERR_ORDER, "You must call after PetscInitialize() but before PetscFinalize()"); 517 if (!argc) { 518 *args = NULL; 519 PetscFunctionReturn(0); 520 } 521 PetscCall(PetscMalloc1(argc, args)); 522 for (i = 0; i < argc - 1; i++) PetscCall(PetscStrallocpy(PetscGlobalArgs[i + 1], &(*args)[i])); 523 (*args)[argc - 1] = NULL; 524 PetscFunctionReturn(0); 525 } 526 527 /*@C 528 PetscFreeArguments - Frees the memory obtained with PetscGetArguments() 529 530 Not Collective 531 532 Output Parameters: 533 . args - the command line arguments 534 535 Level: intermediate 536 537 .seealso: `PetscFinalize()`, `PetscInitializeFortran()`, `PetscGetArgs()`, `PetscGetArguments()` 538 539 @*/ 540 PetscErrorCode PetscFreeArguments(char **args) { 541 PetscFunctionBegin; 542 if (args) { 543 PetscInt i = 0; 544 545 while (args[i]) PetscCall(PetscFree(args[i++])); 546 PetscCall(PetscFree(args)); 547 } 548 PetscFunctionReturn(0); 549 } 550 551 #if PetscDefined(HAVE_SAWS) 552 #include <petscconfiginfo.h> 553 554 PETSC_INTERN PetscErrorCode PetscInitializeSAWs(const char help[]) { 555 PetscFunctionBegin; 556 if (!PetscGlobalRank) { 557 char cert[PETSC_MAX_PATH_LEN], root[PETSC_MAX_PATH_LEN], *intro, programname[64], *appline, *options, version[64]; 558 int port; 559 PetscBool flg, rootlocal = PETSC_FALSE, flg2, selectport = PETSC_FALSE; 560 size_t applinelen, introlen; 561 char sawsurl[256]; 562 563 PetscCall(PetscOptionsHasName(NULL, NULL, "-saws_log", &flg)); 564 if (flg) { 565 char sawslog[PETSC_MAX_PATH_LEN]; 566 567 PetscCall(PetscOptionsGetString(NULL, NULL, "-saws_log", sawslog, sizeof(sawslog), NULL)); 568 if (sawslog[0]) { 569 PetscCallSAWs(SAWs_Set_Use_Logfile, (sawslog)); 570 } else { 571 PetscCallSAWs(SAWs_Set_Use_Logfile, (NULL)); 572 } 573 } 574 PetscCall(PetscOptionsGetString(NULL, NULL, "-saws_https", cert, sizeof(cert), &flg)); 575 if (flg) { PetscCallSAWs(SAWs_Set_Use_HTTPS, (cert)); } 576 PetscCall(PetscOptionsGetBool(NULL, NULL, "-saws_port_auto_select", &selectport, NULL)); 577 if (selectport) { 578 PetscCallSAWs(SAWs_Get_Available_Port, (&port)); 579 PetscCallSAWs(SAWs_Set_Port, (port)); 580 } else { 581 PetscCall(PetscOptionsGetInt(NULL, NULL, "-saws_port", &port, &flg)); 582 if (flg) { PetscCallSAWs(SAWs_Set_Port, (port)); } 583 } 584 PetscCall(PetscOptionsGetString(NULL, NULL, "-saws_root", root, sizeof(root), &flg)); 585 if (flg) { 586 PetscCallSAWs(SAWs_Set_Document_Root, (root)); 587 PetscCall(PetscStrcmp(root, ".", &rootlocal)); 588 } else { 589 PetscCall(PetscOptionsHasName(NULL, NULL, "-saws_options", &flg)); 590 if (flg) { 591 PetscCall(PetscStrreplace(PETSC_COMM_WORLD, "${PETSC_DIR}/share/petsc/saws", root, sizeof(root))); 592 PetscCallSAWs(SAWs_Set_Document_Root, (root)); 593 } 594 } 595 PetscCall(PetscOptionsHasName(NULL, NULL, "-saws_local", &flg2)); 596 if (flg2) { 597 char jsdir[PETSC_MAX_PATH_LEN]; 598 PetscCheck(flg, PETSC_COMM_SELF, PETSC_ERR_SUP, "-saws_local option requires -saws_root option"); 599 PetscCall(PetscSNPrintf(jsdir, sizeof(jsdir), "%s/js", root)); 600 PetscCall(PetscTestDirectory(jsdir, 'r', &flg)); 601 PetscCheck(flg, PETSC_COMM_SELF, PETSC_ERR_FILE_READ, "-saws_local option requires js directory in root directory"); 602 PetscCallSAWs(SAWs_Push_Local_Header, ()); 603 } 604 PetscCall(PetscGetProgramName(programname, sizeof(programname))); 605 PetscCall(PetscStrlen(help, &applinelen)); 606 introlen = 4096 + applinelen; 607 applinelen += 1024; 608 PetscCall(PetscMalloc(applinelen, &appline)); 609 PetscCall(PetscMalloc(introlen, &intro)); 610 611 if (rootlocal) { 612 PetscCall(PetscSNPrintf(appline, applinelen, "%s.c.html", programname)); 613 PetscCall(PetscTestFile(appline, 'r', &rootlocal)); 614 } 615 PetscCall(PetscOptionsGetAll(NULL, &options)); 616 if (rootlocal && help) { 617 PetscCall(PetscSNPrintf(appline, applinelen, "<center> Running <a href=\"%s.c.html\">%s</a> %s</center><br><center><pre>%s</pre></center><br>\n", programname, programname, options, help)); 618 } else if (help) { 619 PetscCall(PetscSNPrintf(appline, applinelen, "<center>Running %s %s</center><br><center><pre>%s</pre></center><br>", programname, options, help)); 620 } else { 621 PetscCall(PetscSNPrintf(appline, applinelen, "<center> Running %s %s</center><br>\n", programname, options)); 622 } 623 PetscCall(PetscFree(options)); 624 PetscCall(PetscGetVersion(version, sizeof(version))); 625 PetscCall(PetscSNPrintf(intro, introlen, 626 "<body>\n" 627 "<center><h2> <a href=\"https://petsc.org/\">PETSc</a> Application Web server powered by <a href=\"https://bitbucket.org/saws/saws\">SAWs</a> </h2></center>\n" 628 "<center>This is the default PETSc application dashboard, from it you can access any published PETSc objects or logging data</center><br><center>%s configured with %s</center><br>\n" 629 "%s", 630 version, petscconfigureoptions, appline)); 631 PetscCallSAWs(SAWs_Push_Body, ("index.html", 0, intro)); 632 PetscCall(PetscFree(intro)); 633 PetscCall(PetscFree(appline)); 634 if (selectport) { 635 PetscBool silent; 636 637 /* another process may have grabbed the port so keep trying */ 638 while (SAWs_Initialize()) { 639 PetscCallSAWs(SAWs_Get_Available_Port, (&port)); 640 PetscCallSAWs(SAWs_Set_Port, (port)); 641 } 642 643 PetscCall(PetscOptionsGetBool(NULL, NULL, "-saws_port_auto_select_silent", &silent, NULL)); 644 if (!silent) { 645 PetscCallSAWs(SAWs_Get_FullURL, (sizeof(sawsurl), sawsurl)); 646 PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Point your browser to %s for SAWs\n", sawsurl)); 647 } 648 } else { 649 PetscCallSAWs(SAWs_Initialize, ()); 650 } 651 PetscCall(PetscCitationsRegister("@TechReport{ saws,\n" 652 " Author = {Matt Otten and Jed Brown and Barry Smith},\n" 653 " Title = {Scientific Application Web Server (SAWs) Users Manual},\n" 654 " Institution = {Argonne National Laboratory},\n" 655 " Year = 2013\n}\n", 656 NULL)); 657 } 658 PetscFunctionReturn(0); 659 } 660 #endif 661 662 /* Things must be done before MPI_Init() when MPI is not yet initialized, and can be shared between C init and Fortran init */ 663 PETSC_INTERN PetscErrorCode PetscPreMPIInit_Private(void) { 664 PetscFunctionBegin; 665 #if defined(PETSC_HAVE_HWLOC_SOLARIS_BUG) 666 /* see MPI.py for details on this bug */ 667 (void)setenv("HWLOC_COMPONENTS", "-x86", 1); 668 #endif 669 PetscFunctionReturn(0); 670 } 671 672 #if PetscDefined(HAVE_ADIOS) 673 #include <adios.h> 674 #include <adios_read.h> 675 int64_t Petsc_adios_group; 676 #endif 677 #if PetscDefined(HAVE_OPENMP) 678 #include <omp.h> 679 PetscInt PetscNumOMPThreads; 680 #endif 681 682 #if PetscDefined(HAVE_DEVICE) 683 #include <petsc/private/deviceimpl.h> 684 #if PetscDefined(HAVE_CUDA) 685 // REMOVE ME 686 cudaStream_t PetscDefaultCudaStream = NULL; 687 #endif 688 #if PetscDefined(HAVE_HIP) 689 // REMOVE ME 690 hipStream_t PetscDefaultHipStream = NULL; 691 #endif 692 #endif 693 694 #if PetscDefined(HAVE_DLFCN_H) 695 #include <dlfcn.h> 696 #endif 697 #if PetscDefined(USE_LOG) 698 PETSC_INTERN PetscErrorCode PetscLogInitialize(void); 699 #endif 700 #if PetscDefined(HAVE_VIENNACL) 701 PETSC_EXTERN PetscErrorCode PetscViennaCLInit(); 702 PetscBool PetscViennaCLSynchronize = PETSC_FALSE; 703 #endif 704 705 PetscBool PetscCIEnabled = PETSC_FALSE, PetscCIEnabledPortableErrorOutput = PETSC_FALSE; 706 707 /* 708 PetscInitialize_Common - shared code between C and Fortran initialization 709 710 prog: program name 711 file: optional PETSc database file name. Might be in Fortran string format when 'ftn' is true 712 help: program help message 713 ftn: is it called from Fortran initilization (petscinitializef_)? 714 readarguments,len: used when fortran is true 715 */ 716 PETSC_INTERN PetscErrorCode PetscInitialize_Common(const char *prog, const char *file, const char *help, PetscBool ftn, PetscBool readarguments, PetscInt len) { 717 PetscMPIInt size; 718 PetscBool flg = PETSC_TRUE; 719 char hostname[256]; 720 721 PetscFunctionBegin; 722 if (PetscInitializeCalled) PetscFunctionReturn(0); 723 /* these must be initialized in a routine, not as a constant declaration */ 724 PETSC_STDOUT = stdout; 725 PETSC_STDERR = stderr; 726 727 /* PetscCall can be used from now */ 728 PetscErrorHandlingInitialized = PETSC_TRUE; 729 730 /* 731 The checking over compatible runtime libraries is complicated by the MPI ABI initiative 732 https://wiki.mpich.org/mpich/index.php/ABI_Compatibility_Initiative which started with 733 MPICH v3.1 (Released February 2014) 734 IBM MPI v2.1 (December 2014) 735 Intel MPI Library v5.0 (2014) 736 Cray MPT v7.0.0 (June 2014) 737 As of July 31, 2017 the ABI number still appears to be 12, that is all of the versions 738 listed above and since that time are compatible. 739 740 Unfortunately the MPI ABI initiative has not defined a way to determine the ABI number 741 at compile time or runtime. Thus we will need to systematically track the allowed versions 742 and how they are represented in the mpi.h and MPI_Get_library_version() output in order 743 to perform the checking. 744 745 Currently we only check for pre MPI ABI versions (and packages that do not follow the MPI ABI). 746 747 Questions: 748 749 Should the checks for ABI incompatibility be only on the major version number below? 750 Presumably the output to stderr will be removed before a release. 751 */ 752 753 #if defined(PETSC_HAVE_MPI_GET_LIBRARY_VERSION) 754 { 755 char mpilibraryversion[MPI_MAX_LIBRARY_VERSION_STRING]; 756 PetscMPIInt mpilibraryversionlength; 757 758 PetscCallMPI(MPI_Get_library_version(mpilibraryversion, &mpilibraryversionlength)); 759 /* check for MPICH versions before MPI ABI initiative */ 760 #if defined(MPICH_VERSION) 761 #if MPICH_NUMVERSION < 30100000 762 { 763 char *ver, *lf; 764 PetscBool flg = PETSC_FALSE; 765 766 PetscCall(PetscStrstr(mpilibraryversion, "MPICH Version:", &ver)); 767 if (ver) { 768 PetscCall(PetscStrchr(ver, '\n', &lf)); 769 if (lf) { 770 *lf = 0; 771 PetscCall(PetscStrendswith(ver, MPICH_VERSION, &flg)); 772 } 773 } 774 if (!flg) { 775 PetscCall(PetscInfo(NULL, "PETSc warning --- MPICH library version \n%s does not match what PETSc was compiled with %s.\n", mpilibraryversion, MPICH_VERSION)); 776 flg = PETSC_TRUE; 777 } 778 } 779 #endif 780 /* check for OpenMPI version, it is not part of the MPI ABI initiative (is it part of another initiative that needs to be handled?) */ 781 #elif defined(OMPI_MAJOR_VERSION) 782 { 783 char *ver, bs[MPI_MAX_LIBRARY_VERSION_STRING], *bsf; 784 PetscBool flg = PETSC_FALSE; 785 #define PSTRSZ 2 786 char ompistr1[PSTRSZ][MPI_MAX_LIBRARY_VERSION_STRING] = {"Open MPI", "FUJITSU MPI"}; 787 char ompistr2[PSTRSZ][MPI_MAX_LIBRARY_VERSION_STRING] = {"v", "Library "}; 788 int i; 789 for (i = 0; i < PSTRSZ; i++) { 790 PetscCall(PetscStrstr(mpilibraryversion, ompistr1[i], &ver)); 791 if (ver) { 792 PetscCall(PetscSNPrintf(bs, MPI_MAX_LIBRARY_VERSION_STRING, "%s%d.%d", ompistr2[i], OMPI_MAJOR_VERSION, OMPI_MINOR_VERSION)); 793 PetscCall(PetscStrstr(ver, bs, &bsf)); 794 if (bsf) flg = PETSC_TRUE; 795 break; 796 } 797 } 798 if (!flg) { 799 PetscInfo(NULL, "PETSc warning --- Open MPI library version \n%s does not match what PETSc was compiled with %d.%d.\n", mpilibraryversion, OMPI_MAJOR_VERSION, OMPI_MINOR_VERSION); 800 flg = PETSC_TRUE; 801 } 802 } 803 #endif 804 } 805 #endif 806 807 #if PetscDefined(HAVE_DLSYM) && defined(__USE_GNU) 808 /* These symbols are currently in the OpenMPI and MPICH libraries; they may not always be, in that case the test will simply not detect the problem */ 809 PetscCheck(!dlsym(RTLD_DEFAULT, "ompi_mpi_init") || !dlsym(RTLD_DEFAULT, "MPID_Abort"), PETSC_COMM_SELF, PETSC_ERR_MPI_LIB_INCOMP, "Application was linked against both OpenMPI and MPICH based MPI libraries and will not run correctly"); 810 #endif 811 812 /* on Windows - set printf to default to printing 2 digit exponents */ 813 #if defined(PETSC_HAVE__SET_OUTPUT_FORMAT) 814 _set_output_format(_TWO_DIGIT_EXPONENT); 815 #endif 816 817 PetscCall(PetscOptionsCreateDefault()); 818 819 PetscFinalizeCalled = PETSC_FALSE; 820 821 PetscCall(PetscSetProgramName(prog)); 822 PetscCall(PetscSpinlockCreate(&PetscViewerASCIISpinLockOpen)); 823 PetscCall(PetscSpinlockCreate(&PetscViewerASCIISpinLockStdout)); 824 PetscCall(PetscSpinlockCreate(&PetscViewerASCIISpinLockStderr)); 825 PetscCall(PetscSpinlockCreate(&PetscCommSpinLock)); 826 827 if (PETSC_COMM_WORLD == MPI_COMM_NULL) PETSC_COMM_WORLD = MPI_COMM_WORLD; 828 PetscCallMPI(MPI_Comm_set_errhandler(PETSC_COMM_WORLD, MPI_ERRORS_RETURN)); 829 830 if (PETSC_MPI_ERROR_CLASS == MPI_ERR_LASTCODE) { 831 PetscCallMPI(MPI_Add_error_class(&PETSC_MPI_ERROR_CLASS)); 832 PetscCallMPI(MPI_Add_error_code(PETSC_MPI_ERROR_CLASS, &PETSC_MPI_ERROR_CODE)); 833 } 834 835 /* Done after init due to a bug in MPICH-GM? */ 836 PetscCall(PetscErrorPrintfInitialize()); 837 838 PetscCallMPI(MPI_Comm_rank(MPI_COMM_WORLD, &PetscGlobalRank)); 839 PetscCallMPI(MPI_Comm_size(MPI_COMM_WORLD, &PetscGlobalSize)); 840 841 MPIU_BOOL = MPI_INT; 842 MPIU_ENUM = MPI_INT; 843 MPIU_FORTRANADDR = (sizeof(void *) == sizeof(int)) ? MPI_INT : MPIU_INT64; 844 if (sizeof(size_t) == sizeof(unsigned)) MPIU_SIZE_T = MPI_UNSIGNED; 845 else if (sizeof(size_t) == sizeof(unsigned long)) MPIU_SIZE_T = MPI_UNSIGNED_LONG; 846 #if defined(PETSC_SIZEOF_LONG_LONG) 847 else if (sizeof(size_t) == sizeof(unsigned long long)) MPIU_SIZE_T = MPI_UNSIGNED_LONG_LONG; 848 #endif 849 else SETERRQ(PETSC_COMM_WORLD, PETSC_ERR_SUP_SYS, "Could not find MPI type for size_t"); 850 851 /* 852 Initialized the global complex variable; this is because with 853 shared libraries the constructors for global variables 854 are not called; at least on IRIX. 855 */ 856 #if defined(PETSC_HAVE_COMPLEX) 857 { 858 #if defined(PETSC_CLANGUAGE_CXX) && !defined(PETSC_USE_REAL___FLOAT128) 859 PetscComplex ic(0.0, 1.0); 860 PETSC_i = ic; 861 #else 862 PETSC_i = _Complex_I; 863 #endif 864 } 865 #endif /* PETSC_HAVE_COMPLEX */ 866 867 /* 868 Create the PETSc MPI reduction operator that sums of the first 869 half of the entries and maxes the second half. 870 */ 871 PetscCallMPI(MPI_Op_create(MPIU_MaxSum_Local, 1, &MPIU_MAXSUM_OP)); 872 873 #if defined(PETSC_HAVE_REAL___FLOAT128) 874 PetscCallMPI(MPI_Type_contiguous(2, MPI_DOUBLE, &MPIU___FLOAT128)); 875 PetscCallMPI(MPI_Type_commit(&MPIU___FLOAT128)); 876 PetscCallMPI(MPI_Type_contiguous(4, MPI_DOUBLE, &MPIU___COMPLEX128)); 877 PetscCallMPI(MPI_Type_commit(&MPIU___COMPLEX128)); 878 #if !defined(PETSC_USE_REAL___FLOAT128) 879 PetscCallMPI(MPI_Op_create(PetscSum_Local, 1, &MPIU_SUM___FLOAT128)); 880 #endif 881 #endif 882 #if defined(PETSC_USE_REAL___FP16) 883 PetscCallMPI(MPI_Type_contiguous(2, MPI_CHAR, &MPIU___FP16)); 884 PetscCallMPI(MPI_Type_commit(&MPIU___FP16)); 885 #endif 886 887 #if defined(PETSC_USE_REAL___FLOAT128) || defined(PETSC_USE_REAL___FP16) 888 PetscCallMPI(MPI_Op_create(PetscSum_Local, 1, &MPIU_SUM)); 889 PetscCallMPI(MPI_Op_create(PetscMax_Local, 1, &MPIU_MAX)); 890 PetscCallMPI(MPI_Op_create(PetscMin_Local, 1, &MPIU_MIN)); 891 #endif 892 893 PetscCallMPI(MPI_Type_contiguous(2, MPIU_SCALAR, &MPIU_2SCALAR)); 894 PetscCallMPI(MPI_Type_commit(&MPIU_2SCALAR)); 895 896 /* create datatypes used by MPIU_MAXLOC, MPIU_MINLOC and PetscSplitReduction_Op */ 897 #if !defined(PETSC_HAVE_MPIUNI) 898 { 899 struct PetscRealInt { 900 PetscReal v; 901 PetscInt i; 902 }; 903 PetscMPIInt blockSizes[2] = {1, 1}; 904 MPI_Aint blockOffsets[2] = {offsetof(struct PetscRealInt, v), offsetof(struct PetscRealInt, i)}; 905 MPI_Datatype blockTypes[2] = {MPIU_REAL, MPIU_INT}, tmpStruct; 906 907 PetscCallMPI(MPI_Type_create_struct(2, blockSizes, blockOffsets, blockTypes, &tmpStruct)); 908 PetscCallMPI(MPI_Type_create_resized(tmpStruct, 0, sizeof(struct PetscRealInt), &MPIU_REAL_INT)); 909 PetscCallMPI(MPI_Type_free(&tmpStruct)); 910 PetscCallMPI(MPI_Type_commit(&MPIU_REAL_INT)); 911 } 912 { 913 struct PetscScalarInt { 914 PetscScalar v; 915 PetscInt i; 916 }; 917 PetscMPIInt blockSizes[2] = {1, 1}; 918 MPI_Aint blockOffsets[2] = {offsetof(struct PetscScalarInt, v), offsetof(struct PetscScalarInt, i)}; 919 MPI_Datatype blockTypes[2] = {MPIU_SCALAR, MPIU_INT}, tmpStruct; 920 921 PetscCallMPI(MPI_Type_create_struct(2, blockSizes, blockOffsets, blockTypes, &tmpStruct)); 922 PetscCallMPI(MPI_Type_create_resized(tmpStruct, 0, sizeof(struct PetscScalarInt), &MPIU_SCALAR_INT)); 923 PetscCallMPI(MPI_Type_free(&tmpStruct)); 924 PetscCallMPI(MPI_Type_commit(&MPIU_SCALAR_INT)); 925 } 926 #endif 927 928 #if defined(PETSC_USE_64BIT_INDICES) 929 PetscCallMPI(MPI_Type_contiguous(2, MPIU_INT, &MPIU_2INT)); 930 PetscCallMPI(MPI_Type_commit(&MPIU_2INT)); 931 #endif 932 PetscCallMPI(MPI_Type_contiguous(4, MPI_INT, &MPI_4INT)); 933 PetscCallMPI(MPI_Type_commit(&MPI_4INT)); 934 PetscCallMPI(MPI_Type_contiguous(4, MPIU_INT, &MPIU_4INT)); 935 PetscCallMPI(MPI_Type_commit(&MPIU_4INT)); 936 937 /* 938 Attributes to be set on PETSc communicators 939 */ 940 PetscCallMPI(MPI_Comm_create_keyval(MPI_COMM_NULL_COPY_FN, Petsc_Counter_Attr_Delete_Fn, &Petsc_Counter_keyval, (void *)0)); 941 PetscCallMPI(MPI_Comm_create_keyval(MPI_COMM_NULL_COPY_FN, Petsc_InnerComm_Attr_Delete_Fn, &Petsc_InnerComm_keyval, (void *)0)); 942 PetscCallMPI(MPI_Comm_create_keyval(MPI_COMM_NULL_COPY_FN, Petsc_OuterComm_Attr_Delete_Fn, &Petsc_OuterComm_keyval, (void *)0)); 943 PetscCallMPI(MPI_Comm_create_keyval(MPI_COMM_NULL_COPY_FN, Petsc_ShmComm_Attr_Delete_Fn, &Petsc_ShmComm_keyval, (void *)0)); 944 945 #if defined(PETSC_HAVE_FORTRAN) 946 if (ftn) PetscCall(PetscInitFortran_Private(readarguments, file, len)); 947 else 948 #endif 949 PetscCall(PetscOptionsInsert(NULL, &PetscGlobalArgc, &PetscGlobalArgs, file)); 950 951 /* call a second time so it can look in the options database */ 952 PetscCall(PetscErrorPrintfInitialize()); 953 954 /* 955 Check system options and print help 956 */ 957 PetscCall(PetscOptionsCheckInitial_Private(help)); 958 959 /* 960 Initialize PetscDevice and PetscDeviceContext 961 962 Note to any future devs thinking of moving this, proper initialization requires: 963 1. MPI initialized 964 2. Options DB initialized 965 3. Petsc error handling initialized, specifically signal handlers. This expects to set up its own SIGSEV handler via 966 the push/pop interface. 967 */ 968 #if (PetscDefined(HAVE_CUDA) || PetscDefined(HAVE_HIP) || PetscDefined(HAVE_SYCL)) 969 PetscCall(PetscDeviceInitializeFromOptions_Internal(PETSC_COMM_WORLD)); 970 #endif 971 972 #if PetscDefined(HAVE_VIENNACL) 973 flg = PETSC_FALSE; 974 PetscCall(PetscOptionsHasName(NULL, NULL, "-log_summary", &flg)); 975 if (!flg) PetscCall(PetscOptionsHasName(NULL, NULL, "-log_view", &flg)); 976 if (!flg) PetscCall(PetscOptionsGetBool(NULL, NULL, "-viennacl_synchronize", &flg, NULL)); 977 PetscViennaCLSynchronize = flg; 978 PetscCall(PetscViennaCLInit()); 979 #endif 980 981 /* 982 Creates the logging data structures; this is enabled even if logging is not turned on 983 This is the last thing we do before returning to the user code to prevent having the 984 logging numbers contaminated by any startup time associated with MPI 985 */ 986 #if defined(PETSC_USE_LOG) 987 PetscCall(PetscLogInitialize()); 988 #endif 989 990 PetscCall(PetscCitationsInitialize()); 991 992 #if defined(PETSC_HAVE_SAWS) 993 PetscCall(PetscInitializeSAWs(ftn ? NULL : help)); 994 flg = PETSC_FALSE; 995 PetscCall(PetscOptionsHasName(NULL, NULL, "-stack_view", &flg)); 996 if (flg) PetscCall(PetscStackViewSAWs()); 997 #endif 998 999 /* 1000 Load the dynamic libraries (on machines that support them), this registers all 1001 the solvers etc. (On non-dynamic machines this initializes the PetscDraw and PetscViewer classes) 1002 */ 1003 PetscCall(PetscInitialize_DynamicLibraries()); 1004 1005 PetscCallMPI(MPI_Comm_size(PETSC_COMM_WORLD, &size)); 1006 PetscCall(PetscInfo(NULL, "PETSc successfully started: number of processors = %d\n", size)); 1007 PetscCall(PetscGetHostName(hostname, 256)); 1008 PetscCall(PetscInfo(NULL, "Running on machine: %s\n", hostname)); 1009 #if defined(PETSC_HAVE_OPENMP) 1010 { 1011 PetscBool omp_view_flag; 1012 char *threads = getenv("OMP_NUM_THREADS"); 1013 1014 if (threads) { 1015 PetscCall(PetscInfo(NULL, "Number of OpenMP threads %s (as given by OMP_NUM_THREADS)\n", threads)); 1016 (void)sscanf(threads, "%" PetscInt_FMT, &PetscNumOMPThreads); 1017 } else { 1018 PetscNumOMPThreads = (PetscInt)omp_get_max_threads(); 1019 PetscCall(PetscInfo(NULL, "Number of OpenMP threads %" PetscInt_FMT " (as given by omp_get_max_threads())\n", PetscNumOMPThreads)); 1020 } 1021 PetscOptionsBegin(PETSC_COMM_WORLD, NULL, "OpenMP options", "Sys"); 1022 PetscCall(PetscOptionsInt("-omp_num_threads", "Number of OpenMP threads to use (can also use environmental variable OMP_NUM_THREADS", "None", PetscNumOMPThreads, &PetscNumOMPThreads, &flg)); 1023 PetscCall(PetscOptionsName("-omp_view", "Display OpenMP number of threads", NULL, &omp_view_flag)); 1024 PetscOptionsEnd(); 1025 if (flg) { 1026 PetscCall(PetscInfo(NULL, "Number of OpenMP theads %" PetscInt_FMT " (given by -omp_num_threads)\n", PetscNumOMPThreads)); 1027 omp_set_num_threads((int)PetscNumOMPThreads); 1028 } 1029 if (omp_view_flag) { PetscCall(PetscPrintf(PETSC_COMM_WORLD, "OpenMP: number of threads %" PetscInt_FMT "\n", PetscNumOMPThreads)); } 1030 } 1031 #endif 1032 1033 #if defined(PETSC_USE_PETSC_MPI_EXTERNAL32) 1034 /* 1035 Tell MPI about our own data representation converter, this would/should be used if extern32 is not supported by the MPI 1036 1037 Currently not used because it is not supported by MPICH. 1038 */ 1039 if (!PetscBinaryBigEndian()) PetscCallMPI(MPI_Register_datarep((char *)"petsc", PetscDataRep_read_conv_fn, PetscDataRep_write_conv_fn, PetscDataRep_extent_fn, NULL)); 1040 #endif 1041 1042 #if defined(PETSC_SERIALIZE_FUNCTIONS) 1043 PetscCall(PetscFPTCreate(10000)); 1044 #endif 1045 1046 #if defined(PETSC_HAVE_HWLOC) 1047 { 1048 PetscViewer viewer; 1049 PetscCall(PetscOptionsGetViewer(PETSC_COMM_WORLD, NULL, NULL, "-process_view", &viewer, NULL, &flg)); 1050 if (flg) { 1051 PetscCall(PetscProcessPlacementView(viewer)); 1052 PetscCall(PetscViewerDestroy(&viewer)); 1053 } 1054 } 1055 #endif 1056 1057 flg = PETSC_TRUE; 1058 PetscCall(PetscOptionsGetBool(NULL, NULL, "-viewfromoptions", &flg, NULL)); 1059 if (!flg) PetscCall(PetscOptionsPushGetViewerOff(PETSC_TRUE)); 1060 1061 #if defined(PETSC_HAVE_ADIOS) 1062 PetscCall(adios_init_noxml(PETSC_COMM_WORLD)); 1063 PetscCall(adios_declare_group(&Petsc_adios_group, "PETSc", "", adios_stat_default)); 1064 PetscCall(adios_select_method(Petsc_adios_group, "MPI", "", "")); 1065 PetscCall(adios_read_init_method(ADIOS_READ_METHOD_BP, PETSC_COMM_WORLD, "")); 1066 #endif 1067 1068 #if defined(__VALGRIND_H) 1069 PETSC_RUNNING_ON_VALGRIND = RUNNING_ON_VALGRIND ? PETSC_TRUE : PETSC_FALSE; 1070 #if defined(PETSC_USING_DARWIN) && defined(PETSC_BLASLAPACK_SDOT_RETURNS_DOUBLE) 1071 if (PETSC_RUNNING_ON_VALGRIND) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "WARNING: Running valgrind with the MacOS native BLAS and LAPACK can fail. If it fails suggest configuring with --download-fblaslapack or --download-f2cblaslapack")); 1072 #endif 1073 #endif 1074 /* 1075 Set flag that we are completely initialized 1076 */ 1077 PetscInitializeCalled = PETSC_TRUE; 1078 1079 PetscCall(PetscOptionsHasName(NULL, NULL, "-python", &flg)); 1080 if (flg) PetscCall(PetscPythonInitialize(NULL, NULL)); 1081 1082 PetscCall(PetscOptionsHasName(NULL, NULL, "-mpi_linear_solver_server", &flg)); 1083 if (PetscDefined(USE_SINGLE_LIBRARY) && flg) PetscCall(PCMPIServerBegin()); 1084 else PetscCheck(!flg, PETSC_COMM_WORLD, PETSC_ERR_SUP, "PETSc configured using -with-single-library=0; -mpi_linear_solver_server not supported in that case"); 1085 PetscFunctionReturn(0); 1086 } 1087 1088 /*@C 1089 PetscInitialize - Initializes the PETSc database and MPI. 1090 PetscInitialize() calls MPI_Init() if that has yet to be called, 1091 so this routine should always be called near the beginning of 1092 your program -- usually the very first line! 1093 1094 Collective on MPI_COMM_WORLD or PETSC_COMM_WORLD if it has been set 1095 1096 Input Parameters: 1097 + argc - count of number of command line arguments 1098 . args - the command line arguments 1099 . file - [optional] PETSc database file, append ":yaml" to filename to specify YAML options format. 1100 Use NULL or empty string to not check for code specific file. 1101 Also checks ~/.petscrc, .petscrc and petscrc. 1102 Use -skip_petscrc in the code specific file (or command line) to skip ~/.petscrc, .petscrc and petscrc files. 1103 - help - [optional] Help message to print, use NULL for no message 1104 1105 If you wish PETSc code to run ONLY on a subcommunicator of MPI_COMM_WORLD, create that 1106 communicator first and assign it to PETSC_COMM_WORLD BEFORE calling PetscInitialize(). Thus if you are running a 1107 four process job and two processes will run PETSc and have PetscInitialize() and PetscFinalize() and two process will not, 1108 then do this. If ALL processes in the job are using PetscInitialize() and PetscFinalize() then you don't need to do this, even 1109 if different subcommunicators of the job are doing different things with PETSc. 1110 1111 Options Database Keys: 1112 + -help [intro] - prints help method for each option; if intro is given the program stops after printing the introductory help message 1113 . -start_in_debugger [noxterm,dbx,xdb,gdb,...] - Starts program in debugger 1114 . -on_error_attach_debugger [noxterm,dbx,xdb,gdb,...] - Starts debugger when error detected 1115 . -on_error_emacs <machinename> - causes emacsclient to jump to error file 1116 . -on_error_abort - calls abort() when error detected (no traceback) 1117 . -on_error_mpiabort - calls MPI_abort() when error detected 1118 . -error_output_stdout - prints PETSc error messages to stdout instead of the default stderr 1119 . -error_output_none - does not print the error messages (but handles errors in the same way as if this was not called) 1120 . -debugger_ranks [rank1,rank2,...] - Indicates ranks to start in debugger 1121 . -debugger_pause [sleeptime] (in seconds) - Pauses debugger 1122 . -stop_for_debugger - Print message on how to attach debugger manually to 1123 process and wait (-debugger_pause) seconds for attachment 1124 . -malloc - Indicates use of PETSc error-checking malloc (on by default for debug version of libraries) (deprecated, use -malloc_debug) 1125 . -malloc no - Indicates not to use error-checking malloc (deprecated, use -malloc_debug no) 1126 . -malloc_debug - check for memory corruption at EVERY malloc or free, see PetscMallocSetDebug() 1127 . -malloc_dump - prints a list of all unfreed memory at the end of the run 1128 . -malloc_test - like -malloc_dump -malloc_debug, but only active for debugging builds, ignored in optimized build. May want to set in PETSC_OPTIONS environmental variable 1129 . -malloc_view - show a list of all allocated memory during PetscFinalize() 1130 . -malloc_view_threshold <t> - only list memory allocations of size greater than t with -malloc_view 1131 . -malloc_requested_size - malloc logging will record the requested size rather than size after alignment 1132 . -fp_trap - Stops on floating point exceptions 1133 . -no_signal_handler - Indicates not to trap error signals 1134 . -shared_tmp - indicates /tmp directory is shared by all processors 1135 . -not_shared_tmp - each processor has own /tmp 1136 . -tmp - alternative name of /tmp directory 1137 . -get_total_flops - returns total flops done by all processors 1138 - -memory_view - Print memory usage at end of run 1139 1140 Options Database Keys for Option Database: 1141 + -skip_petscrc - skip the default option files ~/.petscrc, .petscrc, petscrc 1142 . -options_monitor - monitor all set options to standard output for the whole program run 1143 - -options_monitor_cancel - cancel options monitoring hard-wired using PetscOptionsMonitorSet() 1144 1145 Options -options_monitor_{all,cancel} are 1146 position-independent and apply to all options set since the PETSc start. 1147 They can be used also in option files. 1148 1149 See PetscOptionsMonitorSet() to do monitoring programmatically. 1150 1151 Options Database Keys for Profiling: 1152 See Users-Manual: ch_profiling for details. 1153 + -info [filename][:[~]<list,of,classnames>[:[~]self]] - Prints verbose information. See PetscInfo(). 1154 . -log_sync - Enable barrier synchronization for all events. This option is useful to debug imbalance within each event, 1155 however it slows things down and gives a distorted view of the overall runtime. 1156 . -log_trace [filename] - Print traces of all PETSc calls to the screen (useful to determine where a program 1157 hangs without running in the debugger). See PetscLogTraceBegin(). 1158 . -log_view [:filename:format] - Prints summary of flop and timing information to screen or file, see PetscLogView(). 1159 . -log_view_memory - Includes in the summary from -log_view the memory used in each event, see PetscLogView(). 1160 . -log_view_gpu_time - Includes in the summary from -log_view the time used in each GPU kernel, see PetscLogView(). 1161 . -log_summary [filename] - (Deprecated, use -log_view) Prints summary of flop and timing information to screen. If the filename is specified the 1162 summary is written to the file. See PetscLogView(). 1163 . -log_exclude: <vec,mat,pc,ksp,snes> - excludes subset of object classes from logging 1164 . -log_all [filename] - Logs extensive profiling information See PetscLogDump(). 1165 . -log [filename] - Logs basic profiline information See PetscLogDump(). 1166 . -log_mpe [filename] - Creates a logfile viewable by the utility Jumpshot (in MPICH distribution) 1167 . -viewfromoptions on,off - Enable or disable XXXSetFromOptions() calls, for applications with many small solves turn this off 1168 - -check_pointer_intensity 0,1,2 - if pointers are checked for validity (debug version only), using 0 will result in faster code 1169 1170 Only one of -log_trace, -log_view, -log_all, -log, or -log_mpe may be used at a time 1171 1172 Options Database Keys for SAWs: 1173 + -saws_port <portnumber> - port number to publish SAWs data, default is 8080 1174 . -saws_port_auto_select - have SAWs select a new unique port number where it publishes the data, the URL is printed to the screen 1175 this is useful when you are running many jobs that utilize SAWs at the same time 1176 . -saws_log <filename> - save a log of all SAWs communication 1177 . -saws_https <certificate file> - have SAWs use HTTPS instead of HTTP 1178 - -saws_root <directory> - allow SAWs to have access to the given directory to search for requested resources and files 1179 1180 Environmental Variables: 1181 + PETSC_TMP - alternative tmp directory 1182 . PETSC_SHARED_TMP - tmp is shared by all processes 1183 . PETSC_NOT_SHARED_TMP - each process has its own private tmp 1184 . PETSC_OPTIONS - a string containing additional options for petsc in the form of command line "-key value" pairs 1185 . PETSC_OPTIONS_YAML - (requires configuring PETSc to use libyaml) a string containing additional options for petsc in the form of a YAML document 1186 . PETSC_VIEWER_SOCKET_PORT - socket number to use for socket viewer 1187 - PETSC_VIEWER_SOCKET_MACHINE - machine to use for socket viewer to connect to 1188 1189 Level: beginner 1190 1191 Notes: 1192 If for some reason you must call MPI_Init() separately, call 1193 it before PetscInitialize(). 1194 1195 Fortran Version: 1196 In Fortran this routine has the format 1197 $ call PetscInitialize(file,ierr) 1198 1199 + ierr - error return code 1200 - file - [optional] PETSc database file, also checks ~/.petscrc, .petscrc and petscrc. 1201 Use PETSC_NULL_CHARACTER to not check for code specific file. 1202 Use -skip_petscrc in the code specific file (or command line) to skip ~/.petscrc, .petscrc and petscrc files. 1203 1204 Important Fortran Note: 1205 In Fortran, you MUST use PETSC_NULL_CHARACTER to indicate a 1206 null character string; you CANNOT just use NULL as 1207 in the C version. See Users-Manual: ch_fortran for details. 1208 1209 If your main program is C but you call Fortran code that also uses PETSc you need to call PetscInitializeFortran() soon after 1210 calling PetscInitialize(). 1211 1212 .seealso: `PetscFinalize()`, `PetscInitializeFortran()`, `PetscGetArgs()`, `PetscInitializeNoArguments()`, `PetscLogGpuTime()` 1213 1214 @*/ 1215 PetscErrorCode PetscInitialize(int *argc, char ***args, const char file[], const char help[]) { 1216 PetscMPIInt flag; 1217 const char *prog = "Unknown Name", *mpienv; 1218 1219 PetscFunctionBegin; 1220 if (PetscInitializeCalled) PetscFunctionReturn(0); 1221 PetscCallMPI(MPI_Initialized(&flag)); 1222 if (!flag) { 1223 PetscCheck(PETSC_COMM_WORLD == MPI_COMM_NULL, PETSC_COMM_SELF, PETSC_ERR_SUP, "You cannot set PETSC_COMM_WORLD if you have not initialized MPI first"); 1224 PetscCall(PetscPreMPIInit_Private()); 1225 #if defined(PETSC_HAVE_MPI_INIT_THREAD) 1226 { 1227 PetscMPIInt PETSC_UNUSED provided; 1228 PetscCallMPI(MPI_Init_thread(argc, args, PETSC_MPI_THREAD_REQUIRED, &provided)); 1229 } 1230 #else 1231 PetscCallMPI(MPI_Init(argc, args)); 1232 #endif 1233 if (PetscDefined(HAVE_MPIUNI)) { 1234 mpienv = getenv("PMI_SIZE"); 1235 if (!mpienv) mpienv = getenv("OMPI_COMM_WORLD_SIZE"); 1236 if (mpienv) { 1237 PetscInt isize; 1238 PetscCall(PetscOptionsStringToInt(mpienv, &isize)); 1239 if (isize != 1) printf("You are using an MPI-uni (sequential) install of PETSc but trying to launch parallel jobs; you need full MPI version of PETSc\n"); 1240 PetscCheck(isize == 1, MPI_COMM_SELF, PETSC_ERR_MPI, "You are using an MPI-uni (sequential) install of PETSc but trying to launch parallel jobs; you need full MPI version of PETSc"); 1241 } 1242 } 1243 PetscBeganMPI = PETSC_TRUE; 1244 } 1245 1246 if (argc && *argc) prog = **args; 1247 if (argc && args) { 1248 PetscGlobalArgc = *argc; 1249 PetscGlobalArgs = *args; 1250 } 1251 PetscCall(PetscInitialize_Common(prog, file, help, PETSC_FALSE /*C*/, PETSC_FALSE, 0)); 1252 PetscFunctionReturn(0); 1253 } 1254 1255 #if PetscDefined(USE_LOG) 1256 PETSC_INTERN PetscObject *PetscObjects; 1257 PETSC_INTERN PetscInt PetscObjectsCounts; 1258 PETSC_INTERN PetscInt PetscObjectsMaxCounts; 1259 PETSC_INTERN PetscBool PetscObjectsLog; 1260 #endif 1261 1262 /* 1263 Frees all the MPI types and operations that PETSc may have created 1264 */ 1265 PetscErrorCode PetscFreeMPIResources(void) { 1266 PetscFunctionBegin; 1267 #if defined(PETSC_HAVE_REAL___FLOAT128) 1268 PetscCallMPI(MPI_Type_free(&MPIU___FLOAT128)); 1269 PetscCallMPI(MPI_Type_free(&MPIU___COMPLEX128)); 1270 #if !defined(PETSC_USE_REAL___FLOAT128) 1271 PetscCallMPI(MPI_Op_free(&MPIU_SUM___FLOAT128)); 1272 #endif 1273 #endif 1274 #if defined(PETSC_USE_REAL___FP16) 1275 PetscCallMPI(MPI_Type_free(&MPIU___FP16)); 1276 #endif 1277 1278 #if defined(PETSC_USE_REAL___FLOAT128) || defined(PETSC_USE_REAL___FP16) 1279 PetscCallMPI(MPI_Op_free(&MPIU_SUM)); 1280 PetscCallMPI(MPI_Op_free(&MPIU_MAX)); 1281 PetscCallMPI(MPI_Op_free(&MPIU_MIN)); 1282 #endif 1283 1284 PetscCallMPI(MPI_Type_free(&MPIU_2SCALAR)); 1285 PetscCallMPI(MPI_Type_free(&MPIU_REAL_INT)); 1286 PetscCallMPI(MPI_Type_free(&MPIU_SCALAR_INT)); 1287 #if defined(PETSC_USE_64BIT_INDICES) 1288 PetscCallMPI(MPI_Type_free(&MPIU_2INT)); 1289 #endif 1290 PetscCallMPI(MPI_Type_free(&MPI_4INT)); 1291 PetscCallMPI(MPI_Type_free(&MPIU_4INT)); 1292 PetscCallMPI(MPI_Op_free(&MPIU_MAXSUM_OP)); 1293 PetscFunctionReturn(0); 1294 } 1295 1296 #if PetscDefined(USE_LOG) 1297 PETSC_INTERN PetscErrorCode PetscLogFinalize(void); 1298 #endif 1299 1300 /*@C 1301 PetscFinalize - Checks for options to be called at the conclusion 1302 of the program. MPI_Finalize() is called only if the user had not 1303 called MPI_Init() before calling PetscInitialize(). 1304 1305 Collective on PETSC_COMM_WORLD 1306 1307 Options Database Keys: 1308 + -options_view - Calls PetscOptionsView() 1309 . -options_left - Prints unused options that remain in the database 1310 . -objects_dump [all] - Prints list of objects allocated by the user that have not been freed, the option all cause all outstanding objects to be listed 1311 . -mpidump - Calls PetscMPIDump() 1312 . -malloc_dump <optional filename> - Calls PetscMallocDump(), displays all memory allocated that has not been freed 1313 . -malloc_info - Prints total memory usage 1314 - -malloc_view <optional filename> - Prints list of all memory allocated and where 1315 1316 Level: beginner 1317 1318 Note: 1319 See PetscInitialize() for more general runtime options. 1320 1321 .seealso: `PetscInitialize()`, `PetscOptionsView()`, `PetscMallocDump()`, `PetscMPIDump()`, `PetscEnd()` 1322 @*/ 1323 PetscErrorCode PetscFinalize(void) { 1324 PetscMPIInt rank; 1325 PetscInt nopt; 1326 PetscBool flg1 = PETSC_FALSE, flg2 = PETSC_FALSE, flg3 = PETSC_FALSE; 1327 PetscBool flg; 1328 #if defined(PETSC_USE_LOG) 1329 char mname[PETSC_MAX_PATH_LEN]; 1330 #endif 1331 1332 PetscFunctionBegin; 1333 PetscCheck(PetscInitializeCalled, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONGSTATE, "PetscInitialize() must be called before PetscFinalize()"); 1334 PetscCall(PetscInfo(NULL, "PetscFinalize() called\n")); 1335 1336 PetscCall(PetscOptionsHasName(NULL, NULL, "-mpi_linear_solver_server", &flg)); 1337 if (PetscDefined(USE_SINGLE_LIBRARY) && flg) PetscCall(PCMPIServerEnd()); 1338 1339 PetscCallMPI(MPI_Comm_rank(PETSC_COMM_WORLD, &rank)); 1340 #if defined(PETSC_HAVE_ADIOS) 1341 PetscCall(adios_read_finalize_method(ADIOS_READ_METHOD_BP_AGGREGATE)); 1342 PetscCall(adios_finalize(rank)); 1343 #endif 1344 PetscCall(PetscOptionsHasName(NULL, NULL, "-citations", &flg)); 1345 if (flg) { 1346 char *cits, filename[PETSC_MAX_PATH_LEN]; 1347 FILE *fd = PETSC_STDOUT; 1348 1349 PetscCall(PetscOptionsGetString(NULL, NULL, "-citations", filename, sizeof(filename), NULL)); 1350 if (filename[0]) { PetscCall(PetscFOpen(PETSC_COMM_WORLD, filename, "w", &fd)); } 1351 PetscCall(PetscSegBufferGet(PetscCitationsList, 1, &cits)); 1352 cits[0] = 0; 1353 PetscCall(PetscSegBufferExtractAlloc(PetscCitationsList, &cits)); 1354 PetscCall(PetscFPrintf(PETSC_COMM_WORLD, fd, "If you publish results based on this computation please cite the following:\n")); 1355 PetscCall(PetscFPrintf(PETSC_COMM_WORLD, fd, "===========================================================================\n")); 1356 PetscCall(PetscFPrintf(PETSC_COMM_WORLD, fd, "%s", cits)); 1357 PetscCall(PetscFPrintf(PETSC_COMM_WORLD, fd, "===========================================================================\n")); 1358 PetscCall(PetscFClose(PETSC_COMM_WORLD, fd)); 1359 PetscCall(PetscFree(cits)); 1360 } 1361 PetscCall(PetscSegBufferDestroy(&PetscCitationsList)); 1362 1363 #if defined(PETSC_HAVE_SSL) && defined(PETSC_USE_SOCKET_VIEWER) 1364 /* TextBelt is run for testing purposes only, please do not use this feature often */ 1365 { 1366 PetscInt nmax = 2; 1367 char **buffs; 1368 PetscCall(PetscMalloc1(2, &buffs)); 1369 PetscCall(PetscOptionsGetStringArray(NULL, NULL, "-textbelt", buffs, &nmax, &flg1)); 1370 if (flg1) { 1371 PetscCheck(nmax, PETSC_COMM_WORLD, PETSC_ERR_USER, "-textbelt requires either the phone number or number,\"message\""); 1372 if (nmax == 1) { 1373 PetscCall(PetscMalloc1(128, &buffs[1])); 1374 PetscCall(PetscGetProgramName(buffs[1], 32)); 1375 PetscCall(PetscStrcat(buffs[1], " has completed")); 1376 } 1377 PetscCall(PetscTextBelt(PETSC_COMM_WORLD, buffs[0], buffs[1], NULL)); 1378 PetscCall(PetscFree(buffs[0])); 1379 PetscCall(PetscFree(buffs[1])); 1380 } 1381 PetscCall(PetscFree(buffs)); 1382 } 1383 { 1384 PetscInt nmax = 2; 1385 char **buffs; 1386 PetscCall(PetscMalloc1(2, &buffs)); 1387 PetscCall(PetscOptionsGetStringArray(NULL, NULL, "-tellmycell", buffs, &nmax, &flg1)); 1388 if (flg1) { 1389 PetscCheck(nmax, PETSC_COMM_WORLD, PETSC_ERR_USER, "-tellmycell requires either the phone number or number,\"message\""); 1390 if (nmax == 1) { 1391 PetscCall(PetscMalloc1(128, &buffs[1])); 1392 PetscCall(PetscGetProgramName(buffs[1], 32)); 1393 PetscCall(PetscStrcat(buffs[1], " has completed")); 1394 } 1395 PetscCall(PetscTellMyCell(PETSC_COMM_WORLD, buffs[0], buffs[1], NULL)); 1396 PetscCall(PetscFree(buffs[0])); 1397 PetscCall(PetscFree(buffs[1])); 1398 } 1399 PetscCall(PetscFree(buffs)); 1400 } 1401 #endif 1402 1403 #if defined(PETSC_SERIALIZE_FUNCTIONS) 1404 PetscCall(PetscFPTDestroy()); 1405 #endif 1406 1407 #if defined(PETSC_HAVE_SAWS) 1408 flg = PETSC_FALSE; 1409 PetscCall(PetscOptionsGetBool(NULL, NULL, "-saw_options", &flg, NULL)); 1410 if (flg) PetscCall(PetscOptionsSAWsDestroy()); 1411 #endif 1412 1413 #if defined(PETSC_HAVE_X) 1414 flg1 = PETSC_FALSE; 1415 PetscCall(PetscOptionsGetBool(NULL, NULL, "-x_virtual", &flg1, NULL)); 1416 if (flg1) { 1417 /* this is a crude hack, but better than nothing */ 1418 PetscCall(PetscPOpen(PETSC_COMM_WORLD, NULL, "pkill -9 Xvfb", "r", NULL)); 1419 } 1420 #endif 1421 1422 #if !defined(PETSC_HAVE_THREADSAFETY) 1423 PetscCall(PetscOptionsGetBool(NULL, NULL, "-malloc_info", &flg2, NULL)); 1424 if (!flg2) { 1425 flg2 = PETSC_FALSE; 1426 PetscCall(PetscOptionsGetBool(NULL, NULL, "-memory_view", &flg2, NULL)); 1427 } 1428 if (flg2) { PetscCall(PetscMemoryView(PETSC_VIEWER_STDOUT_WORLD, "Summary of Memory Usage in PETSc\n")); } 1429 #endif 1430 1431 #if defined(PETSC_USE_LOG) 1432 flg1 = PETSC_FALSE; 1433 PetscCall(PetscOptionsGetBool(NULL, NULL, "-get_total_flops", &flg1, NULL)); 1434 if (flg1) { 1435 PetscLogDouble flops = 0; 1436 PetscCallMPI(MPI_Reduce(&petsc_TotalFlops, &flops, 1, MPI_DOUBLE, MPI_SUM, 0, PETSC_COMM_WORLD)); 1437 PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Total flops over all processors %g\n", flops)); 1438 } 1439 #endif 1440 1441 #if defined(PETSC_USE_LOG) 1442 #if defined(PETSC_HAVE_MPE) 1443 mname[0] = 0; 1444 PetscCall(PetscOptionsGetString(NULL, NULL, "-log_mpe", mname, sizeof(mname), &flg1)); 1445 if (flg1) { 1446 if (mname[0]) PetscCall(PetscLogMPEDump(mname)); 1447 else PetscCall(PetscLogMPEDump(0)); 1448 } 1449 #endif 1450 #endif 1451 1452 /* 1453 Free all objects registered with PetscObjectRegisterDestroy() such as PETSC_VIEWER_XXX_(). 1454 */ 1455 PetscCall(PetscObjectRegisterDestroyAll()); 1456 1457 #if defined(PETSC_USE_LOG) 1458 PetscCall(PetscOptionsPushGetViewerOff(PETSC_FALSE)); 1459 PetscCall(PetscLogViewFromOptions()); 1460 PetscCall(PetscOptionsPopGetViewerOff()); 1461 1462 mname[0] = 0; 1463 PetscCall(PetscOptionsGetString(NULL, NULL, "-log_summary", mname, sizeof(mname), &flg1)); 1464 if (flg1) { 1465 PetscViewer viewer; 1466 PetscCall((*PetscHelpPrintf)(PETSC_COMM_WORLD, "\n\n WARNING: -log_summary is being deprecated; switch to -log_view\n\n\n")); 1467 if (mname[0]) { 1468 PetscCall(PetscViewerASCIIOpen(PETSC_COMM_WORLD, mname, &viewer)); 1469 PetscCall(PetscLogView(viewer)); 1470 PetscCall(PetscViewerDestroy(&viewer)); 1471 } else { 1472 viewer = PETSC_VIEWER_STDOUT_WORLD; 1473 PetscCall(PetscViewerPushFormat(viewer, PETSC_VIEWER_DEFAULT)); 1474 PetscCall(PetscLogView(viewer)); 1475 PetscCall(PetscViewerPopFormat(viewer)); 1476 } 1477 } 1478 1479 /* 1480 Free any objects created by the last block of code. 1481 */ 1482 PetscCall(PetscObjectRegisterDestroyAll()); 1483 1484 mname[0] = 0; 1485 PetscCall(PetscOptionsGetString(NULL, NULL, "-log_all", mname, sizeof(mname), &flg1)); 1486 PetscCall(PetscOptionsGetString(NULL, NULL, "-log", mname, sizeof(mname), &flg2)); 1487 if (flg1 || flg2) PetscCall(PetscLogDump(mname)); 1488 #endif 1489 1490 flg1 = PETSC_FALSE; 1491 PetscCall(PetscOptionsGetBool(NULL, NULL, "-no_signal_handler", &flg1, NULL)); 1492 if (!flg1) PetscCall(PetscPopSignalHandler()); 1493 flg1 = PETSC_FALSE; 1494 PetscCall(PetscOptionsGetBool(NULL, NULL, "-mpidump", &flg1, NULL)); 1495 if (flg1) PetscCall(PetscMPIDump(stdout)); 1496 flg1 = PETSC_FALSE; 1497 flg2 = PETSC_FALSE; 1498 /* preemptive call to avoid listing this option in options table as unused */ 1499 PetscCall(PetscOptionsHasName(NULL, NULL, "-malloc_dump", &flg1)); 1500 PetscCall(PetscOptionsHasName(NULL, NULL, "-objects_dump", &flg1)); 1501 PetscCall(PetscOptionsGetBool(NULL, NULL, "-options_view", &flg2, NULL)); 1502 1503 if (flg2) { 1504 PetscViewer viewer; 1505 PetscCall(PetscViewerCreate(PETSC_COMM_WORLD, &viewer)); 1506 PetscCall(PetscViewerSetType(viewer, PETSCVIEWERASCII)); 1507 PetscCall(PetscOptionsView(NULL, viewer)); 1508 PetscCall(PetscViewerDestroy(&viewer)); 1509 } 1510 1511 /* to prevent PETSc -options_left from warning */ 1512 PetscCall(PetscOptionsHasName(NULL, NULL, "-nox", &flg1)); 1513 PetscCall(PetscOptionsHasName(NULL, NULL, "-nox_warning", &flg1)); 1514 1515 flg3 = PETSC_FALSE; /* default value is required */ 1516 PetscCall(PetscOptionsGetBool(NULL, NULL, "-options_left", &flg3, &flg1)); 1517 if (PetscUnlikelyDebug(!flg1)) flg3 = PETSC_TRUE; 1518 if (flg3) { 1519 if (!flg2 && flg1) { /* have not yet printed the options */ 1520 PetscViewer viewer; 1521 PetscCall(PetscViewerCreate(PETSC_COMM_WORLD, &viewer)); 1522 PetscCall(PetscViewerSetType(viewer, PETSCVIEWERASCII)); 1523 PetscCall(PetscOptionsView(NULL, viewer)); 1524 PetscCall(PetscViewerDestroy(&viewer)); 1525 } 1526 PetscCall(PetscOptionsAllUsed(NULL, &nopt)); 1527 if (nopt) { 1528 PetscCall(PetscPrintf(PETSC_COMM_WORLD, "WARNING! There are options you set that were not used!\n")); 1529 PetscCall(PetscPrintf(PETSC_COMM_WORLD, "WARNING! could be spelling mistake, etc!\n")); 1530 if (nopt == 1) { 1531 PetscCall(PetscPrintf(PETSC_COMM_WORLD, "There is one unused database option. It is:\n")); 1532 } else { 1533 PetscCall(PetscPrintf(PETSC_COMM_WORLD, "There are %" PetscInt_FMT " unused database options. They are:\n", nopt)); 1534 } 1535 } else if (flg3 && flg1) { 1536 PetscCall(PetscPrintf(PETSC_COMM_WORLD, "There are no unused options.\n")); 1537 } 1538 PetscCall(PetscOptionsLeft(NULL)); 1539 } 1540 1541 #if defined(PETSC_HAVE_SAWS) 1542 if (!PetscGlobalRank) { 1543 PetscCall(PetscStackSAWsViewOff()); 1544 PetscCallSAWs(SAWs_Finalize, ()); 1545 } 1546 #endif 1547 1548 #if defined(PETSC_USE_LOG) 1549 /* 1550 List all objects the user may have forgot to free 1551 */ 1552 if (PetscObjectsLog) { 1553 PetscCall(PetscOptionsHasName(NULL, NULL, "-objects_dump", &flg1)); 1554 if (flg1) { 1555 MPI_Comm local_comm; 1556 char string[64]; 1557 1558 PetscCall(PetscOptionsGetString(NULL, NULL, "-objects_dump", string, sizeof(string), NULL)); 1559 PetscCallMPI(MPI_Comm_dup(PETSC_COMM_WORLD, &local_comm)); 1560 PetscCall(PetscSequentialPhaseBegin_Private(local_comm, 1)); 1561 PetscCall(PetscObjectsDump(stdout, (string[0] == 'a') ? PETSC_TRUE : PETSC_FALSE)); 1562 PetscCall(PetscSequentialPhaseEnd_Private(local_comm, 1)); 1563 PetscCallMPI(MPI_Comm_free(&local_comm)); 1564 } 1565 } 1566 #endif 1567 1568 #if defined(PETSC_USE_LOG) 1569 PetscObjectsCounts = 0; 1570 PetscObjectsMaxCounts = 0; 1571 PetscCall(PetscFree(PetscObjects)); 1572 #endif 1573 1574 /* 1575 Destroy any packages that registered a finalize 1576 */ 1577 PetscCall(PetscRegisterFinalizeAll()); 1578 1579 #if defined(PETSC_USE_LOG) 1580 PetscCall(PetscLogFinalize()); 1581 #endif 1582 1583 /* 1584 Print PetscFunctionLists that have not been properly freed 1585 */ 1586 if (PetscPrintFunctionList) PetscCall(PetscFunctionListPrintAll()); 1587 1588 if (petsc_history) { 1589 PetscCall(PetscCloseHistoryFile(&petsc_history)); 1590 petsc_history = NULL; 1591 } 1592 PetscCall(PetscOptionsHelpPrintedDestroy(&PetscOptionsHelpPrintedSingleton)); 1593 PetscCall(PetscInfoDestroy()); 1594 1595 #if !defined(PETSC_HAVE_THREADSAFETY) 1596 if (!(PETSC_RUNNING_ON_VALGRIND)) { 1597 char fname[PETSC_MAX_PATH_LEN]; 1598 char sname[PETSC_MAX_PATH_LEN]; 1599 FILE *fd; 1600 int err; 1601 1602 flg2 = PETSC_FALSE; 1603 flg3 = PETSC_FALSE; 1604 if (PetscDefined(USE_DEBUG)) PetscCall(PetscOptionsGetBool(NULL, NULL, "-malloc_test", &flg2, NULL)); 1605 PetscCall(PetscOptionsGetBool(NULL, NULL, "-malloc_debug", &flg3, NULL)); 1606 fname[0] = 0; 1607 PetscCall(PetscOptionsGetString(NULL, NULL, "-malloc_dump", fname, sizeof(fname), &flg1)); 1608 if (flg1 && fname[0]) { 1609 PetscSNPrintf(sname, sizeof(sname), "%s_%d", fname, rank); 1610 fd = fopen(sname, "w"); 1611 PetscCheck(fd, PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Cannot open log file: %s", sname); 1612 PetscCall(PetscMallocDump(fd)); 1613 err = fclose(fd); 1614 PetscCheck(!err, PETSC_COMM_SELF, PETSC_ERR_SYS, "fclose() failed on file"); 1615 } else if (flg1 || flg2 || flg3) { 1616 MPI_Comm local_comm; 1617 1618 PetscCallMPI(MPI_Comm_dup(PETSC_COMM_WORLD, &local_comm)); 1619 PetscCall(PetscSequentialPhaseBegin_Private(local_comm, 1)); 1620 PetscCall(PetscMallocDump(stdout)); 1621 PetscCall(PetscSequentialPhaseEnd_Private(local_comm, 1)); 1622 PetscCallMPI(MPI_Comm_free(&local_comm)); 1623 } 1624 fname[0] = 0; 1625 PetscCall(PetscOptionsGetString(NULL, NULL, "-malloc_view", fname, sizeof(fname), &flg1)); 1626 if (flg1 && fname[0]) { 1627 PetscSNPrintf(sname, sizeof(sname), "%s_%d", fname, rank); 1628 fd = fopen(sname, "w"); 1629 PetscCheck(fd, PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Cannot open log file: %s", sname); 1630 PetscCall(PetscMallocView(fd)); 1631 err = fclose(fd); 1632 PetscCheck(!err, PETSC_COMM_SELF, PETSC_ERR_SYS, "fclose() failed on file"); 1633 } else if (flg1) { 1634 MPI_Comm local_comm; 1635 1636 PetscCallMPI(MPI_Comm_dup(PETSC_COMM_WORLD, &local_comm)); 1637 PetscCall(PetscSequentialPhaseBegin_Private(local_comm, 1)); 1638 PetscCall(PetscMallocView(stdout)); 1639 PetscCall(PetscSequentialPhaseEnd_Private(local_comm, 1)); 1640 PetscCallMPI(MPI_Comm_free(&local_comm)); 1641 } 1642 } 1643 #endif 1644 1645 /* 1646 Close any open dynamic libraries 1647 */ 1648 PetscCall(PetscFinalize_DynamicLibraries()); 1649 1650 /* Can be destroyed only after all the options are used */ 1651 PetscCall(PetscOptionsDestroyDefault()); 1652 1653 PetscGlobalArgc = 0; 1654 PetscGlobalArgs = NULL; 1655 1656 #if defined(PETSC_HAVE_KOKKOS) 1657 if (PetscBeganKokkos) { 1658 PetscCall(PetscKokkosFinalize_Private()); 1659 PetscBeganKokkos = PETSC_FALSE; 1660 PetscKokkosInitialized = PETSC_FALSE; 1661 } 1662 #endif 1663 1664 #if defined(PETSC_HAVE_NVSHMEM) 1665 if (PetscBeganNvshmem) { 1666 PetscCall(PetscNvshmemFinalize()); 1667 PetscBeganNvshmem = PETSC_FALSE; 1668 } 1669 #endif 1670 1671 PetscCall(PetscFreeMPIResources()); 1672 1673 /* 1674 Destroy any known inner MPI_Comm's and attributes pointing to them 1675 Note this will not destroy any new communicators the user has created. 1676 1677 If all PETSc objects were not destroyed those left over objects will have hanging references to 1678 the MPI_Comms that were freed; but that is ok because those PETSc objects will never be used again 1679 */ 1680 { 1681 PetscCommCounter *counter; 1682 PetscMPIInt flg; 1683 MPI_Comm icomm; 1684 union 1685 { 1686 MPI_Comm comm; 1687 void *ptr; 1688 } ucomm; 1689 PetscCallMPI(MPI_Comm_get_attr(PETSC_COMM_SELF, Petsc_InnerComm_keyval, &ucomm, &flg)); 1690 if (flg) { 1691 icomm = ucomm.comm; 1692 PetscCallMPI(MPI_Comm_get_attr(icomm, Petsc_Counter_keyval, &counter, &flg)); 1693 PetscCheck(flg, PETSC_COMM_SELF, PETSC_ERR_ARG_CORRUPT, "Inner MPI_Comm does not have expected tag/name counter, problem with corrupted memory"); 1694 1695 PetscCallMPI(MPI_Comm_delete_attr(PETSC_COMM_SELF, Petsc_InnerComm_keyval)); 1696 PetscCallMPI(MPI_Comm_delete_attr(icomm, Petsc_Counter_keyval)); 1697 PetscCallMPI(MPI_Comm_free(&icomm)); 1698 } 1699 PetscCallMPI(MPI_Comm_get_attr(PETSC_COMM_WORLD, Petsc_InnerComm_keyval, &ucomm, &flg)); 1700 if (flg) { 1701 icomm = ucomm.comm; 1702 PetscCallMPI(MPI_Comm_get_attr(icomm, Petsc_Counter_keyval, &counter, &flg)); 1703 PetscCheck(flg, PETSC_COMM_WORLD, PETSC_ERR_ARG_CORRUPT, "Inner MPI_Comm does not have expected tag/name counter, problem with corrupted memory"); 1704 1705 PetscCallMPI(MPI_Comm_delete_attr(PETSC_COMM_WORLD, Petsc_InnerComm_keyval)); 1706 PetscCallMPI(MPI_Comm_delete_attr(icomm, Petsc_Counter_keyval)); 1707 PetscCallMPI(MPI_Comm_free(&icomm)); 1708 } 1709 } 1710 1711 PetscCallMPI(MPI_Comm_free_keyval(&Petsc_Counter_keyval)); 1712 PetscCallMPI(MPI_Comm_free_keyval(&Petsc_InnerComm_keyval)); 1713 PetscCallMPI(MPI_Comm_free_keyval(&Petsc_OuterComm_keyval)); 1714 PetscCallMPI(MPI_Comm_free_keyval(&Petsc_ShmComm_keyval)); 1715 1716 PetscCall(PetscSpinlockDestroy(&PetscViewerASCIISpinLockOpen)); 1717 PetscCall(PetscSpinlockDestroy(&PetscViewerASCIISpinLockStdout)); 1718 PetscCall(PetscSpinlockDestroy(&PetscViewerASCIISpinLockStderr)); 1719 PetscCall(PetscSpinlockDestroy(&PetscCommSpinLock)); 1720 1721 if (PetscBeganMPI) { 1722 PetscMPIInt flag; 1723 PetscCallMPI(MPI_Finalized(&flag)); 1724 PetscCheck(!flag, PETSC_COMM_SELF, PETSC_ERR_LIB, "MPI_Finalize() has already been called, even though MPI_Init() was called by PetscInitialize()"); 1725 /* wait until the very last moment to disable error handling */ 1726 PetscErrorHandlingInitialized = PETSC_FALSE; 1727 PetscCallMPI(MPI_Finalize()); 1728 } else PetscErrorHandlingInitialized = PETSC_FALSE; 1729 1730 /* 1731 1732 Note: In certain cases PETSC_COMM_WORLD is never MPI_Comm_free()ed because 1733 the communicator has some outstanding requests on it. Specifically if the 1734 flag PETSC_HAVE_BROKEN_REQUEST_FREE is set (for IBM MPI implementation). See 1735 src/vec/utils/vpscat.c. Due to this the memory allocated in PetscCommDuplicate() 1736 is never freed as it should be. Thus one may obtain messages of the form 1737 [ 1] 8 bytes PetscCommDuplicate() line 645 in src/sys/mpiu.c indicating the 1738 memory was not freed. 1739 1740 */ 1741 PetscCall(PetscMallocClear()); 1742 PetscCall(PetscStackReset()); 1743 1744 PetscInitializeCalled = PETSC_FALSE; 1745 PetscFinalizeCalled = PETSC_TRUE; 1746 #if defined(PETSC_USE_GCOV) 1747 /* 1748 flush gcov, otherwise during CI the flushing continues into the next pipeline resulting in git not being able to delete directories since the 1749 gcov files are still being added to the directories as git tries to remove the directories. 1750 */ 1751 __gcov_flush(); 1752 #endif 1753 /* To match PetscFunctionBegin() at the beginning of this function */ 1754 PetscStackClearTop; 1755 return 0; 1756 } 1757 1758 #if defined(PETSC_MISSING_LAPACK_lsame_) 1759 PETSC_EXTERN int lsame_(char *a, char *b) { 1760 if (*a == *b) return 1; 1761 if (*a + 32 == *b) return 1; 1762 if (*a - 32 == *b) return 1; 1763 return 0; 1764 } 1765 #endif 1766 1767 #if defined(PETSC_MISSING_LAPACK_lsame) 1768 PETSC_EXTERN int lsame(char *a, char *b) { 1769 if (*a == *b) return 1; 1770 if (*a + 32 == *b) return 1; 1771 if (*a - 32 == *b) return 1; 1772 return 0; 1773 } 1774 #endif 1775