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