1 /* 2 This is the main PETSc include file (for C and C++). It is included by all 3 other PETSc include files, so it almost never has to be specifically included. 4 Portions of this code are under: 5 Copyright (c) 2022 Advanced Micro Devices, Inc. All rights reserved. 6 */ 7 #ifndef PETSCSYS_H 8 #define PETSCSYS_H 9 10 /* ========================================================================== */ 11 /* 12 petscconf.h is contained in ${PETSC_ARCH}/include/petscconf.h it is 13 found automatically by the compiler due to the -I${PETSC_DIR}/${PETSC_ARCH}/include that 14 PETSc's makefiles add to the compiler rules. 15 For --prefix installs the directory ${PETSC_ARCH} does not exist and petscconf.h is in the same 16 directory as the other PETSc include files. 17 */ 18 #include <petscconf.h> 19 #include <petscconf_poison.h> 20 #include <petscfix.h> 21 #include <petscmacros.h> 22 23 /* SUBMANSEC = Sys */ 24 25 #if defined(PETSC_DESIRE_FEATURE_TEST_MACROS) 26 /* 27 Feature test macros must be included before headers defined by IEEE Std 1003.1-2001 28 We only turn these in PETSc source files that require them by setting PETSC_DESIRE_FEATURE_TEST_MACROS 29 */ 30 #if defined(PETSC__POSIX_C_SOURCE_200112L) && !defined(_POSIX_C_SOURCE) 31 #define _POSIX_C_SOURCE 200112L 32 #endif 33 #if defined(PETSC__BSD_SOURCE) && !defined(_BSD_SOURCE) 34 #define _BSD_SOURCE 35 #endif 36 #if defined(PETSC__DEFAULT_SOURCE) && !defined(_DEFAULT_SOURCE) 37 #define _DEFAULT_SOURCE 38 #endif 39 #if defined(PETSC__GNU_SOURCE) && !defined(_GNU_SOURCE) 40 #define _GNU_SOURCE 41 #endif 42 #endif 43 44 #include <petscsystypes.h> 45 46 /* ========================================================================== */ 47 48 /* 49 Defines the interface to MPI allowing the use of all MPI functions. 50 51 PETSc does not use the C++ binding of MPI at ALL. The following flag 52 makes sure the C++ bindings are not included. The C++ bindings REQUIRE 53 putting mpi.h before ANY C++ include files, we cannot control this 54 with all PETSc users. Users who want to use the MPI C++ bindings can include 55 mpicxx.h directly in their code 56 */ 57 #if !defined(MPICH_SKIP_MPICXX) 58 #define MPICH_SKIP_MPICXX 1 59 #endif 60 #if !defined(OMPI_SKIP_MPICXX) 61 #define OMPI_SKIP_MPICXX 1 62 #endif 63 #if defined(PETSC_HAVE_MPIUNI) 64 #include <petsc/mpiuni/mpi.h> 65 #else 66 #include <mpi.h> 67 #endif 68 69 /* 70 Perform various sanity checks that the correct mpi.h is being included at compile time. 71 This usually happens because 72 * either an unexpected mpi.h is in the default compiler path (i.e. in /usr/include) or 73 * an extra include path -I/something (which contains the unexpected mpi.h) is being passed to the compiler 74 */ 75 #if defined(PETSC_HAVE_MPIUNI) 76 #ifndef MPIUNI_H 77 #error "PETSc was configured with --with-mpi=0 but now appears to be compiling using a different mpi.h" 78 #endif 79 #elif defined(PETSC_HAVE_I_MPI_NUMVERSION) 80 #if !defined(I_MPI_NUMVERSION) 81 #error "PETSc was configured with I_MPI but now appears to be compiling using a non-I_MPI mpi.h" 82 #elif I_MPI_NUMVERSION != PETSC_HAVE_I_MPI_NUMVERSION 83 #error "PETSc was configured with one I_MPI mpi.h version but now appears to be compiling using a different I_MPI mpi.h version" 84 #endif 85 #elif defined(PETSC_HAVE_MVAPICH2_NUMVERSION) 86 #if !defined(MVAPICH2_NUMVERSION) 87 #error "PETSc was configured with MVAPICH2 but now appears to be compiling using a non-MVAPICH2 mpi.h" 88 #elif MVAPICH2_NUMVERSION != PETSC_HAVE_MVAPICH2_NUMVERSION 89 #error "PETSc was configured with one MVAPICH2 mpi.h version but now appears to be compiling using a different MVAPICH2 mpi.h version" 90 #endif 91 #elif defined(PETSC_HAVE_MPICH_NUMVERSION) 92 #if !defined(MPICH_NUMVERSION) || defined(MVAPICH2_NUMVERSION) || defined(I_MPI_NUMVERSION) 93 #error "PETSc was configured with MPICH but now appears to be compiling using a non-MPICH mpi.h" 94 #elif (MPICH_NUMVERSION / 100000000 != PETSC_HAVE_MPICH_NUMVERSION / 100000000) || (MPICH_NUMVERSION / 100000 < PETSC_HAVE_MPICH_NUMVERSION / 100000) || (MPICH_NUMVERSION / 100000 == PETSC_HAVE_MPICH_NUMVERSION / 100000 && MPICH_NUMVERSION % 100000 / 1000 < PETSC_HAVE_MPICH_NUMVERSION % 100000 / 1000) 95 #error "PETSc was configured with one MPICH mpi.h version but now appears to be compiling using a different MPICH mpi.h version" 96 #endif 97 #elif defined(PETSC_HAVE_OMPI_MAJOR_VERSION) 98 #if !defined(OMPI_MAJOR_VERSION) 99 #error "PETSc was configured with OpenMPI but now appears to be compiling using a non-OpenMPI mpi.h" 100 #elif (OMPI_MAJOR_VERSION != PETSC_HAVE_OMPI_MAJOR_VERSION) || (OMPI_MINOR_VERSION < PETSC_HAVE_OMPI_MINOR_VERSION) || (OMPI_MINOR_VERSION == PETSC_HAVE_OMPI_MINOR_VERSION && OMPI_RELEASE_VERSION < PETSC_HAVE_OMPI_RELEASE_VERSION) 101 #error "PETSc was configured with one OpenMPI mpi.h version but now appears to be compiling using a different OpenMPI mpi.h version" 102 #endif 103 #elif defined(PETSC_HAVE_MSMPI_VERSION) 104 #if !defined(MSMPI_VER) 105 #error "PETSc was configured with MSMPI but now appears to be compiling using a non-MSMPI mpi.h" 106 #elif (MSMPI_VER != PETSC_HAVE_MSMPI_VERSION) 107 #error "PETSc was configured with one MSMPI mpi.h version but now appears to be compiling using a different MSMPI mpi.h version" 108 #endif 109 #elif defined(OMPI_MAJOR_VERSION) || defined(MPICH_NUMVERSION) || defined(MSMPI_VER) 110 #error "PETSc was configured with undetermined MPI - but now appears to be compiling using any of OpenMPI, MS-MPI or a MPICH variant" 111 #endif 112 113 /* 114 Need to put stdio.h AFTER mpi.h for MPICH2 with C++ compiler 115 see the top of mpicxx.h in the MPICH2 distribution. 116 */ 117 #include <stdio.h> 118 119 /* MSMPI on 32-bit Microsoft Windows requires this yukky hack - that breaks MPI standard compliance */ 120 #if !defined(MPIAPI) 121 #define MPIAPI 122 #endif 123 124 PETSC_EXTERN MPI_Datatype MPIU_ENUM PETSC_ATTRIBUTE_MPI_TYPE_TAG(PetscEnum); 125 PETSC_EXTERN MPI_Datatype MPIU_BOOL PETSC_ATTRIBUTE_MPI_TYPE_TAG(PetscBool); 126 127 /*MC 128 MPIU_INT - Portable MPI datatype corresponding to `PetscInt` independent of the precision of `PetscInt` 129 130 Level: beginner 131 132 Note: 133 In MPI calls that require an MPI datatype that matches a `PetscInt` or array of `PetscInt` values, pass this value. 134 135 .seealso: `PetscReal`, `PetscScalar`, `PetscComplex`, `PetscInt`, `MPIU_COUNT`, `MPIU_REAL`, `MPIU_SCALAR`, `MPIU_COMPLEX` 136 M*/ 137 138 PETSC_EXTERN MPI_Datatype MPIU_FORTRANADDR; 139 140 #if defined(PETSC_USE_64BIT_INDICES) 141 #define MPIU_INT MPIU_INT64 142 #else 143 #define MPIU_INT MPI_INT 144 #endif 145 146 /*MC 147 MPIU_COUNT - Portable MPI datatype corresponding to `PetscCount` independent of the precision of `PetscCount` 148 149 Level: beginner 150 151 Note: 152 In MPI calls that require an MPI datatype that matches a `PetscCount` or array of `PetscCount` values, pass this value. 153 154 Developer Note: 155 It seems MPI_AINT is unsigned so this may be the wrong choice here since `PetscCount` is signed 156 157 .seealso: `PetscReal`, `PetscScalar`, `PetscComplex`, `PetscInt`, `MPIU_INT`, `MPIU_REAL`, `MPIU_SCALAR`, `MPIU_COMPLEX` 158 M*/ 159 #define MPIU_COUNT MPI_AINT 160 161 /* 162 For the rare cases when one needs to send a size_t object with MPI 163 */ 164 PETSC_EXTERN MPI_Datatype MPIU_SIZE_T PETSC_ATTRIBUTE_MPI_TYPE_TAG(size_t); 165 166 /* 167 You can use PETSC_STDOUT as a replacement of stdout. You can also change 168 the value of PETSC_STDOUT to redirect all standard output elsewhere 169 */ 170 PETSC_EXTERN FILE *PETSC_STDOUT; 171 172 /* 173 You can use PETSC_STDERR as a replacement of stderr. You can also change 174 the value of PETSC_STDERR to redirect all standard error elsewhere 175 */ 176 PETSC_EXTERN FILE *PETSC_STDERR; 177 178 /* 179 Handle inclusion when using clang compiler with CUDA support 180 __float128 is not available for the device 181 */ 182 #if defined(__clang__) && defined(__CUDA_ARCH__) 183 #define PETSC_SKIP_REAL___FLOAT128 184 #endif 185 186 /* 187 Declare extern C stuff after including external header files 188 */ 189 190 PETSC_EXTERN PetscBool PETSC_RUNNING_ON_VALGRIND; 191 /* 192 Defines elementary mathematics functions and constants. 193 */ 194 #include <petscmath.h> 195 196 /*MC 197 PETSC_IGNORE - same as `NULL`, means PETSc will ignore this argument 198 199 Level: beginner 200 201 Note: 202 Accepted by many PETSc functions to not set a parameter and instead use a default value 203 204 Fortran Note: 205 Use `PETSC_NULL_INTEGER`, `PETSC_NULL_DOUBLE_PRECISION` etc 206 207 .seealso: `PETSC_DECIDE`, `PETSC_DEFAULT`, `PETSC_DETERMINE` 208 M*/ 209 #define PETSC_IGNORE PETSC_NULLPTR 210 #define PETSC_NULL PETSC_DEPRECATED_MACRO("GCC warning \"PETSC_NULL is deprecated, use PETSC_NULLPTR instead (since version 3.19)\"") PETSC_NULLPTR 211 212 /*MC 213 PETSC_DECIDE - standard way of passing in integer or floating point parameter 214 where you wish PETSc to use the default. 215 216 Level: beginner 217 218 .seealso: `PETSC_DEFAULT`, `PETSC_IGNORE`, `PETSC_DETERMINE` 219 M*/ 220 221 /*MC 222 PETSC_DETERMINE - standard way of passing in integer or floating point parameter 223 where you wish PETSc to compute the required value. 224 225 Level: beginner 226 227 Developer Note: 228 I would like to use const `PetscInt` `PETSC_DETERMINE` = `PETSC_DECIDE`; but for 229 some reason this is not allowed by the standard even though `PETSC_DECIDE` is a constant value. 230 231 .seealso: `PETSC_DECIDE`, `PETSC_DEFAULT`, `PETSC_IGNORE`, `VecSetSizes()` 232 M*/ 233 234 /*MC 235 PETSC_DEFAULT - standard way of passing in integer or floating point parameter 236 where you wish PETSc to use the default. 237 238 Level: beginner 239 240 Fortran Note: 241 You need to use `PETSC_DEFAULT_INTEGER` or `PETSC_DEFAULT_REAL`. 242 243 .seealso: `PETSC_DECIDE`, `PETSC_IGNORE`, `PETSC_DETERMINE` 244 M*/ 245 246 /* These MUST be preprocessor defines! see https://gitlab.com/petsc/petsc/-/issues/1370 */ 247 #define PETSC_DECIDE (-1) 248 #define PETSC_DETERMINE PETSC_DECIDE 249 #define PETSC_DEFAULT (-2) 250 251 /*MC 252 PETSC_COMM_WORLD - the equivalent of the `MPI_COMM_WORLD` communicator which represents 253 all the processes that PETSc knows about. 254 255 Level: beginner 256 257 Notes: 258 By default `PETSC_COMM_WORLD` and `MPI_COMM_WORLD` are identical unless you wish to 259 run PETSc on ONLY a subset of `MPI_COMM_WORLD`. In that case create your new (smaller) 260 communicator, call it, say comm, and set `PETSC_COMM_WORLD` = comm BEFORE calling 261 PetscInitialize(), but after `MPI_Init()` has been called. 262 263 The value of `PETSC_COMM_WORLD` should never be USED/accessed before `PetscInitialize()` 264 is called because it may not have a valid value yet. 265 266 .seealso: `PETSC_COMM_SELF` 267 M*/ 268 PETSC_EXTERN MPI_Comm PETSC_COMM_WORLD; 269 270 /*MC 271 PETSC_COMM_SELF - This is always `MPI_COMM_SELF` 272 273 Level: beginner 274 275 Notes: 276 Do not USE/access or set this variable before `PetscInitialize()` has been called. 277 278 .seealso: `PETSC_COMM_WORLD` 279 M*/ 280 #define PETSC_COMM_SELF MPI_COMM_SELF 281 282 /*MC 283 PETSC_MPI_THREAD_REQUIRED - the required threading support used if PETSc initializes 284 MPI with `MPI_Init_thread()`. 285 286 Level: beginner 287 288 Notes: 289 By default `PETSC_MPI_THREAD_REQUIRED` equals `MPI_THREAD_FUNNELED`. 290 291 .seealso: `PetscInitialize()` 292 M*/ 293 PETSC_EXTERN PetscMPIInt PETSC_MPI_THREAD_REQUIRED; 294 295 PETSC_EXTERN PetscBool PetscBeganMPI; 296 PETSC_EXTERN PetscBool PetscErrorHandlingInitialized; 297 PETSC_EXTERN PetscBool PetscInitializeCalled; 298 PETSC_EXTERN PetscBool PetscFinalizeCalled; 299 PETSC_EXTERN PetscBool PetscViennaCLSynchronize; 300 301 PETSC_EXTERN PetscErrorCode PetscSetHelpVersionFunctions(PetscErrorCode (*)(MPI_Comm), PetscErrorCode (*)(MPI_Comm)); 302 PETSC_EXTERN PetscErrorCode PetscCommDuplicate(MPI_Comm, MPI_Comm *, int *); 303 PETSC_EXTERN PetscErrorCode PetscCommDestroy(MPI_Comm *); 304 PETSC_EXTERN PetscErrorCode PetscCommGetComm(MPI_Comm, MPI_Comm *); 305 PETSC_EXTERN PetscErrorCode PetscCommRestoreComm(MPI_Comm, MPI_Comm *); 306 307 #if defined(PETSC_HAVE_KOKKOS) 308 PETSC_EXTERN PetscErrorCode PetscKokkosInitializeCheck(void); /* Initialize Kokkos if not yet. */ 309 #endif 310 311 #if defined(PETSC_HAVE_NVSHMEM) 312 PETSC_EXTERN PetscBool PetscBeganNvshmem; 313 PETSC_EXTERN PetscBool PetscNvshmemInitialized; 314 PETSC_EXTERN PetscErrorCode PetscNvshmemFinalize(void); 315 #endif 316 317 #if defined(PETSC_HAVE_ELEMENTAL) 318 PETSC_EXTERN PetscErrorCode PetscElementalInitializePackage(void); 319 PETSC_EXTERN PetscErrorCode PetscElementalInitialized(PetscBool *); 320 PETSC_EXTERN PetscErrorCode PetscElementalFinalizePackage(void); 321 #endif 322 323 /*MC 324 PetscMalloc - Allocates memory, One should use `PetscNew()`, `PetscMalloc1()` or `PetscCalloc1()` usually instead of this 325 326 Synopsis: 327 #include <petscsys.h> 328 PetscErrorCode PetscMalloc(size_t m,void **result) 329 330 Not Collective 331 332 Input Parameter: 333 . m - number of bytes to allocate 334 335 Output Parameter: 336 . result - memory allocated 337 338 Level: beginner 339 340 Notes: 341 Memory is always allocated at least double aligned 342 343 It is safe to allocate size 0 and pass the resulting pointer (which may or may not be `NULL`) to `PetscFree()`. 344 345 .seealso: `PetscFree()`, `PetscNew()` 346 M*/ 347 #define PetscMalloc(a, b) ((*PetscTrMalloc)((a), PETSC_FALSE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, (void **)(b))) 348 349 /*MC 350 PetscRealloc - Reallocates memory 351 352 Synopsis: 353 #include <petscsys.h> 354 PetscErrorCode PetscRealloc(size_t m,void **result) 355 356 Not Collective 357 358 Input Parameters: 359 + m - number of bytes to allocate 360 - result - previous memory 361 362 Output Parameter: 363 . result - new memory allocated 364 365 Level: developer 366 367 Notes: 368 Memory is always allocated at least double aligned 369 370 .seealso: `PetscMalloc()`, `PetscFree()`, `PetscNew()` 371 M*/ 372 #define PetscRealloc(a, b) ((*PetscTrRealloc)((a), __LINE__, PETSC_FUNCTION_NAME, __FILE__, (void **)(b))) 373 374 /*MC 375 PetscAddrAlign - Rounds up an address to `PETSC_MEMALIGN` alignment 376 377 Synopsis: 378 #include <petscsys.h> 379 void *PetscAddrAlign(void *addr) 380 381 Not Collective 382 383 Input Parameter: 384 . addr - address to align (any pointer type) 385 386 Level: developer 387 388 .seealso: `PetscMallocAlign()` 389 M*/ 390 #define PetscAddrAlign(a) ((void *)((((PETSC_UINTPTR_T)(a)) + (PETSC_MEMALIGN - 1)) & ~(PETSC_MEMALIGN - 1))) 391 392 /*MC 393 PetscCalloc - Allocates a cleared (zeroed) memory region aligned to `PETSC_MEMALIGN` 394 395 Synopsis: 396 #include <petscsys.h> 397 PetscErrorCode PetscCalloc(size_t m,void **result) 398 399 Not Collective 400 401 Input Parameter: 402 . m - number of bytes to allocate 403 404 Output Parameter: 405 . result - memory allocated 406 407 Level: beginner 408 409 Notes: 410 Memory is always allocated at least double aligned. This macro is useful in allocating memory pointed by void pointers 411 412 It is safe to allocate size 0 and pass the resulting pointer (which may or may not be `NULL`) to `PetscFree()`. 413 414 .seealso: `PetscFree()`, `PetscNew()` 415 M*/ 416 #define PetscCalloc(m, result) PetscMallocA(1, PETSC_TRUE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)m), (result)) 417 418 /*MC 419 PetscMalloc1 - Allocates an array of memory aligned to `PETSC_MEMALIGN` 420 421 Synopsis: 422 #include <petscsys.h> 423 PetscErrorCode PetscMalloc1(size_t m1,type **r1) 424 425 Not Collective 426 427 Input Parameter: 428 . m1 - number of elements to allocate (may be zero) 429 430 Output Parameter: 431 . r1 - memory allocated 432 433 Level: beginner 434 435 Note: 436 This uses the sizeof() of the memory type requested to determine the total memory to be allocated, therefore you should not 437 multiply the number of elements requested by the `sizeof()` the type. For example use 438 .vb 439 PetscInt *id; 440 PetscMalloc1(10,&id); 441 .ve 442 not 443 .vb 444 PetscInt *id; 445 PetscMalloc1(10*sizeof(PetscInt),&id); 446 .ve 447 448 Does not zero the memory allocated, use `PetscCalloc1()` to obtain memory that has been zeroed. 449 450 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscCalloc1()`, `PetscMalloc2()` 451 M*/ 452 #define PetscMalloc1(m1, r1) PetscMallocA(1, PETSC_FALSE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1)) 453 454 /*MC 455 PetscCalloc1 - Allocates a cleared (zeroed) array of memory aligned to `PETSC_MEMALIGN` 456 457 Synopsis: 458 #include <petscsys.h> 459 PetscErrorCode PetscCalloc1(size_t m1,type **r1) 460 461 Not Collective 462 463 Input Parameter: 464 . m1 - number of elements to allocate in 1st chunk (may be zero) 465 466 Output Parameter: 467 . r1 - memory allocated 468 469 Level: beginner 470 471 Notes: 472 See `PetsMalloc1()` for more details on usage. 473 474 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscMalloc1()`, `PetscCalloc2()` 475 M*/ 476 #define PetscCalloc1(m1, r1) PetscMallocA(1, PETSC_TRUE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1)) 477 478 /*MC 479 PetscMalloc2 - Allocates 2 arrays of memory both aligned to `PETSC_MEMALIGN` 480 481 Synopsis: 482 #include <petscsys.h> 483 PetscErrorCode PetscMalloc2(size_t m1,type **r1,size_t m2,type **r2) 484 485 Not Collective 486 487 Input Parameters: 488 + m1 - number of elements to allocate in 1st chunk (may be zero) 489 - m2 - number of elements to allocate in 2nd chunk (may be zero) 490 491 Output Parameters: 492 + r1 - memory allocated in first chunk 493 - r2 - memory allocated in second chunk 494 495 Level: developer 496 497 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscMalloc1()`, `PetscCalloc2()` 498 M*/ 499 #define PetscMalloc2(m1, r1, m2, r2) PetscMallocA(2, PETSC_FALSE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1), ((size_t)((size_t)m2) * sizeof(**(r2))), (r2)) 500 501 /*MC 502 PetscCalloc2 - Allocates 2 cleared (zeroed) arrays of memory both aligned to `PETSC_MEMALIGN` 503 504 Synopsis: 505 #include <petscsys.h> 506 PetscErrorCode PetscCalloc2(size_t m1,type **r1,size_t m2,type **r2) 507 508 Not Collective 509 510 Input Parameters: 511 + m1 - number of elements to allocate in 1st chunk (may be zero) 512 - m2 - number of elements to allocate in 2nd chunk (may be zero) 513 514 Output Parameters: 515 + r1 - memory allocated in first chunk 516 - r2 - memory allocated in second chunk 517 518 Level: developer 519 520 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscCalloc1()`, `PetscMalloc2()` 521 M*/ 522 #define PetscCalloc2(m1, r1, m2, r2) PetscMallocA(2, PETSC_TRUE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1), ((size_t)((size_t)m2) * sizeof(**(r2))), (r2)) 523 524 /*MC 525 PetscMalloc3 - Allocates 3 arrays of memory, all aligned to `PETSC_MEMALIGN` 526 527 Synopsis: 528 #include <petscsys.h> 529 PetscErrorCode PetscMalloc3(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3) 530 531 Not Collective 532 533 Input Parameters: 534 + m1 - number of elements to allocate in 1st chunk (may be zero) 535 . m2 - number of elements to allocate in 2nd chunk (may be zero) 536 - m3 - number of elements to allocate in 3rd chunk (may be zero) 537 538 Output Parameters: 539 + r1 - memory allocated in first chunk 540 . r2 - memory allocated in second chunk 541 - r3 - memory allocated in third chunk 542 543 Level: developer 544 545 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscCalloc3()`, `PetscFree3()` 546 M*/ 547 #define PetscMalloc3(m1, r1, m2, r2, m3, r3) \ 548 PetscMallocA(3, PETSC_FALSE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1), ((size_t)((size_t)m2) * sizeof(**(r2))), (r2), ((size_t)((size_t)m3) * sizeof(**(r3))), (r3)) 549 550 /*MC 551 PetscCalloc3 - Allocates 3 cleared (zeroed) arrays of memory, all aligned to `PETSC_MEMALIGN` 552 553 Synopsis: 554 #include <petscsys.h> 555 PetscErrorCode PetscCalloc3(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3) 556 557 Not Collective 558 559 Input Parameters: 560 + m1 - number of elements to allocate in 1st chunk (may be zero) 561 . m2 - number of elements to allocate in 2nd chunk (may be zero) 562 - m3 - number of elements to allocate in 3rd chunk (may be zero) 563 564 Output Parameters: 565 + r1 - memory allocated in first chunk 566 . r2 - memory allocated in second chunk 567 - r3 - memory allocated in third chunk 568 569 Level: developer 570 571 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscCalloc2()`, `PetscMalloc3()`, `PetscFree3()` 572 M*/ 573 #define PetscCalloc3(m1, r1, m2, r2, m3, r3) \ 574 PetscMallocA(3, PETSC_TRUE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1), ((size_t)((size_t)m2) * sizeof(**(r2))), (r2), ((size_t)((size_t)m3) * sizeof(**(r3))), (r3)) 575 576 /*MC 577 PetscMalloc4 - Allocates 4 arrays of memory, all aligned to `PETSC_MEMALIGN` 578 579 Synopsis: 580 #include <petscsys.h> 581 PetscErrorCode PetscMalloc4(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4) 582 583 Not Collective 584 585 Input Parameters: 586 + m1 - number of elements to allocate in 1st chunk (may be zero) 587 . m2 - number of elements to allocate in 2nd chunk (may be zero) 588 . m3 - number of elements to allocate in 3rd chunk (may be zero) 589 - m4 - number of elements to allocate in 4th chunk (may be zero) 590 591 Output Parameters: 592 + r1 - memory allocated in first chunk 593 . r2 - memory allocated in second chunk 594 . r3 - memory allocated in third chunk 595 - r4 - memory allocated in fourth chunk 596 597 Level: developer 598 599 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscCalloc4()`, `PetscFree4()` 600 M*/ 601 #define PetscMalloc4(m1, r1, m2, r2, m3, r3, m4, r4) \ 602 PetscMallocA(4, PETSC_FALSE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1), ((size_t)((size_t)m2) * sizeof(**(r2))), (r2), ((size_t)((size_t)m3) * sizeof(**(r3))), (r3), ((size_t)((size_t)m4) * sizeof(**(r4))), (r4)) 603 604 /*MC 605 PetscCalloc4 - Allocates 4 cleared (zeroed) arrays of memory, all aligned to `PETSC_MEMALIGN` 606 607 Synopsis: 608 #include <petscsys.h> 609 PetscErrorCode PetscCalloc4(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4) 610 611 Not Collective 612 613 Input Parameters: 614 + m1 - number of elements to allocate in 1st chunk (may be zero) 615 . m2 - number of elements to allocate in 2nd chunk (may be zero) 616 . m3 - number of elements to allocate in 3rd chunk (may be zero) 617 - m4 - number of elements to allocate in 4th chunk (may be zero) 618 619 Output Parameters: 620 + r1 - memory allocated in first chunk 621 . r2 - memory allocated in second chunk 622 . r3 - memory allocated in third chunk 623 - r4 - memory allocated in fourth chunk 624 625 Level: developer 626 627 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscCalloc4()`, `PetscFree4()` 628 M*/ 629 #define PetscCalloc4(m1, r1, m2, r2, m3, r3, m4, r4) \ 630 PetscMallocA(4, PETSC_TRUE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1), ((size_t)((size_t)m2) * sizeof(**(r2))), (r2), ((size_t)((size_t)m3) * sizeof(**(r3))), (r3), ((size_t)((size_t)m4) * sizeof(**(r4))), (r4)) 631 632 /*MC 633 PetscMalloc5 - Allocates 5 arrays of memory, all aligned to `PETSC_MEMALIGN` 634 635 Synopsis: 636 #include <petscsys.h> 637 PetscErrorCode PetscMalloc5(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4,size_t m5,type **r5) 638 639 Not Collective 640 641 Input Parameters: 642 + m1 - number of elements to allocate in 1st chunk (may be zero) 643 . m2 - number of elements to allocate in 2nd chunk (may be zero) 644 . m3 - number of elements to allocate in 3rd chunk (may be zero) 645 . m4 - number of elements to allocate in 4th chunk (may be zero) 646 - m5 - number of elements to allocate in 5th chunk (may be zero) 647 648 Output Parameters: 649 + r1 - memory allocated in first chunk 650 . r2 - memory allocated in second chunk 651 . r3 - memory allocated in third chunk 652 . r4 - memory allocated in fourth chunk 653 - r5 - memory allocated in fifth chunk 654 655 Level: developer 656 657 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscCalloc5()`, `PetscFree5()` 658 M*/ 659 #define PetscMalloc5(m1, r1, m2, r2, m3, r3, m4, r4, m5, r5) \ 660 PetscMallocA(5, PETSC_FALSE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1), ((size_t)((size_t)m2) * sizeof(**(r2))), (r2), ((size_t)((size_t)m3) * sizeof(**(r3))), (r3), ((size_t)((size_t)m4) * sizeof(**(r4))), (r4), ((size_t)((size_t)m5) * sizeof(**(r5))), (r5)) 661 662 /*MC 663 PetscCalloc5 - Allocates 5 cleared (zeroed) arrays of memory, all aligned to `PETSC_MEMALIGN` 664 665 Synopsis: 666 #include <petscsys.h> 667 PetscErrorCode PetscCalloc5(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4,size_t m5,type **r5) 668 669 Not Collective 670 671 Input Parameters: 672 + m1 - number of elements to allocate in 1st chunk (may be zero) 673 . m2 - number of elements to allocate in 2nd chunk (may be zero) 674 . m3 - number of elements to allocate in 3rd chunk (may be zero) 675 . m4 - number of elements to allocate in 4th chunk (may be zero) 676 - m5 - number of elements to allocate in 5th chunk (may be zero) 677 678 Output Parameters: 679 + r1 - memory allocated in first chunk 680 . r2 - memory allocated in second chunk 681 . r3 - memory allocated in third chunk 682 . r4 - memory allocated in fourth chunk 683 - r5 - memory allocated in fifth chunk 684 685 Level: developer 686 687 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscMalloc5()`, `PetscFree5()` 688 M*/ 689 #define PetscCalloc5(m1, r1, m2, r2, m3, r3, m4, r4, m5, r5) \ 690 PetscMallocA(5, PETSC_TRUE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1), ((size_t)((size_t)m2) * sizeof(**(r2))), (r2), ((size_t)((size_t)m3) * sizeof(**(r3))), (r3), ((size_t)((size_t)m4) * sizeof(**(r4))), (r4), ((size_t)((size_t)m5) * sizeof(**(r5))), (r5)) 691 692 /*MC 693 PetscMalloc6 - Allocates 6 arrays of memory, all aligned to `PETSC_MEMALIGN` 694 695 Synopsis: 696 #include <petscsys.h> 697 PetscErrorCode PetscMalloc6(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4,size_t m5,type **r5,size_t m6,type **r6) 698 699 Not Collective 700 701 Input Parameters: 702 + m1 - number of elements to allocate in 1st chunk (may be zero) 703 . m2 - number of elements to allocate in 2nd chunk (may be zero) 704 . m3 - number of elements to allocate in 3rd chunk (may be zero) 705 . m4 - number of elements to allocate in 4th chunk (may be zero) 706 . m5 - number of elements to allocate in 5th chunk (may be zero) 707 - m6 - number of elements to allocate in 6th chunk (may be zero) 708 709 Output Parameteasr: 710 + r1 - memory allocated in first chunk 711 . r2 - memory allocated in second chunk 712 . r3 - memory allocated in third chunk 713 . r4 - memory allocated in fourth chunk 714 . r5 - memory allocated in fifth chunk 715 - r6 - memory allocated in sixth chunk 716 717 Level: developer 718 719 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscCalloc6()`, `PetscFree3()`, `PetscFree4()`, `PetscFree5()`, `PetscFree6()` 720 M*/ 721 #define PetscMalloc6(m1, r1, m2, r2, m3, r3, m4, r4, m5, r5, m6, r6) \ 722 PetscMallocA(6, PETSC_FALSE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1), ((size_t)((size_t)m2) * sizeof(**(r2))), (r2), ((size_t)((size_t)m3) * sizeof(**(r3))), (r3), ((size_t)((size_t)m4) * sizeof(**(r4))), (r4), ((size_t)((size_t)m5) * sizeof(**(r5))), (r5), ((size_t)((size_t)m6) * sizeof(**(r6))), (r6)) 723 724 /*MC 725 PetscCalloc6 - Allocates 6 cleared (zeroed) arrays of memory, all aligned to `PETSC_MEMALIGN` 726 727 Synopsis: 728 #include <petscsys.h> 729 PetscErrorCode PetscCalloc6(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4,size_t m5,type **r5,size_t m6,type **r6) 730 731 Not Collective 732 733 Input Parameters: 734 + m1 - number of elements to allocate in 1st chunk (may be zero) 735 . m2 - number of elements to allocate in 2nd chunk (may be zero) 736 . m3 - number of elements to allocate in 3rd chunk (may be zero) 737 . m4 - number of elements to allocate in 4th chunk (may be zero) 738 . m5 - number of elements to allocate in 5th chunk (may be zero) 739 - m6 - number of elements to allocate in 6th chunk (may be zero) 740 741 Output Parameters: 742 + r1 - memory allocated in first chunk 743 . r2 - memory allocated in second chunk 744 . r3 - memory allocated in third chunk 745 . r4 - memory allocated in fourth chunk 746 . r5 - memory allocated in fifth chunk 747 - r6 - memory allocated in sixth chunk 748 749 Level: developer 750 751 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscMalloc6()`, `PetscFree6()` 752 M*/ 753 #define PetscCalloc6(m1, r1, m2, r2, m3, r3, m4, r4, m5, r5, m6, r6) \ 754 PetscMallocA(6, PETSC_TRUE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1), ((size_t)((size_t)m2) * sizeof(**(r2))), (r2), ((size_t)((size_t)m3) * sizeof(**(r3))), (r3), ((size_t)((size_t)m4) * sizeof(**(r4))), (r4), ((size_t)((size_t)m5) * sizeof(**(r5))), (r5), ((size_t)((size_t)m6) * sizeof(**(r6))), (r6)) 755 756 /*MC 757 PetscMalloc7 - Allocates 7 arrays of memory, all aligned to `PETSC_MEMALIGN` 758 759 Synopsis: 760 #include <petscsys.h> 761 PetscErrorCode PetscMalloc7(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4,size_t m5,type **r5,size_t m6,type **r6,size_t m7,type **r7) 762 763 Not Collective 764 765 Input Parameters: 766 + m1 - number of elements to allocate in 1st chunk (may be zero) 767 . m2 - number of elements to allocate in 2nd chunk (may be zero) 768 . m3 - number of elements to allocate in 3rd chunk (may be zero) 769 . m4 - number of elements to allocate in 4th chunk (may be zero) 770 . m5 - number of elements to allocate in 5th chunk (may be zero) 771 . m6 - number of elements to allocate in 6th chunk (may be zero) 772 - m7 - number of elements to allocate in 7th chunk (may be zero) 773 774 Output Parameters: 775 + r1 - memory allocated in first chunk 776 . r2 - memory allocated in second chunk 777 . r3 - memory allocated in third chunk 778 . r4 - memory allocated in fourth chunk 779 . r5 - memory allocated in fifth chunk 780 . r6 - memory allocated in sixth chunk 781 - r7 - memory allocated in seventh chunk 782 783 Level: developer 784 785 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscCalloc7()`, `PetscFree7()` 786 M*/ 787 #define PetscMalloc7(m1, r1, m2, r2, m3, r3, m4, r4, m5, r5, m6, r6, m7, r7) \ 788 PetscMallocA(7, PETSC_FALSE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1), ((size_t)((size_t)m2) * sizeof(**(r2))), (r2), ((size_t)((size_t)m3) * sizeof(**(r3))), (r3), ((size_t)((size_t)m4) * sizeof(**(r4))), (r4), ((size_t)((size_t)m5) * sizeof(**(r5))), (r5), ((size_t)((size_t)m6) * sizeof(**(r6))), (r6), ((size_t)((size_t)m7) * sizeof(**(r7))), (r7)) 789 790 /*MC 791 PetscCalloc7 - Allocates 7 cleared (zeroed) arrays of memory, all aligned to `PETSC_MEMALIGN` 792 793 Synopsis: 794 #include <petscsys.h> 795 PetscErrorCode PetscCalloc7(size_t m1,type **r1,size_t m2,type **r2,size_t m3,type **r3,size_t m4,type **r4,size_t m5,type **r5,size_t m6,type **r6,size_t m7,type **r7) 796 797 Not Collective 798 799 Input Parameters: 800 + m1 - number of elements to allocate in 1st chunk (may be zero) 801 . m2 - number of elements to allocate in 2nd chunk (may be zero) 802 . m3 - number of elements to allocate in 3rd chunk (may be zero) 803 . m4 - number of elements to allocate in 4th chunk (may be zero) 804 . m5 - number of elements to allocate in 5th chunk (may be zero) 805 . m6 - number of elements to allocate in 6th chunk (may be zero) 806 - m7 - number of elements to allocate in 7th chunk (may be zero) 807 808 Output Parameters: 809 + r1 - memory allocated in first chunk 810 . r2 - memory allocated in second chunk 811 . r3 - memory allocated in third chunk 812 . r4 - memory allocated in fourth chunk 813 . r5 - memory allocated in fifth chunk 814 . r6 - memory allocated in sixth chunk 815 - r7 - memory allocated in seventh chunk 816 817 Level: developer 818 819 .seealso: `PetscFree()`, `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscMalloc7()`, `PetscFree7()` 820 M*/ 821 #define PetscCalloc7(m1, r1, m2, r2, m3, r3, m4, r4, m5, r5, m6, r6, m7, r7) \ 822 PetscMallocA(7, PETSC_TRUE, __LINE__, PETSC_FUNCTION_NAME, __FILE__, ((size_t)((size_t)m1) * sizeof(**(r1))), (r1), ((size_t)((size_t)m2) * sizeof(**(r2))), (r2), ((size_t)((size_t)m3) * sizeof(**(r3))), (r3), ((size_t)((size_t)m4) * sizeof(**(r4))), (r4), ((size_t)((size_t)m5) * sizeof(**(r5))), (r5), ((size_t)((size_t)m6) * sizeof(**(r6))), (r6), ((size_t)((size_t)m7) * sizeof(**(r7))), (r7)) 823 824 /*MC 825 PetscNew - Allocates memory of a particular type, zeros the memory! Aligned to `PETSC_MEMALIGN` 826 827 Synopsis: 828 #include <petscsys.h> 829 PetscErrorCode PetscNew(type **result) 830 831 Not Collective 832 833 Output Parameter: 834 . result - memory allocated, sized to match pointer type 835 836 Level: beginner 837 838 .seealso: `PetscFree()`, `PetscMalloc()`, `PetscCalloc1()`, `PetscMalloc1()` 839 M*/ 840 #define PetscNew(b) PetscCalloc1(1, (b)) 841 842 #define PetscNewLog(o, b) PETSC_DEPRECATED_MACRO("GCC warning \"PetscNewLog is deprecated, use PetscNew() instead (since version 3.18)\"") PetscNew((b)) 843 844 /*MC 845 PetscFree - Frees memory 846 847 Synopsis: 848 #include <petscsys.h> 849 PetscErrorCode PetscFree(void *memory) 850 851 Not Collective 852 853 Input Parameter: 854 . memory - memory to free (the pointer is ALWAYS set to `NULL` upon success) 855 856 Level: beginner 857 858 Note: 859 Do not free memory obtained with `PetscMalloc2()`, `PetscCalloc2()` etc, they must be freed with `PetscFree2()` etc. 860 861 It is safe to call `PetscFree()` on a `NULL` pointer. 862 863 .seealso: `PetscNew()`, `PetscMalloc()`, `PetscMalloc1()`, `PetscCalloc1()` 864 M*/ 865 #define PetscFree(a) ((PetscErrorCode)((*PetscTrFree)((void *)(a), __LINE__, PETSC_FUNCTION_NAME, __FILE__) || ((a) = PETSC_NULLPTR, PETSC_SUCCESS))) 866 867 /*MC 868 PetscFree2 - Frees 2 chunks of memory obtained with `PetscMalloc2()` 869 870 Synopsis: 871 #include <petscsys.h> 872 PetscErrorCode PetscFree2(void *memory1,void *memory2) 873 874 Not Collective 875 876 Input Parameters: 877 + memory1 - memory to free 878 - memory2 - 2nd memory to free 879 880 Level: developer 881 882 Note: 883 Memory must have been obtained with `PetscMalloc2()` 884 885 .seealso: `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscFree()` 886 M*/ 887 #define PetscFree2(m1, m2) PetscFreeA(2, __LINE__, PETSC_FUNCTION_NAME, __FILE__, &(m1), &(m2)) 888 889 /*MC 890 PetscFree3 - Frees 3 chunks of memory obtained with `PetscMalloc3()` 891 892 Synopsis: 893 #include <petscsys.h> 894 PetscErrorCode PetscFree3(void *memory1,void *memory2,void *memory3) 895 896 Not Collective 897 898 Input Parameters: 899 + memory1 - memory to free 900 . memory2 - 2nd memory to free 901 - memory3 - 3rd memory to free 902 903 Level: developer 904 905 Note: 906 Memory must have been obtained with `PetscMalloc3()` 907 908 .seealso: `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscFree()`, `PetscMalloc3()` 909 M*/ 910 #define PetscFree3(m1, m2, m3) PetscFreeA(3, __LINE__, PETSC_FUNCTION_NAME, __FILE__, &(m1), &(m2), &(m3)) 911 912 /*MC 913 PetscFree4 - Frees 4 chunks of memory obtained with `PetscMalloc4()` 914 915 Synopsis: 916 #include <petscsys.h> 917 PetscErrorCode PetscFree4(void *m1,void *m2,void *m3,void *m4) 918 919 Not Collective 920 921 Input Parameters: 922 + m1 - memory to free 923 . m2 - 2nd memory to free 924 . m3 - 3rd memory to free 925 - m4 - 4th memory to free 926 927 Level: developer 928 929 Note: 930 Memory must have been obtained with `PetscMalloc4()` 931 932 .seealso: `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscFree()`, `PetscMalloc3()`, `PetscMalloc4()` 933 M*/ 934 #define PetscFree4(m1, m2, m3, m4) PetscFreeA(4, __LINE__, PETSC_FUNCTION_NAME, __FILE__, &(m1), &(m2), &(m3), &(m4)) 935 936 /*MC 937 PetscFree5 - Frees 5 chunks of memory obtained with `PetscMalloc5()` 938 939 Synopsis: 940 #include <petscsys.h> 941 PetscErrorCode PetscFree5(void *m1,void *m2,void *m3,void *m4,void *m5) 942 943 Not Collective 944 945 Input Parameters: 946 + m1 - memory to free 947 . m2 - 2nd memory to free 948 . m3 - 3rd memory to free 949 . m4 - 4th memory to free 950 - m5 - 5th memory to free 951 952 Level: developer 953 954 Note: 955 Memory must have been obtained with `PetscMalloc5()` 956 957 .seealso: `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscFree()`, `PetscMalloc3()`, `PetscMalloc4()`, `PetscMalloc5()` 958 M*/ 959 #define PetscFree5(m1, m2, m3, m4, m5) PetscFreeA(5, __LINE__, PETSC_FUNCTION_NAME, __FILE__, &(m1), &(m2), &(m3), &(m4), &(m5)) 960 961 /*MC 962 PetscFree6 - Frees 6 chunks of memory obtained with `PetscMalloc6()` 963 964 Synopsis: 965 #include <petscsys.h> 966 PetscErrorCode PetscFree6(void *m1,void *m2,void *m3,void *m4,void *m5,void *m6) 967 968 Not Collective 969 970 Input Parameters: 971 + m1 - memory to free 972 . m2 - 2nd memory to free 973 . m3 - 3rd memory to free 974 . m4 - 4th memory to free 975 . m5 - 5th memory to free 976 - m6 - 6th memory to free 977 978 Level: developer 979 980 Note: 981 Memory must have been obtained with `PetscMalloc6()` 982 983 .seealso: `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscFree()`, `PetscMalloc3()`, `PetscMalloc4()`, `PetscMalloc5()`, `PetscMalloc6()` 984 M*/ 985 #define PetscFree6(m1, m2, m3, m4, m5, m6) PetscFreeA(6, __LINE__, PETSC_FUNCTION_NAME, __FILE__, &(m1), &(m2), &(m3), &(m4), &(m5), &(m6)) 986 987 /*MC 988 PetscFree7 - Frees 7 chunks of memory obtained with `PetscMalloc7()` 989 990 Synopsis: 991 #include <petscsys.h> 992 PetscErrorCode PetscFree7(void *m1,void *m2,void *m3,void *m4,void *m5,void *m6,void *m7) 993 994 Not Collective 995 996 Input Parameters: 997 + m1 - memory to free 998 . m2 - 2nd memory to free 999 . m3 - 3rd memory to free 1000 . m4 - 4th memory to free 1001 . m5 - 5th memory to free 1002 . m6 - 6th memory to free 1003 - m7 - 7th memory to free 1004 1005 Level: developer 1006 1007 Note: 1008 Memory must have been obtained with `PetscMalloc7()` 1009 1010 .seealso: `PetscNew()`, `PetscMalloc()`, `PetscMalloc2()`, `PetscFree()`, `PetscMalloc3()`, `PetscMalloc4()`, `PetscMalloc5()`, `PetscMalloc6()`, 1011 `PetscMalloc7()` 1012 M*/ 1013 #define PetscFree7(m1, m2, m3, m4, m5, m6, m7) PetscFreeA(7, __LINE__, PETSC_FUNCTION_NAME, __FILE__, &(m1), &(m2), &(m3), &(m4), &(m5), &(m6), &(m7)) 1014 1015 PETSC_EXTERN PetscErrorCode PetscMallocA(int, PetscBool, int, const char *, const char *, size_t, void *, ...); 1016 PETSC_EXTERN PetscErrorCode PetscFreeA(int, int, const char *, const char *, void *, ...); 1017 PETSC_EXTERN PetscErrorCode (*PetscTrMalloc)(size_t, PetscBool, int, const char[], const char[], void **); 1018 PETSC_EXTERN PetscErrorCode (*PetscTrFree)(void *, int, const char[], const char[]); 1019 PETSC_EXTERN PetscErrorCode (*PetscTrRealloc)(size_t, int, const char[], const char[], void **); 1020 PETSC_EXTERN PetscErrorCode PetscMallocSetCoalesce(PetscBool); 1021 PETSC_EXTERN PetscErrorCode PetscMallocSet(PetscErrorCode (*)(size_t, PetscBool, int, const char[], const char[], void **), PetscErrorCode (*)(void *, int, const char[], const char[]), PetscErrorCode (*)(size_t, int, const char[], const char[], void **)); 1022 PETSC_EXTERN PetscErrorCode PetscMallocClear(void); 1023 1024 /* 1025 Unlike PetscMallocSet and PetscMallocClear which overwrite the existing settings, these two functions save the previous choice of allocator, and should be used in pair. 1026 */ 1027 PETSC_EXTERN PetscErrorCode PetscMallocSetDRAM(void); 1028 PETSC_EXTERN PetscErrorCode PetscMallocResetDRAM(void); 1029 #if defined(PETSC_HAVE_CUDA) 1030 PETSC_EXTERN PetscErrorCode PetscMallocSetCUDAHost(void); 1031 PETSC_EXTERN PetscErrorCode PetscMallocResetCUDAHost(void); 1032 #endif 1033 #if defined(PETSC_HAVE_HIP) 1034 PETSC_EXTERN PetscErrorCode PetscMallocSetHIPHost(void); 1035 PETSC_EXTERN PetscErrorCode PetscMallocResetHIPHost(void); 1036 #endif 1037 1038 #define MPIU_PETSCLOGDOUBLE MPI_DOUBLE 1039 #define MPIU_2PETSCLOGDOUBLE MPI_2DOUBLE_PRECISION 1040 1041 /* 1042 Routines for tracing memory corruption/bleeding with default PETSc memory allocation 1043 */ 1044 PETSC_EXTERN PetscErrorCode PetscMallocDump(FILE *); 1045 PETSC_EXTERN PetscErrorCode PetscMallocView(FILE *); 1046 PETSC_EXTERN PetscErrorCode PetscMallocGetCurrentUsage(PetscLogDouble *); 1047 PETSC_EXTERN PetscErrorCode PetscMallocGetMaximumUsage(PetscLogDouble *); 1048 PETSC_EXTERN PetscErrorCode PetscMallocPushMaximumUsage(int); 1049 PETSC_EXTERN PetscErrorCode PetscMallocPopMaximumUsage(int, PetscLogDouble *); 1050 PETSC_EXTERN PetscErrorCode PetscMallocSetDebug(PetscBool, PetscBool); 1051 PETSC_EXTERN PetscErrorCode PetscMallocGetDebug(PetscBool *, PetscBool *, PetscBool *); 1052 PETSC_EXTERN PetscErrorCode PetscMallocValidate(int, const char[], const char[]); 1053 PETSC_EXTERN PetscErrorCode PetscMallocViewSet(PetscLogDouble); 1054 PETSC_EXTERN PetscErrorCode PetscMallocViewGet(PetscBool *); 1055 PETSC_EXTERN PetscErrorCode PetscMallocLogRequestedSizeSet(PetscBool); 1056 PETSC_EXTERN PetscErrorCode PetscMallocLogRequestedSizeGet(PetscBool *); 1057 1058 PETSC_EXTERN PetscErrorCode PetscDataTypeToMPIDataType(PetscDataType, MPI_Datatype *); 1059 PETSC_EXTERN PetscErrorCode PetscMPIDataTypeToPetscDataType(MPI_Datatype, PetscDataType *); 1060 PETSC_EXTERN PetscErrorCode PetscDataTypeGetSize(PetscDataType, size_t *); 1061 PETSC_EXTERN PetscErrorCode PetscDataTypeFromString(const char *, PetscDataType *, PetscBool *); 1062 1063 /* 1064 These are MPI operations for MPI_Allreduce() etc 1065 */ 1066 PETSC_EXTERN MPI_Op MPIU_MAXSUM_OP; 1067 #if defined(PETSC_USE_REAL___FLOAT128) || defined(PETSC_USE_REAL___FP16) 1068 PETSC_EXTERN MPI_Op MPIU_SUM; 1069 PETSC_EXTERN MPI_Op MPIU_MAX; 1070 PETSC_EXTERN MPI_Op MPIU_MIN; 1071 #else 1072 #define MPIU_SUM MPI_SUM 1073 #define MPIU_MAX MPI_MAX 1074 #define MPIU_MIN MPI_MIN 1075 #endif 1076 PETSC_EXTERN MPI_Op Petsc_Garbage_SetIntersectOp; 1077 PETSC_EXTERN PetscErrorCode PetscMaxSum(MPI_Comm, const PetscInt[], PetscInt *, PetscInt *); 1078 1079 #if (defined(PETSC_HAVE_REAL___FLOAT128) && !defined(PETSC_SKIP_REAL___FLOAT128)) || (defined(PETSC_HAVE_REAL___FP16) && !defined(PETSC_SKIP_REAL___FP16)) 1080 /*MC 1081 MPIU_SUM___FP16___FLOAT128 - MPI_Op that acts as a replacement for `MPI_SUM` with 1082 custom `MPI_Datatype` `MPIU___FLOAT128`, `MPIU___COMPLEX128`, and `MPIU___FP16`. 1083 1084 Level: advanced 1085 1086 Developer Note: 1087 This should be unified with `MPIU_SUM` 1088 1089 .seealso: `MPIU_REAL`, `MPIU_SCALAR`, `MPIU_COMPLEX` 1090 M*/ 1091 PETSC_EXTERN MPI_Op MPIU_SUM___FP16___FLOAT128; 1092 #endif 1093 PETSC_EXTERN PetscErrorCode PetscMaxSum(MPI_Comm, const PetscInt[], PetscInt *, PetscInt *); 1094 1095 PETSC_EXTERN PetscErrorCode MPIULong_Send(void *, PetscInt, MPI_Datatype, PetscMPIInt, PetscMPIInt, MPI_Comm) PETSC_ATTRIBUTE_MPI_POINTER_WITH_TYPE(1, 3); 1096 PETSC_EXTERN PetscErrorCode MPIULong_Recv(void *, PetscInt, MPI_Datatype, PetscMPIInt, PetscMPIInt, MPI_Comm) PETSC_ATTRIBUTE_MPI_POINTER_WITH_TYPE(1, 3); 1097 1098 /* 1099 Defines PETSc error handling. 1100 */ 1101 #include <petscerror.h> 1102 1103 PETSC_EXTERN PetscBool PetscCIEnabled; /* code is running in the PETSc test harness CI */ 1104 PETSC_EXTERN PetscBool PetscCIEnabledPortableErrorOutput; /* error output is stripped to ensure portability of error messages across systems */ 1105 PETSC_EXTERN const char *PetscCIFilename(const char *); 1106 PETSC_EXTERN int PetscCILinenumber(int); 1107 1108 #define PETSC_SMALLEST_CLASSID ((PetscClassId)1211211) 1109 PETSC_EXTERN PetscClassId PETSC_LARGEST_CLASSID; 1110 PETSC_EXTERN PetscClassId PETSC_OBJECT_CLASSID; 1111 PETSC_EXTERN PetscErrorCode PetscClassIdRegister(const char[], PetscClassId *); 1112 PETSC_EXTERN PetscErrorCode PetscObjectGetId(PetscObject, PetscObjectId *); 1113 PETSC_EXTERN PetscErrorCode PetscObjectCompareId(PetscObject, PetscObjectId, PetscBool *); 1114 1115 /* 1116 Routines that get memory usage information from the OS 1117 */ 1118 PETSC_EXTERN PetscErrorCode PetscMemoryGetCurrentUsage(PetscLogDouble *); 1119 PETSC_EXTERN PetscErrorCode PetscMemoryGetMaximumUsage(PetscLogDouble *); 1120 PETSC_EXTERN PetscErrorCode PetscMemorySetGetMaximumUsage(void); 1121 PETSC_EXTERN PetscErrorCode PetscMemoryTrace(const char[]); 1122 1123 PETSC_EXTERN PetscErrorCode PetscSleep(PetscReal); 1124 1125 /* 1126 Initialization of PETSc 1127 */ 1128 PETSC_EXTERN PetscErrorCode PetscInitialize(int *, char ***, const char[], const char[]); 1129 PETSC_EXTERN PetscErrorCode PetscInitializeNoPointers(int, char **, const char[], const char[]); 1130 PETSC_EXTERN PetscErrorCode PetscInitializeNoArguments(void); 1131 PETSC_EXTERN PetscErrorCode PetscInitialized(PetscBool *); 1132 PETSC_EXTERN PetscErrorCode PetscFinalized(PetscBool *); 1133 PETSC_EXTERN PetscErrorCode PetscFinalize(void); 1134 PETSC_EXTERN PetscErrorCode PetscInitializeFortran(void); 1135 PETSC_EXTERN PetscErrorCode PetscGetArgs(int *, char ***); 1136 PETSC_EXTERN PetscErrorCode PetscGetArguments(char ***); 1137 PETSC_EXTERN PetscErrorCode PetscFreeArguments(char **); 1138 1139 PETSC_EXTERN PetscErrorCode PetscEnd(void); 1140 PETSC_EXTERN PetscErrorCode PetscSysInitializePackage(void); 1141 1142 PETSC_EXTERN PetscErrorCode PetscPythonInitialize(const char[], const char[]); 1143 PETSC_EXTERN PetscErrorCode PetscPythonFinalize(void); 1144 PETSC_EXTERN PetscErrorCode PetscPythonPrintError(void); 1145 PETSC_EXTERN PetscErrorCode PetscPythonMonitorSet(PetscObject, const char[]); 1146 1147 PETSC_EXTERN PetscErrorCode PetscMonitorCompare(PetscErrorCode (*)(void), void *, PetscErrorCode (*)(void **), PetscErrorCode (*)(void), void *, PetscErrorCode (*)(void **), PetscBool *); 1148 1149 /* 1150 These are so that in extern C code we can caste function pointers to non-extern C 1151 function pointers. Since the regular C++ code expects its function pointers to be C++ 1152 */ 1153 PETSC_EXTERN_TYPEDEF typedef void (**PetscVoidStarFunction)(void); 1154 PETSC_EXTERN_TYPEDEF typedef void (*PetscVoidFunction)(void); 1155 PETSC_EXTERN_TYPEDEF typedef PetscErrorCode (*PetscErrorCodeFunction)(void); 1156 1157 /* 1158 Functions that can act on any PETSc object. 1159 */ 1160 PETSC_EXTERN PetscErrorCode PetscObjectDestroy(PetscObject *); 1161 PETSC_EXTERN PetscErrorCode PetscObjectGetComm(PetscObject, MPI_Comm *); 1162 PETSC_EXTERN PetscErrorCode PetscObjectGetClassId(PetscObject, PetscClassId *); 1163 PETSC_EXTERN PetscErrorCode PetscObjectGetClassName(PetscObject, const char *[]); 1164 PETSC_EXTERN PetscErrorCode PetscObjectGetType(PetscObject, const char *[]); 1165 PETSC_EXTERN PetscErrorCode PetscObjectSetName(PetscObject, const char[]); 1166 PETSC_EXTERN PetscErrorCode PetscObjectGetName(PetscObject, const char *[]); 1167 PETSC_EXTERN PetscErrorCode PetscObjectSetTabLevel(PetscObject, PetscInt); 1168 PETSC_EXTERN PetscErrorCode PetscObjectGetTabLevel(PetscObject, PetscInt *); 1169 PETSC_EXTERN PetscErrorCode PetscObjectIncrementTabLevel(PetscObject, PetscObject, PetscInt); 1170 PETSC_EXTERN PetscErrorCode PetscObjectReference(PetscObject); 1171 PETSC_EXTERN PetscErrorCode PetscObjectGetReference(PetscObject, PetscInt *); 1172 PETSC_EXTERN PetscErrorCode PetscObjectDereference(PetscObject); 1173 PETSC_EXTERN PetscErrorCode PetscObjectGetNewTag(PetscObject, PetscMPIInt *); 1174 PETSC_EXTERN PetscErrorCode PetscObjectCompose(PetscObject, const char[], PetscObject); 1175 PETSC_EXTERN PetscErrorCode PetscObjectRemoveReference(PetscObject, const char[]); 1176 PETSC_EXTERN PetscErrorCode PetscObjectQuery(PetscObject, const char[], PetscObject *); 1177 PETSC_EXTERN PetscErrorCode PetscObjectComposeFunction_Private(PetscObject, const char[], void (*)(void)); 1178 #define PetscObjectComposeFunction(a, b, ...) PetscObjectComposeFunction_Private((a), (b), (PetscVoidFunction)(__VA_ARGS__)) 1179 PETSC_EXTERN PetscErrorCode PetscObjectSetFromOptions(PetscObject); 1180 PETSC_EXTERN PetscErrorCode PetscObjectSetUp(PetscObject); 1181 PETSC_EXTERN PetscErrorCode PetscObjectSetPrintedOptions(PetscObject); 1182 PETSC_EXTERN PetscErrorCode PetscObjectInheritPrintedOptions(PetscObject, PetscObject); 1183 PETSC_EXTERN PetscErrorCode PetscCommGetNewTag(MPI_Comm, PetscMPIInt *); 1184 1185 #include <petscviewertypes.h> 1186 #include <petscoptions.h> 1187 1188 PETSC_EXTERN PetscErrorCode PetscMallocTraceSet(PetscViewer, PetscBool, PetscLogDouble); 1189 PETSC_EXTERN PetscErrorCode PetscMallocTraceGet(PetscBool *); 1190 1191 PETSC_EXTERN PetscErrorCode PetscObjectsListGetGlobalNumbering(MPI_Comm, PetscInt, PetscObject *, PetscInt *, PetscInt *); 1192 1193 PETSC_EXTERN PetscErrorCode PetscMemoryView(PetscViewer, const char[]); 1194 PETSC_EXTERN PetscErrorCode PetscObjectPrintClassNamePrefixType(PetscObject, PetscViewer); 1195 PETSC_EXTERN PetscErrorCode PetscObjectView(PetscObject, PetscViewer); 1196 #define PetscObjectQueryFunction(obj, name, fptr) PetscObjectQueryFunction_Private((obj), (name), (PetscVoidFunction *)(fptr)) 1197 PETSC_EXTERN PetscErrorCode PetscObjectQueryFunction_Private(PetscObject, const char[], void (**)(void)); 1198 PETSC_EXTERN PetscErrorCode PetscObjectSetOptionsPrefix(PetscObject, const char[]); 1199 PETSC_EXTERN PetscErrorCode PetscObjectAppendOptionsPrefix(PetscObject, const char[]); 1200 PETSC_EXTERN PetscErrorCode PetscObjectPrependOptionsPrefix(PetscObject, const char[]); 1201 PETSC_EXTERN PetscErrorCode PetscObjectGetOptionsPrefix(PetscObject, const char *[]); 1202 PETSC_EXTERN PetscErrorCode PetscObjectChangeTypeName(PetscObject, const char[]); 1203 PETSC_EXTERN PetscErrorCode PetscObjectRegisterDestroy(PetscObject); 1204 PETSC_EXTERN PetscErrorCode PetscObjectRegisterDestroyAll(void); 1205 PETSC_EXTERN PetscErrorCode PetscObjectViewFromOptions(PetscObject, PetscObject, const char[]); 1206 PETSC_EXTERN PetscErrorCode PetscObjectName(PetscObject); 1207 PETSC_EXTERN PetscErrorCode PetscObjectTypeCompare(PetscObject, const char[], PetscBool *); 1208 PETSC_EXTERN PetscErrorCode PetscObjectObjectTypeCompare(PetscObject, PetscObject, PetscBool *); 1209 PETSC_EXTERN PetscErrorCode PetscObjectBaseTypeCompare(PetscObject, const char[], PetscBool *); 1210 PETSC_EXTERN PetscErrorCode PetscObjectTypeCompareAny(PetscObject, PetscBool *, const char[], ...); 1211 PETSC_EXTERN PetscErrorCode PetscObjectBaseTypeCompareAny(PetscObject, PetscBool *, const char[], ...); 1212 PETSC_EXTERN PetscErrorCode PetscRegisterFinalize(PetscErrorCode (*)(void)); 1213 PETSC_EXTERN PetscErrorCode PetscRegisterFinalizeAll(void); 1214 1215 #if defined(PETSC_HAVE_SAWS) 1216 PETSC_EXTERN PetscErrorCode PetscSAWsBlock(void); 1217 PETSC_EXTERN PetscErrorCode PetscObjectSAWsViewOff(PetscObject); 1218 PETSC_EXTERN PetscErrorCode PetscObjectSAWsSetBlock(PetscObject, PetscBool); 1219 PETSC_EXTERN PetscErrorCode PetscObjectSAWsBlock(PetscObject); 1220 PETSC_EXTERN PetscErrorCode PetscObjectSAWsGrantAccess(PetscObject); 1221 PETSC_EXTERN PetscErrorCode PetscObjectSAWsTakeAccess(PetscObject); 1222 PETSC_EXTERN void PetscStackSAWsGrantAccess(void); 1223 PETSC_EXTERN void PetscStackSAWsTakeAccess(void); 1224 PETSC_EXTERN PetscErrorCode PetscStackViewSAWs(void); 1225 PETSC_EXTERN PetscErrorCode PetscStackSAWsViewOff(void); 1226 1227 #else 1228 #define PetscSAWsBlock() PETSC_SUCCESS 1229 #define PetscObjectSAWsViewOff(obj) PETSC_SUCCESS 1230 #define PetscObjectSAWsSetBlock(obj, flg) PETSC_SUCCESS 1231 #define PetscObjectSAWsBlock(obj) PETSC_SUCCESS 1232 #define PetscObjectSAWsGrantAccess(obj) PETSC_SUCCESS 1233 #define PetscObjectSAWsTakeAccess(obj) PETSC_SUCCESS 1234 #define PetscStackViewSAWs() PETSC_SUCCESS 1235 #define PetscStackSAWsViewOff() PETSC_SUCCESS 1236 #define PetscStackSAWsTakeAccess() 1237 #define PetscStackSAWsGrantAccess() 1238 1239 #endif 1240 1241 PETSC_EXTERN PetscErrorCode PetscDLOpen(const char[], PetscDLMode, PetscDLHandle *); 1242 PETSC_EXTERN PetscErrorCode PetscDLClose(PetscDLHandle *); 1243 PETSC_EXTERN PetscErrorCode PetscDLSym(PetscDLHandle, const char[], void **); 1244 PETSC_EXTERN PetscErrorCode PetscDLAddr(void (*)(void), char **); 1245 #ifdef PETSC_HAVE_CXX 1246 PETSC_EXTERN PetscErrorCode PetscDemangleSymbol(const char *, char **); 1247 #endif 1248 1249 PETSC_EXTERN PetscErrorCode PetscMallocGetStack(void *, PetscStack **); 1250 1251 PETSC_EXTERN PetscErrorCode PetscObjectsDump(FILE *, PetscBool); 1252 PETSC_EXTERN PetscErrorCode PetscObjectListDestroy(PetscObjectList *); 1253 PETSC_EXTERN PetscErrorCode PetscObjectListFind(PetscObjectList, const char[], PetscObject *); 1254 PETSC_EXTERN PetscErrorCode PetscObjectListReverseFind(PetscObjectList, PetscObject, char **, PetscBool *); 1255 PETSC_EXTERN PetscErrorCode PetscObjectListAdd(PetscObjectList *, const char[], PetscObject); 1256 PETSC_EXTERN PetscErrorCode PetscObjectListRemoveReference(PetscObjectList *, const char[]); 1257 PETSC_EXTERN PetscErrorCode PetscObjectListDuplicate(PetscObjectList, PetscObjectList *); 1258 1259 /* 1260 Dynamic library lists. Lists of names of routines in objects or in dynamic 1261 link libraries that will be loaded as needed. 1262 */ 1263 1264 #define PetscFunctionListAdd(list, name, fptr) PetscFunctionListAdd_Private((list), (name), (PetscVoidFunction)(fptr)) 1265 PETSC_EXTERN PetscErrorCode PetscFunctionListAdd_Private(PetscFunctionList *, const char[], PetscVoidFunction); 1266 PETSC_EXTERN PetscErrorCode PetscFunctionListDestroy(PetscFunctionList *); 1267 PETSC_EXTERN PetscErrorCode PetscFunctionListClear(PetscFunctionList); 1268 #define PetscFunctionListFind(list, name, fptr) PetscFunctionListFind_Private((list), (name), (PetscVoidFunction *)(fptr)) 1269 PETSC_EXTERN PetscErrorCode PetscFunctionListFind_Private(PetscFunctionList, const char[], PetscVoidFunction *); 1270 PETSC_EXTERN PetscErrorCode PetscFunctionListPrintTypes(MPI_Comm, FILE *, const char[], const char[], const char[], const char[], PetscFunctionList, const char[], const char[]); 1271 PETSC_EXTERN PetscErrorCode PetscFunctionListDuplicate(PetscFunctionList, PetscFunctionList *); 1272 PETSC_EXTERN PetscErrorCode PetscFunctionListView(PetscFunctionList, PetscViewer); 1273 PETSC_EXTERN PetscErrorCode PetscFunctionListGet(PetscFunctionList, const char ***, int *); 1274 PETSC_EXTERN PetscErrorCode PetscFunctionListPrintNonEmpty(PetscFunctionList); 1275 PETSC_EXTERN PetscErrorCode PetscFunctionListPrintAll(void); 1276 1277 PETSC_EXTERN PetscDLLibrary PetscDLLibrariesLoaded; 1278 PETSC_EXTERN PetscErrorCode PetscDLLibraryAppend(MPI_Comm, PetscDLLibrary *, const char[]); 1279 PETSC_EXTERN PetscErrorCode PetscDLLibraryPrepend(MPI_Comm, PetscDLLibrary *, const char[]); 1280 PETSC_EXTERN PetscErrorCode PetscDLLibrarySym(MPI_Comm, PetscDLLibrary *, const char[], const char[], void **); 1281 PETSC_EXTERN PetscErrorCode PetscDLLibraryPrintPath(PetscDLLibrary); 1282 PETSC_EXTERN PetscErrorCode PetscDLLibraryRetrieve(MPI_Comm, const char[], char *, size_t, PetscBool *); 1283 PETSC_EXTERN PetscErrorCode PetscDLLibraryOpen(MPI_Comm, const char[], PetscDLLibrary *); 1284 PETSC_EXTERN PetscErrorCode PetscDLLibraryClose(PetscDLLibrary); 1285 1286 /* 1287 Useful utility routines 1288 */ 1289 PETSC_EXTERN PetscErrorCode PetscSplitOwnership(MPI_Comm, PetscInt *, PetscInt *); 1290 PETSC_EXTERN PetscErrorCode PetscSplitOwnershipBlock(MPI_Comm, PetscInt, PetscInt *, PetscInt *); 1291 PETSC_EXTERN PetscErrorCode PetscSplitOwnershipEqual(MPI_Comm, PetscInt *, PetscInt *); 1292 PETSC_EXTERN PetscErrorCode PetscSequentialPhaseBegin(MPI_Comm, PetscMPIInt); 1293 PETSC_EXTERN PetscErrorCode PetscSequentialPhaseEnd(MPI_Comm, PetscMPIInt); 1294 PETSC_EXTERN PetscErrorCode PetscBarrier(PetscObject); 1295 PETSC_EXTERN PetscErrorCode PetscMPIDump(FILE *); 1296 PETSC_EXTERN PetscErrorCode PetscGlobalMinMaxInt(MPI_Comm, const PetscInt[2], PetscInt[2]); 1297 PETSC_EXTERN PetscErrorCode PetscGlobalMinMaxReal(MPI_Comm, const PetscReal[2], PetscReal[2]); 1298 1299 /*MC 1300 PetscNot - negates a logical type value and returns result as a `PetscBool` 1301 1302 Level: beginner 1303 1304 Note: 1305 This is useful in cases like 1306 .vb 1307 int *a; 1308 PetscBool flag = PetscNot(a) 1309 .ve 1310 where !a would not return a `PetscBool` because we cannot provide a cast from int to `PetscBool` in C. 1311 1312 .seealso: `PetscBool`, `PETSC_TRUE`, `PETSC_FALSE` 1313 M*/ 1314 #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE) 1315 1316 /*MC 1317 PetscHelpPrintf - Prints help messages. 1318 1319 Synopsis: 1320 #include <petscsys.h> 1321 PetscErrorCode (*PetscHelpPrintf)(MPI_Comm comm, const char format[],args); 1322 1323 Not Collective, only applies on MPI rank 0; No Fortran Support 1324 1325 Input Parameters: 1326 + comm - the MPI communicator over which the help message is printed 1327 . format - the usual printf() format string 1328 - args - arguments to be printed 1329 1330 Level: developer 1331 1332 Note: 1333 You can change how help messages are printed by replacing the function pointer with a function that does not simply write to stdout. 1334 1335 To use, write your own function, for example, 1336 .vb 1337 PetscErrorCode mypetschelpprintf(MPI_Comm comm,const char format[],....) 1338 { 1339 PetscFunctionReturn(PETSC_SUCCESS); 1340 } 1341 .ve 1342 then do the assignment 1343 $ PetscHelpPrintf = mypetschelpprintf; 1344 You can do the assignment before `PetscInitialize()`. 1345 1346 The default routine used is called `PetscHelpPrintfDefault()`. 1347 1348 .seealso: `PetscFPrintf()`, `PetscSynchronizedPrintf()`, `PetscErrorPrintf()`, `PetscHelpPrintfDefault()` 1349 M*/ 1350 PETSC_EXTERN PetscErrorCode (*PetscHelpPrintf)(MPI_Comm, const char[], ...) PETSC_ATTRIBUTE_FORMAT(2, 3); 1351 1352 /* 1353 Defines PETSc profiling. 1354 */ 1355 #include <petsclog.h> 1356 1357 /* 1358 Simple PETSc parallel IO for ASCII printing 1359 */ 1360 PETSC_EXTERN PetscErrorCode PetscFixFilename(const char[], char[]); 1361 PETSC_EXTERN PetscErrorCode PetscFOpen(MPI_Comm, const char[], const char[], FILE **); 1362 PETSC_EXTERN PetscErrorCode PetscFClose(MPI_Comm, FILE *); 1363 PETSC_EXTERN PetscErrorCode PetscFPrintf(MPI_Comm, FILE *, const char[], ...) PETSC_ATTRIBUTE_FORMAT(3, 4); 1364 PETSC_EXTERN PetscErrorCode PetscFFlush(FILE *); 1365 PETSC_EXTERN PetscErrorCode PetscPrintf(MPI_Comm, const char[], ...) PETSC_ATTRIBUTE_FORMAT(2, 3); 1366 PETSC_EXTERN PetscErrorCode PetscSNPrintf(char *, size_t, const char[], ...) PETSC_ATTRIBUTE_FORMAT(3, 4); 1367 PETSC_EXTERN PetscErrorCode PetscSNPrintfCount(char *, size_t, const char[], size_t *, ...) PETSC_ATTRIBUTE_FORMAT(3, 5); 1368 PETSC_EXTERN PetscErrorCode PetscFormatRealArray(char[], size_t, const char *, PetscInt, const PetscReal[]); 1369 1370 PETSC_EXTERN PetscErrorCode PetscErrorPrintfDefault(const char[], ...) PETSC_ATTRIBUTE_FORMAT(1, 2); 1371 PETSC_EXTERN PetscErrorCode PetscErrorPrintfNone(const char[], ...) PETSC_ATTRIBUTE_FORMAT(1, 2); 1372 PETSC_EXTERN PetscErrorCode PetscHelpPrintfDefault(MPI_Comm, const char[], ...) PETSC_ATTRIBUTE_FORMAT(2, 3); 1373 1374 PETSC_EXTERN PetscErrorCode PetscFormatConvertGetSize(const char *, size_t *); 1375 PETSC_EXTERN PetscErrorCode PetscFormatConvert(const char *, char *); 1376 1377 #if defined(PETSC_HAVE_POPEN) 1378 PETSC_EXTERN PetscErrorCode PetscPOpen(MPI_Comm, const char[], const char[], const char[], FILE **); 1379 PETSC_EXTERN PetscErrorCode PetscPClose(MPI_Comm, FILE *); 1380 PETSC_EXTERN PetscErrorCode PetscPOpenSetMachine(const char[]); 1381 #endif 1382 1383 PETSC_EXTERN PetscErrorCode PetscSynchronizedPrintf(MPI_Comm, const char[], ...) PETSC_ATTRIBUTE_FORMAT(2, 3); 1384 PETSC_EXTERN PetscErrorCode PetscSynchronizedFPrintf(MPI_Comm, FILE *, const char[], ...) PETSC_ATTRIBUTE_FORMAT(3, 4); 1385 PETSC_EXTERN PetscErrorCode PetscSynchronizedFlush(MPI_Comm, FILE *); 1386 PETSC_EXTERN PetscErrorCode PetscSynchronizedFGets(MPI_Comm, FILE *, size_t, char[]); 1387 PETSC_EXTERN PetscErrorCode PetscStartMatlab(MPI_Comm, const char[], const char[], FILE **); 1388 PETSC_EXTERN PetscErrorCode PetscStartJava(MPI_Comm, const char[], const char[], FILE **); 1389 PETSC_EXTERN PetscErrorCode PetscGetPetscDir(const char *[]); 1390 1391 PETSC_EXTERN PetscClassId PETSC_CONTAINER_CLASSID; 1392 PETSC_EXTERN PetscErrorCode PetscContainerGetPointer(PetscContainer, void **); 1393 PETSC_EXTERN PetscErrorCode PetscContainerSetPointer(PetscContainer, void *); 1394 PETSC_EXTERN PetscErrorCode PetscContainerDestroy(PetscContainer *); 1395 PETSC_EXTERN PetscErrorCode PetscContainerCreate(MPI_Comm, PetscContainer *); 1396 PETSC_EXTERN PetscErrorCode PetscContainerSetUserDestroy(PetscContainer, PetscErrorCode (*)(void *)); 1397 PETSC_EXTERN PetscErrorCode PetscContainerUserDestroyDefault(void *); 1398 1399 /* 1400 For use in debuggers 1401 */ 1402 PETSC_EXTERN PetscMPIInt PetscGlobalRank; 1403 PETSC_EXTERN PetscMPIInt PetscGlobalSize; 1404 PETSC_EXTERN PetscErrorCode PetscIntView(PetscInt, const PetscInt[], PetscViewer); 1405 PETSC_EXTERN PetscErrorCode PetscRealView(PetscInt, const PetscReal[], PetscViewer); 1406 PETSC_EXTERN PetscErrorCode PetscScalarView(PetscInt, const PetscScalar[], PetscViewer); 1407 1408 /* 1409 Basic memory and string operations. These are usually simple wrappers 1410 around the basic Unix system calls, but a few of them have additional 1411 functionality and/or error checking. 1412 */ 1413 #include <petscstring.h> 1414 1415 #include <stddef.h> 1416 #include <stdlib.h> 1417 1418 #if defined(PETSC_HAVE_XMMINTRIN_H) && !defined(__CUDACC__) 1419 #include <xmmintrin.h> 1420 #endif 1421 1422 #if defined(PETSC_CLANG_STATIC_ANALYZER) 1423 #define PetscPrefetchBlock(a, b, c, d) 1424 #else 1425 /*MC 1426 PetscPrefetchBlock - Prefetches a block of memory 1427 1428 Synopsis: 1429 #include <petscsys.h> 1430 void PetscPrefetchBlock(const anytype *a,size_t n,int rw,int t) 1431 1432 Not Collective 1433 1434 Input Parameters: 1435 + a - pointer to first element to fetch (any type but usually `PetscInt` or `PetscScalar`) 1436 . n - number of elements to fetch 1437 . rw - 1 if the memory will be written to, otherwise 0 (ignored by many processors) 1438 - t - temporal locality (PETSC_PREFETCH_HINT_{NTA,T0,T1,T2}), see note 1439 1440 Level: developer 1441 1442 Notes: 1443 The last two arguments (`rw` and `t`) must be compile-time constants. 1444 1445 Adopting Intel's x86/x86-64 conventions, there are four levels of temporal locality. Not all architectures offer 1446 equivalent locality hints, but the following macros are always defined to their closest analogue. 1447 + `PETSC_PREFETCH_HINT_NTA` - Non-temporal. Prefetches directly to L1, evicts to memory (skips higher level cache unless it was already there when prefetched). 1448 . `PETSC_PREFETCH_HINT_T0` - Fetch to all levels of cache and evict to the closest level. Use this when the memory will be reused regularly despite necessary eviction from L1. 1449 . `PETSC_PREFETCH_HINT_T1` - Fetch to level 2 and higher (not L1). 1450 - `PETSC_PREFETCH_HINT_T2` - Fetch to high-level cache only. (On many systems, T0 and T1 are equivalent.) 1451 1452 This function does nothing on architectures that do not support prefetch and never errors (even if passed an invalid 1453 address). 1454 1455 M*/ 1456 #define PetscPrefetchBlock(a, n, rw, t) \ 1457 do { \ 1458 const char *_p = (const char *)(a), *_end = (const char *)((a) + (n)); \ 1459 for (; _p < _end; _p += PETSC_LEVEL1_DCACHE_LINESIZE) PETSC_Prefetch(_p, (rw), (t)); \ 1460 } while (0) 1461 #endif 1462 /* 1463 Determine if some of the kernel computation routines use 1464 Fortran (rather than C) for the numerical calculations. On some machines 1465 and compilers (like complex numbers) the Fortran version of the routines 1466 is faster than the C/C++ versions. The flag --with-fortran-kernels 1467 should be used with ./configure to turn these on. 1468 */ 1469 #if defined(PETSC_USE_FORTRAN_KERNELS) 1470 1471 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTCRL) 1472 #define PETSC_USE_FORTRAN_KERNEL_MULTCRL 1473 #endif 1474 1475 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJPERM) 1476 #define PETSC_USE_FORTRAN_KERNEL_MULTAIJPERM 1477 #endif 1478 1479 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ) 1480 #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ 1481 #endif 1482 1483 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ) 1484 #define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ 1485 #endif 1486 1487 #if !defined(PETSC_USE_FORTRAN_KERNEL_NORM) 1488 #define PETSC_USE_FORTRAN_KERNEL_NORM 1489 #endif 1490 1491 #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY) 1492 #define PETSC_USE_FORTRAN_KERNEL_MAXPY 1493 #endif 1494 1495 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ) 1496 #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ 1497 #endif 1498 1499 #if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ) 1500 #define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ 1501 #endif 1502 1503 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ) 1504 #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ 1505 #endif 1506 1507 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ) 1508 #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ 1509 #endif 1510 1511 #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT) 1512 #define PETSC_USE_FORTRAN_KERNEL_MDOT 1513 #endif 1514 1515 #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY) 1516 #define PETSC_USE_FORTRAN_KERNEL_XTIMESY 1517 #endif 1518 1519 #if !defined(PETSC_USE_FORTRAN_KERNEL_AYPX) 1520 #define PETSC_USE_FORTRAN_KERNEL_AYPX 1521 #endif 1522 1523 #if !defined(PETSC_USE_FORTRAN_KERNEL_WAXPY) 1524 #define PETSC_USE_FORTRAN_KERNEL_WAXPY 1525 #endif 1526 1527 #endif 1528 1529 /* 1530 Macros for indicating code that should be compiled with a C interface, 1531 rather than a C++ interface. Any routines that are dynamically loaded 1532 (such as the PCCreate_XXX() routines) must be wrapped so that the name 1533 mangler does not change the functions symbol name. This just hides the 1534 ugly extern "C" {} wrappers. 1535 */ 1536 #if defined(__cplusplus) 1537 #define EXTERN_C_BEGIN extern "C" { 1538 #define EXTERN_C_END } 1539 #else 1540 #define EXTERN_C_BEGIN 1541 #define EXTERN_C_END 1542 #endif 1543 1544 /*MC 1545 MPI_Comm - the basic object used by MPI to determine which processes are involved in a 1546 communication 1547 1548 Level: beginner 1549 1550 Note: 1551 This manual page is a place-holder because MPICH does not have a manual page for `MPI_Comm` 1552 1553 .seealso: `PETSC_COMM_WORLD`, `PETSC_COMM_SELF` 1554 M*/ 1555 1556 #if defined(PETSC_HAVE_MPIIO) 1557 PETSC_EXTERN PetscErrorCode MPIU_File_write_all(MPI_File, void *, PetscMPIInt, MPI_Datatype, MPI_Status *) PETSC_ATTRIBUTE_MPI_POINTER_WITH_TYPE(2, 4); 1558 PETSC_EXTERN PetscErrorCode MPIU_File_read_all(MPI_File, void *, PetscMPIInt, MPI_Datatype, MPI_Status *) PETSC_ATTRIBUTE_MPI_POINTER_WITH_TYPE(2, 4); 1559 PETSC_EXTERN PetscErrorCode MPIU_File_write_at(MPI_File, MPI_Offset, void *, PetscMPIInt, MPI_Datatype, MPI_Status *) PETSC_ATTRIBUTE_MPI_POINTER_WITH_TYPE(3, 5); 1560 PETSC_EXTERN PetscErrorCode MPIU_File_read_at(MPI_File, MPI_Offset, void *, PetscMPIInt, MPI_Datatype, MPI_Status *) PETSC_ATTRIBUTE_MPI_POINTER_WITH_TYPE(3, 5); 1561 PETSC_EXTERN PetscErrorCode MPIU_File_write_at_all(MPI_File, MPI_Offset, void *, PetscMPIInt, MPI_Datatype, MPI_Status *) PETSC_ATTRIBUTE_MPI_POINTER_WITH_TYPE(3, 5); 1562 PETSC_EXTERN PetscErrorCode MPIU_File_read_at_all(MPI_File, MPI_Offset, void *, PetscMPIInt, MPI_Datatype, MPI_Status *) PETSC_ATTRIBUTE_MPI_POINTER_WITH_TYPE(3, 5); 1563 #endif 1564 1565 /*@C 1566 PetscIntCast - casts a `PetscInt64` (which is 64 bits in size) to a `PetscInt` (which may be 32-bits in size), generates an 1567 error if the `PetscInt` is not large enough to hold the number. 1568 1569 Not Collective; No Fortran Support 1570 1571 Input Parameter: 1572 . a - the `PetscInt64` value 1573 1574 Output Parameter: 1575 . b - the resulting `PetscInt` value 1576 1577 Level: advanced 1578 1579 Notes: 1580 If integers needed for the applications are too large to fit in 32-bit ints you can ./configure using `--with-64-bit-indices` to make `PetscInt` use 64-bit integers 1581 1582 .seealso: `PetscBLASInt`, `PetscMPIInt`, `PetscInt`, `PetscMPIIntCast()`, `PetscBLASIntCast()`, `PetscIntMultError()`, `PetscIntSumError()` 1583 @*/ 1584 static inline PetscErrorCode PetscIntCast(PetscInt64 a, PetscInt *b) 1585 { 1586 PetscFunctionBegin; 1587 *b = 0; 1588 // if using 64-bit indices already then this comparison is tautologically true 1589 PetscCheck(a < PETSC_MAX_INT, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "%" PetscInt64_FMT " is too big for PetscInt, you may need to ./configure using --with-64-bit-indices", a); 1590 *b = (PetscInt)a; 1591 PetscFunctionReturn(PETSC_SUCCESS); 1592 } 1593 1594 /*@C 1595 PetscCountCast - casts a `PetscCount` to a `PetscInt` (which may be 32-bits in size), generates an 1596 error if the `PetscInt` is not large enough to hold the number. 1597 1598 Not Collective; No Fortran Support 1599 1600 Input Parameter: 1601 . a - the `PetscCount` value 1602 1603 Output Parameter: 1604 . b - the resulting `PetscInt` value 1605 1606 Level: advanced 1607 1608 Note: 1609 If integers needed for the applications are too large to fit in 32-bit integers you can ./configure using `--with-64-bit-indices` to make `PetscInt` use 64-bit integers 1610 1611 .seealso: `PetscCount`, `PetscBLASInt`, `PetscMPIInt`, `PetscInt`, `PetscMPIIntCast()`, `PetscBLASIntCast()`, `PetscIntMultError()`, `PetscIntSumError()`, `PetscIntCast()` 1612 @*/ 1613 static inline PetscErrorCode PetscCountCast(PetscCount a, PetscInt *b) 1614 { 1615 PetscFunctionBegin; 1616 *b = 0; 1617 PetscCheck(sizeof(PetscCount) <= sizeof(PetscInt) || a <= PETSC_MAX_INT, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "%" PetscCount_FMT " is too big for PetscInt, you may need to ./configure using --with-64-bit-indices", a); 1618 *b = (PetscInt)a; 1619 PetscFunctionReturn(PETSC_SUCCESS); 1620 } 1621 1622 /*@C 1623 PetscBLASIntCast - casts a `PetscInt` (which may be 64-bits in size) to a `PetscBLASInt` (which may be 32-bits in size), generates an 1624 error if the `PetscBLASInt` is not large enough to hold the number. 1625 1626 Not Collective; No Fortran Support 1627 1628 Input Parameter: 1629 . a - the `PetscInt` value 1630 1631 Output Parameter: 1632 . b - the resulting `PetscBLASInt` value 1633 1634 Level: advanced 1635 1636 Note: 1637 Errors if the integer is negative since PETSc calls to BLAS/LAPACK never need to cast negative integer inputs 1638 1639 .seealso: `PetscBLASInt`, `PetscMPIInt`, `PetscInt`, `PetscMPIIntCast()`, `PetscIntCast()`, `PetscCountCast()` 1640 @*/ 1641 static inline PetscErrorCode PetscBLASIntCast(PetscInt a, PetscBLASInt *b) 1642 { 1643 PetscFunctionBegin; 1644 *b = 0; 1645 if (PetscDefined(USE_64BIT_INDICES) && !PetscDefined(HAVE_64BIT_BLAS_INDICES)) { 1646 PetscCheck(a <= PETSC_BLAS_INT_MAX, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "%" PetscInt_FMT " is too big for BLAS/LAPACK, which is restricted to 32-bit integers. Either you have an invalidly large integer error in your code or you must ./configure PETSc with --with-64-bit-blas-indices for the case you are running", a); 1647 } 1648 PetscCheck(a >= 0, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Passing negative integer to BLAS/LAPACK routine"); 1649 *b = (PetscBLASInt)a; 1650 PetscFunctionReturn(PETSC_SUCCESS); 1651 } 1652 1653 /*@C 1654 PetscCuBLASIntCast - like `PetscBLASIntCast()`, but for `PetscCuBLASInt`. 1655 1656 Not Collective; No Fortran Support 1657 1658 Input Parameter: 1659 . a - the `PetscInt` value 1660 1661 Output Parameter: 1662 . b - the resulting `PetscCuBLASInt` value 1663 1664 Level: advanced 1665 1666 Note: 1667 Errors if the integer is negative since PETSc calls to cuBLAS and friends never need to cast negative integer inputs 1668 1669 .seealso: `PetscCuBLASInt`, `PetscBLASInt`, `PetscMPIInt`, `PetscInt`, `PetscBLASIntCast()`, `PetscMPIIntCast()`, `PetscIntCast()` 1670 @*/ 1671 static inline PetscErrorCode PetscCuBLASIntCast(PetscInt a, PetscCuBLASInt *b) 1672 { 1673 PetscFunctionBegin; 1674 *b = 0; 1675 PetscCheck(a <= PETSC_CUBLAS_INT_MAX, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "%" PetscInt_FMT " is too big for cuBLAS, which is restricted to 32-bit integers.", a); 1676 PetscCheck(a >= 0, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Passing negative integer %" PetscInt_FMT "to cuBLAS routine", a); 1677 *b = (PetscCuBLASInt)a; 1678 PetscFunctionReturn(PETSC_SUCCESS); 1679 } 1680 1681 /*@C 1682 PetscHipBLASIntCast - like `PetscBLASIntCast()`, but for `PetscHipBLASInt`. 1683 1684 Not Collective; No Fortran Support 1685 1686 Input Parameter: 1687 . a - the `PetscInt` value 1688 1689 Output Parameter: 1690 . b - the resulting `PetscHipBLASInt` value 1691 1692 Level: advanced 1693 1694 Note: 1695 Errors if the integer is negative since PETSc calls to hipBLAS and friends never need to cast negative integer inputs 1696 1697 .seealso: `PetscHipBLASInt`, `PetscBLASInt`, `PetscMPIInt`, `PetscInt`, `PetscBLASIntCast()`, `PetscMPIIntCast()`, `PetscIntCast()` 1698 @*/ 1699 static inline PetscErrorCode PetscHipBLASIntCast(PetscInt a, PetscHipBLASInt *b) 1700 { 1701 PetscFunctionBegin; 1702 *b = 0; 1703 PetscCheck(a <= PETSC_HIPBLAS_INT_MAX, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "%" PetscInt_FMT " is too big for hipBLAS, which is restricted to 32-bit integers.", a); 1704 PetscCheck(a >= 0, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Passing negative integer %" PetscInt_FMT "to hipBLAS routine", a); 1705 *b = (PetscHipBLASInt)a; 1706 PetscFunctionReturn(PETSC_SUCCESS); 1707 } 1708 1709 /*@C 1710 PetscMPIIntCast - casts a `PetscInt` (which may be 64-bits in size) to a PetscMPIInt (which may be 32-bits in size), generates an 1711 error if the `PetscMPIInt` is not large enough to hold the number. 1712 1713 Not Collective; No Fortran Support 1714 1715 Input Parameter: 1716 . a - the `PetscInt` value 1717 1718 Output Parameter: 1719 . b - the resulting `PetscMPIInt` value 1720 1721 Level: advanced 1722 1723 .seealso: `PetscBLASInt`, `PetscMPIInt`, `PetscInt`, `PetscBLASIntCast()`, `PetscIntCast()` 1724 @*/ 1725 static inline PetscErrorCode PetscMPIIntCast(PetscInt a, PetscMPIInt *b) 1726 { 1727 PetscFunctionBegin; 1728 *b = 0; 1729 PetscCheck(a <= PETSC_MPI_INT_MAX, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "%" PetscInt_FMT " is too big for MPI buffer length. Maximum supported value is %d", a, PETSC_MPI_INT_MAX); 1730 *b = (PetscMPIInt)a; 1731 PetscFunctionReturn(PETSC_SUCCESS); 1732 } 1733 1734 #define PetscInt64Mult(a, b) (((PetscInt64)(a)) * ((PetscInt64)(b))) 1735 1736 /*@C 1737 PetscRealIntMultTruncate - Computes the product of a positive `PetscReal` and a positive 1738 `PetscInt` and truncates the value to slightly less than the maximal possible value. 1739 1740 Not Collective; No Fortran Support 1741 1742 Input Parameters: 1743 + a - The `PetscReal` value 1744 - b - The `PetscInt` value 1745 1746 Level: advanced 1747 1748 Notes: 1749 Returns the result as a `PetscInt` value. 1750 1751 Use `PetscInt64Mult()` to compute the product of two `PetscInt` as a `PetscInt64`. 1752 1753 Use `PetscIntMultTruncate()` to compute the product of two positive `PetscInt` and truncate 1754 to fit a `PetscInt`. 1755 1756 Use `PetscIntMultError()` to compute the product of two `PetscInt` if you wish to generate an 1757 error if the result will not fit in a `PetscInt`. 1758 1759 Developers Notes: 1760 We currently assume that `PetscInt` addition can never overflow, this is obviously wrong but 1761 requires many more checks. 1762 1763 This is used where we compute approximate sizes for workspace and need to insure the 1764 workspace is index-able. 1765 1766 .seealso: `PetscReal`, `PetscInt`, `PetscInt64Mult()`, `PetscIntMultError()`, `PetscIntSumError()` 1767 @*/ 1768 static inline PetscInt PetscRealIntMultTruncate(PetscReal a, PetscInt b) 1769 { 1770 PetscInt64 r = (PetscInt64)(a * (PetscReal)b); 1771 if (r > PETSC_MAX_INT - 100) r = PETSC_MAX_INT - 100; 1772 return (PetscInt)r; 1773 } 1774 1775 /*@C 1776 1777 PetscIntMultTruncate - Computes the product of two positive `PetscInt` and truncates the value to slightly less than the maximal possible value 1778 1779 Not Collective; No Fortran Support 1780 1781 Input Parameters: 1782 + a - the PetscInt value 1783 - b - the second value 1784 1785 Returns: 1786 the result as a `PetscInt` value 1787 1788 Level: advanced 1789 1790 Notes: 1791 Use `PetscInt64Mult()` to compute the product of two `PetscInt` as a `PetscInt64` 1792 1793 Use `PetscRealIntMultTruncate()` to compute the product of a `PetscReal` and a `PetscInt` and truncate to fit a `PetscInt` 1794 1795 Use `PetscIntMultError()` to compute the product of two `PetscInt` if you wish to generate an error if the result will not fit in a `PetscInt` 1796 1797 Developers Notes: 1798 We currently assume that `PetscInt` addition can never overflow, this is obviously wrong but requires many more checks. 1799 1800 This is used where we compute approximate sizes for workspace and need to insure the workspace is index-able. 1801 1802 .seealso: `PetscBLASInt`, `PetscMPIInt`, `PetscInt`, `PetscBLASIntCast()`, `PetscInt64Mult()`, `PetscIntMultError()`, `PetscIntSumError()`, 1803 `PetscIntSumTruncate()` 1804 @*/ 1805 static inline PetscInt PetscIntMultTruncate(PetscInt a, PetscInt b) 1806 { 1807 PetscInt64 r = PetscInt64Mult(a, b); 1808 if (r > PETSC_MAX_INT - 100) r = PETSC_MAX_INT - 100; 1809 return (PetscInt)r; 1810 } 1811 1812 /*@C 1813 1814 PetscIntSumTruncate - Computes the sum of two positive `PetscInt` and truncates the value to slightly less than the maximal possible value 1815 1816 Not Collective; No Fortran Support 1817 1818 Input Parameters: 1819 + a - the `PetscInt` value 1820 - b - the second value 1821 1822 Returns: 1823 the result as a `PetscInt` value 1824 1825 Level: advanced 1826 1827 Notes: 1828 Use `PetscInt64Mult()` to compute the product of two `PetscInt` as a `PetscInt64` 1829 1830 Use `PetscRealIntMultTruncate()` to compute the product of a `PetscReal` and a `PetscInt` and truncate to fit a `PetscInt` 1831 1832 Use `PetscIntMultError()` to compute the product of two `PetscInt` if you wish to generate an error if the result will not fit in a `PetscInt` 1833 1834 Developers Notes: 1835 This is used where we compute approximate sizes for workspace and need to insure the workspace is index-able. 1836 1837 .seealso: `PetscBLASInt`, `PetscMPIInt`, `PetscInt`, `PetscBLASIntCast()`, `PetscInt64Mult()`, `PetscIntMultError()` 1838 @*/ 1839 static inline PetscInt PetscIntSumTruncate(PetscInt a, PetscInt b) 1840 { 1841 PetscInt64 r = ((PetscInt64)a) + ((PetscInt64)b); 1842 if (r > PETSC_MAX_INT - 100) r = PETSC_MAX_INT - 100; 1843 return (PetscInt)r; 1844 } 1845 1846 /*@C 1847 1848 PetscIntMultError - Computes the product of two positive `PetscInt` and generates an error with overflow. 1849 1850 Not Collective; No Fortran Support 1851 1852 Input Parameters: 1853 + a - the `PetscInt` value 1854 - b - the second value 1855 1856 Output Parameter: 1857 . result - the result as a `PetscInt` value, or `NULL` if you do not want the result, you just want to check if it overflows 1858 1859 Level: advanced 1860 1861 Notes: 1862 Use `PetscInt64Mult()` to compute the product of two `PetscInt` and store in a `PetscInt64` 1863 1864 Use `PetscIntMultTruncate()` to compute the product of two `PetscInt` and truncate it to fit in a `PetscInt` 1865 1866 Developers Note: 1867 In most places in the source code we currently assume that `PetscInt` addition does not overflow, this is obviously wrong but requires many more checks. 1868 `PetscIntSumError()` can be used to check for this situation. 1869 1870 .seealso: `PetscBLASInt`, `PetscMPIInt`, `PetscInt`, `PetscBLASIntCast()`, `PetscIntMult64()`, `PetscIntSumError()` 1871 @*/ 1872 static inline PetscErrorCode PetscIntMultError(PetscInt a, PetscInt b, PetscInt *result) 1873 { 1874 PetscInt64 r = PetscInt64Mult(a, b); 1875 1876 PetscFunctionBegin; 1877 if (result) *result = (PetscInt)r; 1878 if (!PetscDefined(USE_64BIT_INDICES)) { 1879 PetscCheck(r <= PETSC_MAX_INT, PETSC_COMM_SELF, PETSC_ERR_SUP, "Product of two integers %" PetscInt_FMT " %" PetscInt_FMT " overflow, either you have an invalidly large integer error in your code or you must ./configure PETSc with --with-64-bit-indices for the case you are running", a, b); 1880 } 1881 PetscFunctionReturn(PETSC_SUCCESS); 1882 } 1883 1884 /*@C 1885 1886 PetscIntSumError - Computes the sum of two positive `PetscInt` and generates an error with overflow. 1887 1888 Not Collective; No Fortran Support 1889 1890 Input Parameters: 1891 + a - the `PetscInt` value 1892 - b - the second value 1893 1894 Output Parameter: 1895 . c - the result as a `PetscInt` value, or `NULL` if you do not want the result, you just want to check if it overflows 1896 1897 Level: advanced 1898 1899 Notes: 1900 Use `PetscInt64Mult()` to compute the product of two 32-bit `PetscInt` and store in a `PetscInt64` 1901 1902 Use `PetscIntMultTruncate()` to compute the product of two `PetscInt` and truncate it to fit in a `PetscInt` 1903 1904 .seealso: `PetscBLASInt`, `PetscMPIInt`, `PetscInt`, `PetscBLASIntCast()`, `PetscInt64Mult()`, `PetscIntMultError()` 1905 @*/ 1906 static inline PetscErrorCode PetscIntSumError(PetscInt a, PetscInt b, PetscInt *result) 1907 { 1908 PetscInt64 r = ((PetscInt64)a) + ((PetscInt64)b); 1909 1910 PetscFunctionBegin; 1911 if (result) *result = (PetscInt)r; 1912 if (!PetscDefined(USE_64BIT_INDICES)) { 1913 PetscCheck(r <= PETSC_MAX_INT, PETSC_COMM_SELF, PETSC_ERR_SUP, "Sum of two integers %" PetscInt_FMT " %" PetscInt_FMT " overflow, either you have an invalidly large integer error in your code or you must ./configure PETSc with --with-64-bit-indices for the case you are running", a, b); 1914 } 1915 PetscFunctionReturn(PETSC_SUCCESS); 1916 } 1917 1918 /* 1919 The IBM include files define hz, here we hide it so that it may be used as a regular user variable. 1920 */ 1921 #if defined(hz) 1922 #undef hz 1923 #endif 1924 1925 #include <limits.h> 1926 1927 /* The number of bits in a byte */ 1928 1929 #define PETSC_BITS_PER_BYTE CHAR_BIT 1930 1931 #if defined(PETSC_HAVE_SYS_TYPES_H) 1932 #include <sys/types.h> 1933 #endif 1934 1935 /*MC 1936 1937 PETSC_VERSION - This manual page provides information about how PETSc documents and uses its version information. This information is available to both C/C++ 1938 and Fortran compilers when `petscsys.h` is included. 1939 1940 The current PETSc version and the API for accessing it are defined in <A HREF="PETSC_DOC_OUT_ROOT_PLACEHOLDER/include/petscversion.h.html">include/petscverson.html</A> 1941 1942 The complete version number is given as the triple PETSC_VERSION_MAJOR.PETSC_VERSION_MINOR.PETSC_VERSION_SUBMINOR (in short hand x.y.z) 1943 1944 A change in the minor version number (y) indicates possible/likely changes in the PETSc API. Note this is different than with the semantic versioning convention 1945 where only a change in the major version number (x) indicates a change in the API. 1946 1947 A subminor greater than zero indicates a patch release. Version x.y.z maintains source and binary compatibility with version x.y.w for all z and w 1948 1949 Use the macros PETSC_VERSION_EQ(x,y,z), PETSC_VERSION_LT(x,y,z), PETSC_VERSION_LE(x,y,z), PETSC_VERSION_GT(x,y,z), 1950 PETSC_VERSION_GE(x,y,z) to determine if the current version is equal to, less than, less than or equal to, greater than or greater than or equal to a given 1951 version number (x.y.z). 1952 1953 `PETSC_RELEASE_DATE` is the date the x.y version was released (i.e. the version before any patch releases) 1954 1955 `PETSC_VERSION_DATE` is the date the x.y.z version was released 1956 1957 `PETSC_VERSION_GIT` is the last git commit to the repository given in the form vx.y.z-wwwww 1958 1959 `PETSC_VERSION_DATE_GIT` is the date of the last git commit to the repository 1960 1961 `PETSC_VERSION_()` is deprecated and will eventually be removed. 1962 1963 Level: intermediate 1964 M*/ 1965 1966 PETSC_EXTERN PetscErrorCode PetscGetArchType(char[], size_t); 1967 PETSC_EXTERN PetscErrorCode PetscGetHostName(char[], size_t); 1968 PETSC_EXTERN PetscErrorCode PetscGetUserName(char[], size_t); 1969 PETSC_EXTERN PetscErrorCode PetscGetProgramName(char[], size_t); 1970 PETSC_EXTERN PetscErrorCode PetscSetProgramName(const char[]); 1971 PETSC_EXTERN PetscErrorCode PetscGetDate(char[], size_t); 1972 PETSC_EXTERN PetscErrorCode PetscGetVersion(char[], size_t); 1973 PETSC_EXTERN PetscErrorCode PetscGetVersionNumber(PetscInt *, PetscInt *, PetscInt *, PetscInt *); 1974 1975 PETSC_EXTERN PetscErrorCode PetscSortedInt(PetscInt, const PetscInt[], PetscBool *); 1976 PETSC_EXTERN PetscErrorCode PetscSortedInt64(PetscInt, const PetscInt64[], PetscBool *); 1977 PETSC_EXTERN PetscErrorCode PetscSortedMPIInt(PetscInt, const PetscMPIInt[], PetscBool *); 1978 PETSC_EXTERN PetscErrorCode PetscSortedReal(PetscInt, const PetscReal[], PetscBool *); 1979 PETSC_EXTERN PetscErrorCode PetscSortInt(PetscInt, PetscInt[]); 1980 PETSC_EXTERN PetscErrorCode PetscSortInt64(PetscInt, PetscInt64[]); 1981 PETSC_EXTERN PetscErrorCode PetscSortCount(PetscInt, PetscCount[]); 1982 PETSC_EXTERN PetscErrorCode PetscSortReverseInt(PetscInt, PetscInt[]); 1983 PETSC_EXTERN PetscErrorCode PetscSortedRemoveDupsInt(PetscInt *, PetscInt[]); 1984 PETSC_EXTERN PetscErrorCode PetscSortedCheckDupsInt(PetscInt, const PetscInt[], PetscBool *); 1985 PETSC_EXTERN PetscErrorCode PetscSortRemoveDupsInt(PetscInt *, PetscInt[]); 1986 PETSC_EXTERN PetscErrorCode PetscCheckDupsInt(PetscInt, const PetscInt[], PetscBool *); 1987 PETSC_EXTERN PetscErrorCode PetscFindInt(PetscInt, PetscInt, const PetscInt[], PetscInt *); 1988 PETSC_EXTERN PetscErrorCode PetscFindMPIInt(PetscMPIInt, PetscInt, const PetscMPIInt[], PetscInt *); 1989 PETSC_EXTERN PetscErrorCode PetscSortIntWithPermutation(PetscInt, const PetscInt[], PetscInt[]); 1990 PETSC_EXTERN PetscErrorCode PetscSortStrWithPermutation(PetscInt, const char *[], PetscInt[]); 1991 PETSC_EXTERN PetscErrorCode PetscSortIntWithArray(PetscInt, PetscInt[], PetscInt[]); 1992 PETSC_EXTERN PetscErrorCode PetscSortIntWithCountArray(PetscCount, PetscInt[], PetscCount[]); 1993 PETSC_EXTERN PetscErrorCode PetscSortIntWithArrayPair(PetscInt, PetscInt[], PetscInt[], PetscInt[]); 1994 PETSC_EXTERN PetscErrorCode PetscSortIntWithIntCountArrayPair(PetscCount, PetscInt[], PetscInt[], PetscCount[]); 1995 PETSC_EXTERN PetscErrorCode PetscSortMPIInt(PetscInt, PetscMPIInt[]); 1996 PETSC_EXTERN PetscErrorCode PetscSortRemoveDupsMPIInt(PetscInt *, PetscMPIInt[]); 1997 PETSC_EXTERN PetscErrorCode PetscSortMPIIntWithArray(PetscMPIInt, PetscMPIInt[], PetscMPIInt[]); 1998 PETSC_EXTERN PetscErrorCode PetscSortMPIIntWithIntArray(PetscMPIInt, PetscMPIInt[], PetscInt[]); 1999 PETSC_EXTERN PetscErrorCode PetscSortIntWithScalarArray(PetscInt, PetscInt[], PetscScalar[]); 2000 PETSC_EXTERN PetscErrorCode PetscSortIntWithDataArray(PetscInt, PetscInt[], void *, size_t, void *); 2001 PETSC_EXTERN PetscErrorCode PetscSortReal(PetscInt, PetscReal[]); 2002 PETSC_EXTERN PetscErrorCode PetscSortRealWithArrayInt(PetscInt, PetscReal[], PetscInt[]); 2003 PETSC_EXTERN PetscErrorCode PetscSortRealWithPermutation(PetscInt, const PetscReal[], PetscInt[]); 2004 PETSC_EXTERN PetscErrorCode PetscSortRemoveDupsReal(PetscInt *, PetscReal[]); 2005 PETSC_EXTERN PetscErrorCode PetscFindReal(PetscReal, PetscInt, const PetscReal[], PetscReal, PetscInt *); 2006 PETSC_EXTERN PetscErrorCode PetscSortSplit(PetscInt, PetscInt, PetscScalar[], PetscInt[]); 2007 PETSC_EXTERN PetscErrorCode PetscSortSplitReal(PetscInt, PetscInt, PetscReal[], PetscInt[]); 2008 PETSC_EXTERN PetscErrorCode PetscProcessTree(PetscInt, const PetscBool[], const PetscInt[], PetscInt *, PetscInt **, PetscInt **, PetscInt **, PetscInt **); 2009 PETSC_EXTERN PetscErrorCode PetscMergeIntArrayPair(PetscInt, const PetscInt[], const PetscInt[], PetscInt, const PetscInt[], const PetscInt[], PetscInt *, PetscInt **, PetscInt **); 2010 PETSC_EXTERN PetscErrorCode PetscMergeIntArray(PetscInt, const PetscInt[], PetscInt, const PetscInt[], PetscInt *, PetscInt **); 2011 PETSC_EXTERN PetscErrorCode PetscMergeMPIIntArray(PetscInt, const PetscMPIInt[], PetscInt, const PetscMPIInt[], PetscInt *, PetscMPIInt **); 2012 PETSC_EXTERN PetscErrorCode PetscParallelSortedInt(MPI_Comm, PetscInt, const PetscInt[], PetscBool *); 2013 2014 PETSC_EXTERN PetscErrorCode PetscTimSort(PetscInt, void *, size_t, int (*)(const void *, const void *, void *), void *); 2015 PETSC_EXTERN PetscErrorCode PetscIntSortSemiOrdered(PetscInt, PetscInt[]); 2016 PETSC_EXTERN PetscErrorCode PetscMPIIntSortSemiOrdered(PetscInt, PetscMPIInt[]); 2017 PETSC_EXTERN PetscErrorCode PetscRealSortSemiOrdered(PetscInt, PetscReal[]); 2018 PETSC_EXTERN PetscErrorCode PetscTimSortWithArray(PetscInt, void *, size_t, void *, size_t, int (*)(const void *, const void *, void *), void *); 2019 PETSC_EXTERN PetscErrorCode PetscIntSortSemiOrderedWithArray(PetscInt, PetscInt[], PetscInt[]); 2020 PETSC_EXTERN PetscErrorCode PetscMPIIntSortSemiOrderedWithArray(PetscInt, PetscMPIInt[], PetscMPIInt[]); 2021 PETSC_EXTERN PetscErrorCode PetscRealSortSemiOrderedWithArrayInt(PetscInt, PetscReal[], PetscInt[]); 2022 2023 PETSC_EXTERN PetscErrorCode PetscSetDisplay(void); 2024 PETSC_EXTERN PetscErrorCode PetscGetDisplay(char[], size_t); 2025 2026 /*J 2027 PetscRandomType - String with the name of a PETSc randomizer 2028 2029 Level: beginner 2030 2031 Note: 2032 To use `PETSCSPRNG` or `PETSCRANDOM123` you must have ./configure PETSc 2033 with the option `--download-sprng` or `--download-random123`. We recommend the default provided with PETSc. 2034 2035 .seealso: `PetscRandomSetType()`, `PetscRandom`, `PetscRandomCreate()` 2036 J*/ 2037 typedef const char *PetscRandomType; 2038 #define PETSCRAND "rand" 2039 #define PETSCRAND48 "rand48" 2040 #define PETSCSPRNG "sprng" 2041 #define PETSCRANDER48 "rander48" 2042 #define PETSCRANDOM123 "random123" 2043 #define PETSCCURAND "curand" 2044 2045 /* Logging support */ 2046 PETSC_EXTERN PetscClassId PETSC_RANDOM_CLASSID; 2047 2048 PETSC_EXTERN PetscErrorCode PetscRandomInitializePackage(void); 2049 2050 /* Dynamic creation and loading functions */ 2051 PETSC_EXTERN PetscFunctionList PetscRandomList; 2052 2053 PETSC_EXTERN PetscErrorCode PetscRandomRegister(const char[], PetscErrorCode (*)(PetscRandom)); 2054 PETSC_EXTERN PetscErrorCode PetscRandomSetType(PetscRandom, PetscRandomType); 2055 PETSC_EXTERN PetscErrorCode PetscRandomSetFromOptions(PetscRandom); 2056 PETSC_EXTERN PetscErrorCode PetscRandomGetType(PetscRandom, PetscRandomType *); 2057 PETSC_EXTERN PetscErrorCode PetscRandomViewFromOptions(PetscRandom, PetscObject, const char[]); 2058 PETSC_EXTERN PetscErrorCode PetscRandomView(PetscRandom, PetscViewer); 2059 2060 PETSC_EXTERN PetscErrorCode PetscRandomCreate(MPI_Comm, PetscRandom *); 2061 PETSC_EXTERN PetscErrorCode PetscRandomGetValue(PetscRandom, PetscScalar *); 2062 PETSC_EXTERN PetscErrorCode PetscRandomGetValueReal(PetscRandom, PetscReal *); 2063 PETSC_EXTERN PetscErrorCode PetscRandomGetValues(PetscRandom, PetscInt, PetscScalar *); 2064 PETSC_EXTERN PetscErrorCode PetscRandomGetValuesReal(PetscRandom, PetscInt, PetscReal *); 2065 PETSC_EXTERN PetscErrorCode PetscRandomGetInterval(PetscRandom, PetscScalar *, PetscScalar *); 2066 PETSC_EXTERN PetscErrorCode PetscRandomSetInterval(PetscRandom, PetscScalar, PetscScalar); 2067 PETSC_EXTERN PetscErrorCode PetscRandomSetSeed(PetscRandom, unsigned long); 2068 PETSC_EXTERN PetscErrorCode PetscRandomGetSeed(PetscRandom, unsigned long *); 2069 PETSC_EXTERN PetscErrorCode PetscRandomSeed(PetscRandom); 2070 PETSC_EXTERN PetscErrorCode PetscRandomDestroy(PetscRandom *); 2071 2072 PETSC_EXTERN PetscErrorCode PetscGetFullPath(const char[], char[], size_t); 2073 PETSC_EXTERN PetscErrorCode PetscGetRelativePath(const char[], char[], size_t); 2074 PETSC_EXTERN PetscErrorCode PetscGetWorkingDirectory(char[], size_t); 2075 PETSC_EXTERN PetscErrorCode PetscGetRealPath(const char[], char[]); 2076 PETSC_EXTERN PetscErrorCode PetscGetHomeDirectory(char[], size_t); 2077 PETSC_EXTERN PetscErrorCode PetscTestFile(const char[], char, PetscBool *); 2078 PETSC_EXTERN PetscErrorCode PetscTestDirectory(const char[], char, PetscBool *); 2079 PETSC_EXTERN PetscErrorCode PetscMkdir(const char[]); 2080 PETSC_EXTERN PetscErrorCode PetscMkdtemp(char[]); 2081 PETSC_EXTERN PetscErrorCode PetscRMTree(const char[]); 2082 2083 static inline PetscBool PetscBinaryBigEndian(void) 2084 { 2085 long _petsc_v = 1; 2086 return ((char *)&_petsc_v)[0] ? PETSC_FALSE : PETSC_TRUE; 2087 } 2088 2089 PETSC_EXTERN PetscErrorCode PetscBinaryRead(int, void *, PetscInt, PetscInt *, PetscDataType); 2090 PETSC_EXTERN PetscErrorCode PetscBinarySynchronizedRead(MPI_Comm, int, void *, PetscInt, PetscInt *, PetscDataType); 2091 PETSC_EXTERN PetscErrorCode PetscBinaryWrite(int, const void *, PetscInt, PetscDataType); 2092 PETSC_EXTERN PetscErrorCode PetscBinarySynchronizedWrite(MPI_Comm, int, const void *, PetscInt, PetscDataType); 2093 PETSC_EXTERN PetscErrorCode PetscBinaryOpen(const char[], PetscFileMode, int *); 2094 PETSC_EXTERN PetscErrorCode PetscBinaryClose(int); 2095 PETSC_EXTERN PetscErrorCode PetscSharedTmp(MPI_Comm, PetscBool *); 2096 PETSC_EXTERN PetscErrorCode PetscSharedWorkingDirectory(MPI_Comm, PetscBool *); 2097 PETSC_EXTERN PetscErrorCode PetscGetTmp(MPI_Comm, char[], size_t); 2098 PETSC_EXTERN PetscErrorCode PetscFileRetrieve(MPI_Comm, const char[], char[], size_t, PetscBool *); 2099 PETSC_EXTERN PetscErrorCode PetscLs(MPI_Comm, const char[], char[], size_t, PetscBool *); 2100 #if defined(PETSC_USE_SOCKET_VIEWER) 2101 PETSC_EXTERN PetscErrorCode PetscOpenSocket(const char[], int, int *); 2102 #endif 2103 2104 PETSC_EXTERN PetscErrorCode PetscBinarySeek(int, off_t, PetscBinarySeekType, off_t *); 2105 PETSC_EXTERN PetscErrorCode PetscBinarySynchronizedSeek(MPI_Comm, int, off_t, PetscBinarySeekType, off_t *); 2106 PETSC_EXTERN PetscErrorCode PetscByteSwap(void *, PetscDataType, PetscInt); 2107 2108 PETSC_EXTERN PetscErrorCode PetscSetDebugTerminal(const char[]); 2109 PETSC_EXTERN PetscErrorCode PetscSetDebugger(const char[], PetscBool); 2110 PETSC_EXTERN PetscErrorCode PetscSetDefaultDebugger(void); 2111 PETSC_EXTERN PetscErrorCode PetscSetDebuggerFromString(const char *); 2112 PETSC_EXTERN PetscErrorCode PetscAttachDebugger(void); 2113 PETSC_EXTERN PetscErrorCode PetscStopForDebugger(void); 2114 PETSC_EXTERN PetscErrorCode PetscWaitOnError(void); 2115 2116 PETSC_EXTERN PetscErrorCode PetscGatherNumberOfMessages(MPI_Comm, const PetscMPIInt[], const PetscMPIInt[], PetscMPIInt *); 2117 PETSC_EXTERN PetscErrorCode PetscGatherMessageLengths(MPI_Comm, PetscMPIInt, PetscMPIInt, const PetscMPIInt[], PetscMPIInt **, PetscMPIInt **); 2118 PETSC_EXTERN PetscErrorCode PetscGatherMessageLengths2(MPI_Comm, PetscMPIInt, PetscMPIInt, const PetscMPIInt[], const PetscMPIInt[], PetscMPIInt **, PetscMPIInt **, PetscMPIInt **); 2119 PETSC_EXTERN PetscErrorCode PetscPostIrecvInt(MPI_Comm, PetscMPIInt, PetscMPIInt, const PetscMPIInt[], const PetscMPIInt[], PetscInt ***, MPI_Request **); 2120 PETSC_EXTERN PetscErrorCode PetscPostIrecvScalar(MPI_Comm, PetscMPIInt, PetscMPIInt, const PetscMPIInt[], const PetscMPIInt[], PetscScalar ***, MPI_Request **); 2121 PETSC_EXTERN PetscErrorCode PetscCommBuildTwoSided(MPI_Comm, PetscMPIInt, MPI_Datatype, PetscMPIInt, const PetscMPIInt *, const void *, PetscMPIInt *, PetscMPIInt **, void *) PETSC_ATTRIBUTE_MPI_POINTER_WITH_TYPE(6, 3); 2122 PETSC_EXTERN PetscErrorCode PetscCommBuildTwoSidedF(MPI_Comm, PetscMPIInt, MPI_Datatype, PetscMPIInt, const PetscMPIInt[], const void *, PetscMPIInt *, PetscMPIInt **, void *, PetscMPIInt, PetscErrorCode (*send)(MPI_Comm, const PetscMPIInt[], PetscMPIInt, PetscMPIInt, void *, MPI_Request[], void *), PetscErrorCode (*recv)(MPI_Comm, const PetscMPIInt[], PetscMPIInt, void *, MPI_Request[], void *), void *ctx) PETSC_ATTRIBUTE_MPI_POINTER_WITH_TYPE(6, 3); 2123 PETSC_EXTERN PetscErrorCode PetscCommBuildTwoSidedFReq(MPI_Comm, PetscMPIInt, MPI_Datatype, PetscMPIInt, const PetscMPIInt[], const void *, PetscMPIInt *, PetscMPIInt **, void *, PetscMPIInt, MPI_Request **, MPI_Request **, PetscErrorCode (*send)(MPI_Comm, const PetscMPIInt[], PetscMPIInt, PetscMPIInt, void *, MPI_Request[], void *), PetscErrorCode (*recv)(MPI_Comm, const PetscMPIInt[], PetscMPIInt, void *, MPI_Request[], void *), void *ctx) PETSC_ATTRIBUTE_MPI_POINTER_WITH_TYPE(6, 3); 2124 2125 PETSC_EXTERN PetscErrorCode PetscCommBuildTwoSidedSetType(MPI_Comm, PetscBuildTwoSidedType); 2126 PETSC_EXTERN PetscErrorCode PetscCommBuildTwoSidedGetType(MPI_Comm, PetscBuildTwoSidedType *); 2127 2128 PETSC_EXTERN PetscErrorCode PetscSSEIsEnabled(MPI_Comm, PetscBool *, PetscBool *); 2129 2130 PETSC_EXTERN MPI_Comm PetscObjectComm(PetscObject); 2131 2132 struct _n_PetscSubcomm { 2133 MPI_Comm parent; /* parent communicator */ 2134 MPI_Comm dupparent; /* duplicate parent communicator, under which the processors of this subcomm have contiguous rank */ 2135 MPI_Comm child; /* the sub-communicator */ 2136 PetscMPIInt n; /* num of subcommunicators under the parent communicator */ 2137 PetscMPIInt color; /* color of processors belong to this communicator */ 2138 PetscMPIInt *subsize; /* size of subcommunicator[color] */ 2139 PetscSubcommType type; 2140 char *subcommprefix; 2141 }; 2142 2143 static inline MPI_Comm PetscSubcommParent(PetscSubcomm scomm) 2144 { 2145 return scomm->parent; 2146 } 2147 static inline MPI_Comm PetscSubcommChild(PetscSubcomm scomm) 2148 { 2149 return scomm->child; 2150 } 2151 static inline MPI_Comm PetscSubcommContiguousParent(PetscSubcomm scomm) 2152 { 2153 return scomm->dupparent; 2154 } 2155 PETSC_EXTERN PetscErrorCode PetscSubcommCreate(MPI_Comm, PetscSubcomm *); 2156 PETSC_EXTERN PetscErrorCode PetscSubcommDestroy(PetscSubcomm *); 2157 PETSC_EXTERN PetscErrorCode PetscSubcommSetNumber(PetscSubcomm, PetscInt); 2158 PETSC_EXTERN PetscErrorCode PetscSubcommSetType(PetscSubcomm, PetscSubcommType); 2159 PETSC_EXTERN PetscErrorCode PetscSubcommSetTypeGeneral(PetscSubcomm, PetscMPIInt, PetscMPIInt); 2160 PETSC_EXTERN PetscErrorCode PetscSubcommView(PetscSubcomm, PetscViewer); 2161 PETSC_EXTERN PetscErrorCode PetscSubcommSetFromOptions(PetscSubcomm); 2162 PETSC_EXTERN PetscErrorCode PetscSubcommSetOptionsPrefix(PetscSubcomm, const char[]); 2163 PETSC_EXTERN PetscErrorCode PetscSubcommGetParent(PetscSubcomm, MPI_Comm *); 2164 PETSC_EXTERN PetscErrorCode PetscSubcommGetContiguousParent(PetscSubcomm, MPI_Comm *); 2165 PETSC_EXTERN PetscErrorCode PetscSubcommGetChild(PetscSubcomm, MPI_Comm *); 2166 2167 PETSC_EXTERN PetscErrorCode PetscHeapCreate(PetscInt, PetscHeap *); 2168 PETSC_EXTERN PetscErrorCode PetscHeapAdd(PetscHeap, PetscInt, PetscInt); 2169 PETSC_EXTERN PetscErrorCode PetscHeapPop(PetscHeap, PetscInt *, PetscInt *); 2170 PETSC_EXTERN PetscErrorCode PetscHeapPeek(PetscHeap, PetscInt *, PetscInt *); 2171 PETSC_EXTERN PetscErrorCode PetscHeapStash(PetscHeap, PetscInt, PetscInt); 2172 PETSC_EXTERN PetscErrorCode PetscHeapUnstash(PetscHeap); 2173 PETSC_EXTERN PetscErrorCode PetscHeapDestroy(PetscHeap *); 2174 PETSC_EXTERN PetscErrorCode PetscHeapView(PetscHeap, PetscViewer); 2175 2176 PETSC_EXTERN PetscErrorCode PetscProcessPlacementView(PetscViewer); 2177 PETSC_EXTERN PetscErrorCode PetscShmCommGet(MPI_Comm, PetscShmComm *); 2178 PETSC_EXTERN PetscErrorCode PetscShmCommGlobalToLocal(PetscShmComm, PetscMPIInt, PetscMPIInt *); 2179 PETSC_EXTERN PetscErrorCode PetscShmCommLocalToGlobal(PetscShmComm, PetscMPIInt, PetscMPIInt *); 2180 PETSC_EXTERN PetscErrorCode PetscShmCommGetMpiShmComm(PetscShmComm, MPI_Comm *); 2181 2182 /* routines to better support OpenMP multithreading needs of some PETSc third party libraries */ 2183 PETSC_EXTERN PetscErrorCode PetscOmpCtrlCreate(MPI_Comm, PetscInt, PetscOmpCtrl *); 2184 PETSC_EXTERN PetscErrorCode PetscOmpCtrlGetOmpComms(PetscOmpCtrl, MPI_Comm *, MPI_Comm *, PetscBool *); 2185 PETSC_EXTERN PetscErrorCode PetscOmpCtrlDestroy(PetscOmpCtrl *); 2186 PETSC_EXTERN PetscErrorCode PetscOmpCtrlBarrier(PetscOmpCtrl); 2187 PETSC_EXTERN PetscErrorCode PetscOmpCtrlOmpRegionOnMasterBegin(PetscOmpCtrl); 2188 PETSC_EXTERN PetscErrorCode PetscOmpCtrlOmpRegionOnMasterEnd(PetscOmpCtrl); 2189 2190 PETSC_EXTERN PetscErrorCode PetscSegBufferCreate(size_t, size_t, PetscSegBuffer *); 2191 PETSC_EXTERN PetscErrorCode PetscSegBufferDestroy(PetscSegBuffer *); 2192 PETSC_EXTERN PetscErrorCode PetscSegBufferGet(PetscSegBuffer, size_t, void *); 2193 PETSC_EXTERN PetscErrorCode PetscSegBufferExtractAlloc(PetscSegBuffer, void *); 2194 PETSC_EXTERN PetscErrorCode PetscSegBufferExtractTo(PetscSegBuffer, void *); 2195 PETSC_EXTERN PetscErrorCode PetscSegBufferExtractInPlace(PetscSegBuffer, void *); 2196 PETSC_EXTERN PetscErrorCode PetscSegBufferGetSize(PetscSegBuffer, size_t *); 2197 PETSC_EXTERN PetscErrorCode PetscSegBufferUnuse(PetscSegBuffer, size_t); 2198 2199 /* Type-safe wrapper to encourage use of PETSC_RESTRICT. Does not use PetscFunctionBegin because the error handling 2200 * prevents the compiler from completely erasing the stub. This is called in inner loops so it has to be as fast as 2201 * possible. */ 2202 static inline PetscErrorCode PetscSegBufferGetInts(PetscSegBuffer seg, size_t count, PetscInt *PETSC_RESTRICT *slot) 2203 { 2204 return PetscSegBufferGet(seg, count, (void **)slot); 2205 } 2206 2207 extern PetscOptionsHelpPrinted PetscOptionsHelpPrintedSingleton; 2208 PETSC_EXTERN PetscErrorCode PetscOptionsHelpPrintedDestroy(PetscOptionsHelpPrinted *); 2209 PETSC_EXTERN PetscErrorCode PetscOptionsHelpPrintedCreate(PetscOptionsHelpPrinted *); 2210 PETSC_EXTERN PetscErrorCode PetscOptionsHelpPrintedCheck(PetscOptionsHelpPrinted, const char *, const char *, PetscBool *); 2211 2212 #include <stdarg.h> 2213 PETSC_EXTERN PetscErrorCode PetscVSNPrintf(char *, size_t, const char[], size_t *, va_list); 2214 PETSC_EXTERN PetscErrorCode (*PetscVFPrintf)(FILE *, const char[], va_list); 2215 2216 PETSC_EXTERN PetscSegBuffer PetscCitationsList; 2217 2218 /*@C 2219 PetscCitationsRegister - Register a bibtex item to obtain credit for an implemented algorithm used in the code. 2220 2221 Not Collective; No Fortran Support 2222 2223 Input Parameters: 2224 + cite - the bibtex item, formatted to displayed on multiple lines nicely 2225 - set - a boolean variable initially set to `PETSC_FALSE`; this is used to insure only a single registration of the citation 2226 2227 Options Database Key: 2228 . -citations [filename] - print out the bibtex entries for the given computation 2229 2230 Level: intermediate 2231 @*/ 2232 static inline PetscErrorCode PetscCitationsRegister(const char cit[], PetscBool *set) 2233 { 2234 size_t len; 2235 char *vstring; 2236 2237 PetscFunctionBegin; 2238 if (set && *set) PetscFunctionReturn(PETSC_SUCCESS); 2239 PetscCall(PetscStrlen(cit, &len)); 2240 PetscCall(PetscSegBufferGet(PetscCitationsList, len, &vstring)); 2241 PetscCall(PetscArraycpy(vstring, cit, len)); 2242 if (set) *set = PETSC_TRUE; 2243 PetscFunctionReturn(PETSC_SUCCESS); 2244 } 2245 2246 PETSC_EXTERN PETSC_DEPRECATED_FUNCTION("Google has discontinued its URL shortener service") PetscErrorCode PetscURLShorten(const char[], char[], size_t c); 2247 PETSC_EXTERN PetscErrorCode PetscGoogleDriveAuthorize(MPI_Comm, char[], char[], size_t); 2248 PETSC_EXTERN PetscErrorCode PetscGoogleDriveRefresh(MPI_Comm, const char[], char[], size_t); 2249 PETSC_EXTERN PetscErrorCode PetscGoogleDriveUpload(MPI_Comm, const char[], const char[]); 2250 2251 PETSC_EXTERN PetscErrorCode PetscBoxAuthorize(MPI_Comm, char[], char[], size_t); 2252 PETSC_EXTERN PetscErrorCode PetscBoxRefresh(MPI_Comm, const char[], char[], char[], size_t); 2253 2254 PETSC_EXTERN PetscErrorCode PetscGlobusGetTransfers(MPI_Comm, const char[], char[], size_t); 2255 2256 PETSC_EXTERN PetscErrorCode PetscTextBelt(MPI_Comm, const char[], const char[], PetscBool *); 2257 PETSC_EXTERN PetscErrorCode PetscTellMyCell(MPI_Comm, const char[], const char[], PetscBool *); 2258 2259 PETSC_EXTERN PetscErrorCode PetscPullJSONValue(const char[], const char[], char[], size_t, PetscBool *); 2260 PETSC_EXTERN PetscErrorCode PetscPushJSONValue(char[], const char[], const char[], size_t); 2261 2262 #if defined(PETSC_USE_DEBUG) 2263 static inline unsigned int PetscStrHash(const char *str) 2264 { 2265 unsigned int c, hash = 5381; 2266 2267 while ((c = (unsigned int)*str++)) hash = ((hash << 5) + hash) + c; /* hash * 33 + c */ 2268 return hash; 2269 } 2270 2271 /*MC 2272 MPIU_Allreduce - a PETSc replacement for `MPI_Allreduce()` that tries to determine if the call from all the MPI ranks occur from the 2273 same place in the PETSc code. This helps to detect bugs where different MPI ranks follow different code paths 2274 resulting in inconsistent and incorrect calls to `MPI_Allreduce()`. 2275 2276 Synopsis: 2277 #include <petscsys.h> 2278 PetscErrorCode MPIU_Allreduce(void *indata,void *outdata,PetscMPIInt count,MPI_Datatype datatype, MPI_Op op, MPI_Comm comm); 2279 2280 Collective 2281 2282 Input Parameters: 2283 + a - pointer to the input data to be reduced 2284 . c - the number of MPI data items in a and b 2285 . d - the MPI datatype, for example `MPI_INT` 2286 . e - the MPI operation, for example `MPI_SUM` 2287 - fcomm - the MPI communicator on which the operation occurs 2288 2289 Output Parameter: 2290 . b - the reduced values 2291 2292 Level: developer 2293 2294 Notes: 2295 In optimized mode this directly calls `MPI_Allreduce()` 2296 2297 This is defined as a macro that can return error codes internally so it cannot be used in a subroutine that returns void. 2298 2299 The error code this returns should be checked with `PetscCall()` even though it looks like an MPI function because it always returns PETSc error codes 2300 2301 .seealso: `MPI_Allreduce()` 2302 M*/ 2303 // clang-format off 2304 #define MPIU_Allreduce(a, b, c, d, e, fcomm) \ 2305 PetscMacroReturnStandard( \ 2306 PetscMPIInt a_b1[6], a_b2[6]; \ 2307 int _mpiu_allreduce_c_int = (int)(c); \ 2308 a_b1[0] = -(PetscMPIInt)__LINE__; \ 2309 a_b1[1] = -a_b1[0]; \ 2310 a_b1[2] = -(PetscMPIInt)PetscStrHash(PETSC_FUNCTION_NAME); \ 2311 a_b1[3] = -a_b1[2]; \ 2312 a_b1[4] = -(PetscMPIInt)(c); \ 2313 a_b1[5] = -a_b1[4]; \ 2314 \ 2315 PetscCallMPI(MPI_Allreduce(a_b1, a_b2, 6, MPI_INT, MPI_MAX, fcomm)); \ 2316 PetscCheck(-a_b2[0] == a_b2[1], PETSC_COMM_SELF, PETSC_ERR_PLIB, "MPI_Allreduce() called in different locations (code lines) on different processors"); \ 2317 PetscCheck(-a_b2[2] == a_b2[3], PETSC_COMM_SELF, PETSC_ERR_PLIB, "MPI_Allreduce() called in different locations (functions) on different processors"); \ 2318 PetscCheck(-a_b2[4] == a_b2[5], PETSC_COMM_SELF, PETSC_ERR_PLIB, "MPI_Allreduce() called with different counts %d on different processors", _mpiu_allreduce_c_int); \ 2319 PetscCallMPI(MPI_Allreduce((a), (b), (c), (d), (e), (fcomm)));) 2320 // clang-format on 2321 #else 2322 #define MPIU_Allreduce(a, b, c, d, e, fcomm) PetscMacroReturnStandard(PetscCallMPI(MPI_Allreduce((a), (b), (c), (d), (e), (fcomm)))) 2323 #endif 2324 2325 #if defined(PETSC_HAVE_MPI_PROCESS_SHARED_MEMORY) 2326 PETSC_EXTERN PetscErrorCode MPIU_Win_allocate_shared(MPI_Aint, PetscMPIInt, MPI_Info, MPI_Comm, void *, MPI_Win *); 2327 PETSC_EXTERN PetscErrorCode MPIU_Win_shared_query(MPI_Win, PetscMPIInt, MPI_Aint *, PetscMPIInt *, void *); 2328 #endif 2329 2330 /* this is a vile hack */ 2331 #if defined(PETSC_HAVE_NECMPI) 2332 #if !defined(PETSC_NECMPI_VERSION_MAJOR) || !defined(PETSC_NECMPI_VERSION_MINOR) || PETSC_NECMPI_VERSION_MAJOR < 2 || (PETSC_NECMPI_VERSION_MAJOR == 2 && PETSC_NECMPI_VERSION_MINOR < 18) 2333 #define MPI_Type_free(a) (*(a) = MPI_DATATYPE_NULL, 0); 2334 #endif 2335 #endif 2336 2337 /* 2338 List of external packages and queries on it 2339 */ 2340 PETSC_EXTERN PetscErrorCode PetscHasExternalPackage(const char[], PetscBool *); 2341 2342 /* this cannot go here because it may be in a different shared library */ 2343 PETSC_EXTERN PetscErrorCode PCMPIServerBegin(void); 2344 PETSC_EXTERN PetscErrorCode PCMPIServerEnd(void); 2345 PETSC_EXTERN PetscErrorCode PCMPICommsDestroy(void); 2346 #endif 2347