1 /* 2 This provides a few of the MPI-uni functions that cannot be implemented 3 with C macros 4 */ 5 #include <mpiuni/mpi.h> 6 #if !defined(__MPIUNI_H) 7 #error "Wrong mpi.h included! require mpi.h from MPIUNI" 8 #endif 9 #if !defined(PETSC_STDCALL) 10 #define PETSC_STDCALL 11 #endif 12 #include <stdio.h> 13 #if defined(PETSC_HAVE_STDLIB_H) 14 #include <stdlib.h> 15 #endif 16 17 #define MPI_SUCCESS 0 18 #define MPI_FAILURE 1 19 void *MPIUNI_TMP = 0; 20 int MPIUNI_DATASIZE[10] = {sizeof(int),sizeof(float),sizeof(double),2*sizeof(double),sizeof(char),2*sizeof(int),4*sizeof(double),4,8,2*sizeof(double)}; 21 /* 22 With MPI Uni there is only one communicator, which is called 1. 23 */ 24 #define MAX_ATTR 128 25 26 typedef struct { 27 void *attribute_val; 28 int active; 29 } MPI_Attr; 30 31 typedef struct { 32 void *extra_state; 33 MPI_Delete_function *del; 34 } MPI_Attr_keyval; 35 36 static MPI_Attr_keyval attr_keyval[MAX_ATTR]; 37 static MPI_Attr attr[MAX_ATTR]; 38 static int num_attr = 1,mpi_tag_ub = 100000000; 39 40 #if defined(__cplusplus) 41 extern "C" { 42 #endif 43 44 /* 45 To avoid problems with prototypes to the system memcpy() it is duplicated here 46 */ 47 int MPIUNI_Memcpy(void *a,const void* b,int n) { 48 int i; 49 char *aa= (char*)a; 50 char *bb= (char*)b; 51 52 if (b == MPI_IN_PLACE) return 0; 53 for (i=0; i<n; i++) aa[i] = bb[i]; 54 return 0; 55 } 56 57 /* 58 Used to set the built-in MPI_TAG_UB attribute 59 */ 60 static int Keyval_setup(void) 61 { 62 attr[0].active = 1; 63 attr[0].attribute_val = &mpi_tag_ub; 64 return 0; 65 } 66 67 int MPI_Keyval_create(MPI_Copy_function *copy_fn,MPI_Delete_function *delete_fn,int *keyval,void *extra_state) 68 { 69 if (num_attr >= MAX_ATTR) MPI_Abort(MPI_COMM_WORLD,1); 70 71 attr_keyval[num_attr].extra_state = extra_state; 72 attr_keyval[num_attr].del = delete_fn; 73 *keyval = num_attr++; 74 return 0; 75 } 76 77 int MPI_Keyval_free(int *keyval) 78 { 79 return MPI_SUCCESS; 80 } 81 82 int MPI_Attr_put(MPI_Comm comm,int keyval,void *attribute_val) 83 { 84 attr[keyval].active = 1; 85 attr[keyval].attribute_val = attribute_val; 86 return MPI_SUCCESS; 87 } 88 89 int MPI_Attr_delete(MPI_Comm comm,int keyval) 90 { 91 if (attr[keyval].active && attr_keyval[keyval].del) { 92 void* save_attribute_val = attr[keyval].attribute_val; 93 attr[keyval].active = 0; 94 attr[keyval].attribute_val = 0; 95 (*(attr_keyval[keyval].del))(comm,keyval,save_attribute_val,attr_keyval[keyval].extra_state); 96 } 97 return MPI_SUCCESS; 98 } 99 100 int MPI_Attr_get(MPI_Comm comm,int keyval,void *attribute_val,int *flag) 101 { 102 if (!keyval) Keyval_setup(); 103 *flag = attr[keyval].active; 104 *(void **)attribute_val = attr[keyval].attribute_val; 105 return MPI_SUCCESS; 106 } 107 108 static int dups = 0; 109 int MPI_Comm_create(MPI_Comm comm,MPI_Group group,MPI_Comm *newcomm) 110 { 111 dups++; 112 *newcomm = comm; 113 return MPI_SUCCESS; 114 } 115 116 int MPI_Comm_dup(MPI_Comm comm,MPI_Comm *out) 117 { 118 *out = comm; 119 dups++; 120 return 0; 121 } 122 123 int MPI_Comm_free(MPI_Comm *comm) 124 { 125 int i; 126 127 if (--dups) return MPI_SUCCESS; 128 for (i=0; i<num_attr; i++) { 129 if (attr[i].active && attr_keyval[i].del) { 130 (*attr_keyval[i].del)(*comm,i,attr[i].attribute_val,attr_keyval[i].extra_state); 131 } 132 attr[i].active = 0; 133 } 134 return MPI_SUCCESS; 135 } 136 137 int MPI_Comm_size(MPI_Comm comm, int*size) 138 { 139 *size=1; 140 return MPI_SUCCESS; 141 } 142 143 int MPI_Comm_rank(MPI_Comm comm, int*rank) 144 { 145 *rank=0; 146 return MPI_SUCCESS; 147 } 148 149 int MPI_Abort(MPI_Comm comm,int errorcode) 150 { 151 abort(); 152 return MPI_SUCCESS; 153 } 154 155 /* --------------------------------------------------------------------------*/ 156 157 static int MPI_was_initialized = 0; 158 static int MPI_was_finalized = 0; 159 160 int MPI_Init(int *argc, char ***argv) 161 { 162 if (MPI_was_initialized) return 1; 163 if (MPI_was_finalized) return 1; 164 MPI_was_initialized = 1; 165 return 0; 166 } 167 168 int MPI_Finalize(void) 169 { 170 if (MPI_was_finalized) return 1; 171 if (!MPI_was_initialized) return 1; 172 MPI_was_finalized = 1; 173 return 0; 174 } 175 176 int MPI_Initialized(int *flag) 177 { 178 *flag = MPI_was_initialized; 179 return 0; 180 } 181 182 int MPI_Finalized(int *flag) 183 { 184 *flag = MPI_was_finalized; 185 return 0; 186 } 187 188 /* ------------------- Fortran versions of several routines ------------------ */ 189 190 #if defined(PETSC_HAVE_FORTRAN_CAPS) 191 #define mpi_init_ MPI_INIT 192 #define mpi_finalize_ MPI_FINALIZE 193 #define mpi_comm_size_ MPI_COMM_SIZE 194 #define mpi_comm_rank_ MPI_COMM_RANK 195 #define mpi_abort_ MPI_ABORT 196 #define mpi_reduce_ MPI_REDUCE 197 #define mpi_allreduce_ MPI_ALLREDUCE 198 #define mpi_barrier_ MPI_BARRIER 199 #define mpi_bcast_ MPI_BCAST 200 #define mpi_gather_ MPI_GATHER 201 #define mpi_allgather_ MPI_ALLGATHER 202 #define mpi_comm_split_ MPI_COMM_SPLIT 203 #define mpi_scan_ MPI_SCAN 204 #define mpi_send_ MPI_SEND 205 #define mpi_recv_ MPI_RECV 206 #define mpi_reduce_scatter_ MPI_REDUCE_SCATTER 207 #define mpi_irecv_ MPI_IRECV 208 #define mpi_isend_ MPI_ISEND 209 #define mpi_sendrecv_ MPI_SENDRECV 210 #define mpi_test_ MPI_TEST 211 #define mpi_waitall_ MPI_WAITALL 212 #define mpi_waitany_ MPI_WAITANY 213 #define mpi_allgatherv_ MPI_ALLGATHERV 214 #define mpi_alltoallv_ MPI_ALLTOALLV 215 #define mpi_comm_create_ MPI_COMM_CREATE 216 #define mpi_address_ MPI_ADDRESS 217 #define mpi_pack_ MPI_PACK 218 #define mpi_unpack_ MPI_UNPACK 219 #define mpi_pack_size_ MPI_PACK_SIZE 220 #define mpi_type_struct_ MPI_TYPE_STRUCT 221 #define mpi_type_commit_ MPI_TYPE_COMMIT 222 #define mpi_wtime_ MPI_WTIME 223 #define mpi_cancel_ MPI_CANCEL 224 #define mpi_comm_dup_ MPI_COMM_DUP 225 #define mpi_comm_free_ MPI_COMM_FREE 226 #define mpi_get_count_ MPI_GET_COUNT 227 #define mpi_get_processor_name_ MPI_GET_PROCESSOR_NAME 228 #define mpi_initialized_ MPI_INITIALIZED 229 #define mpi_iprobe_ MPI_IPROBE 230 #define mpi_probe_ MPI_PROBE 231 #define mpi_request_free_ MPI_REQUEST_FREE 232 #define mpi_ssend_ MPI_SSEND 233 #define mpi_wait_ MPI_WAIT 234 #define mpi_comm_group_ MPI_COMM_GROUP 235 #define mpi_exscan_ MPI_EXSCAN 236 #elif !defined(PETSC_HAVE_FORTRAN_UNDERSCORE) 237 #define mpi_init_ mpi_init 238 #define mpi_finalize_ mpi_finalize 239 #define mpi_comm_size_ mpi_comm_size 240 #define mpi_comm_rank_ mpi_comm_rank 241 #define mpi_abort_ mpi_abort 242 #define mpi_reduce_ mpi_reduce 243 #define mpi_allreduce_ mpi_allreduce 244 #define mpi_barrier_ mpi_barrier 245 #define mpi_bcast_ mpi_bcast 246 #define mpi_gather_ mpi_gather 247 #define mpi_allgather_ mpi_allgather 248 #define mpi_comm_split_ mpi_comm_split 249 #define mpi_scan_ mpi_scan 250 #define mpi_send_ mpi_send 251 #define mpi_recv_ mpi_recv 252 #define mpi_reduce_scatter_ mpi_reduce_scatter 253 #define mpi_irecv_ mpi_irecv 254 #define mpi_isend_ mpi_isend 255 #define mpi_sendrecv_ mpi_sendrecv 256 #define mpi_test_ mpi_test 257 #define mpi_waitall_ mpi_waitall 258 #define mpi_waitany_ mpi_waitany 259 #define mpi_allgatherv_ mpi_allgatherv 260 #define mpi_alltoallv_ mpi_alltoallv 261 #define mpi_comm_create_ mpi_comm_create 262 #define mpi_address_ mpi_address 263 #define mpi_pack_ mpi_pack 264 #define mpi_unpack_ mpi_unpack 265 #define mpi_pack_size_ mpi_pack_size 266 #define mpi_type_struct_ mpi_type_struct 267 #define mpi_type_commit_ mpi_type_commit 268 #define mpi_wtime_ mpi_wtime 269 #define mpi_cancel_ mpi_cancel 270 #define mpi_comm_dup_ mpi_comm_dup 271 #define mpi_comm_free_ mpi_comm_free 272 #define mpi_get_count_ mpi_get_count 273 #define mpi_get_processor_name_ mpi_get_processor_name 274 #define mpi_initialized_ mpi_initialized 275 #define mpi_iprobe_ mpi_iprobe 276 #define mpi_probe_ mpi_probe 277 #define mpi_request_free_ mpi_request_free 278 #define mpi_ssend_ mpi_ssend 279 #define mpi_wait_ mpi_wait 280 #define mpi_comm_group_ mpi_comm_group 281 #define mpi_exscan_ mpi_exscan 282 #endif 283 284 #if defined(PETSC_HAVE_FORTRAN_UNDERSCORE_UNDERSCORE) 285 #define mpi_init_ mpi_init__ 286 #define mpi_finalize_ mpi_finalize__ 287 #define mpi_comm_size_ mpi_comm_size__ 288 #define mpi_comm_rank_ mpi_comm_rank__ 289 #define mpi_abort_ mpi_abort__ 290 #define mpi_reduce_ mpi_reduce__ 291 #define mpi_allreduce_ mpi_allreduce__ 292 #define mpi_barrier_ mpi_barrier__ 293 #define mpi_bcast_ mpi_bcast__ 294 #define mpi_gather_ mpi_gather__ 295 #define mpi_allgather_ mpi_allgather__ 296 #define mpi_comm_split_ mpi_comm_split__ 297 #define mpi_scan_ mpi_scan__ 298 #define mpi_send_ mpi_send__ 299 #define mpi_recv_ mpi_recv__ 300 #define mpi_reduce_scatter_ mpi_reduce_scatter__ 301 #define mpi_irecv_ mpi_irecv__ 302 #define mpi_isend_ mpi_isend__ 303 #define mpi_sendrecv_ mpi_sendrecv__ 304 #define mpi_test_ mpi_test__ 305 #define mpi_waitall_ mpi_waitall__ 306 #define mpi_waitany_ mpi_waitany__ 307 #define mpi_allgatherv_ mpi_allgatherv__ 308 #define mpi_alltoallv_ mpi_alltoallv__ 309 #define mpi_comm_create_ mpi_comm_create__ 310 #define mpi_address_ mpi_address__ 311 #define mpi_pack_ mpi_pack__ 312 #define mpi_unpack_ mpi_unpack__ 313 #define mpi_pack_size_ mpi_pack_size__ 314 #define mpi_type_struct_ mpi_type_struct__ 315 #define mpi_type_commit_ mpi_type_commit__ 316 #define mpi_wtime_ mpi_wtime__ 317 #define mpi_cancel_ mpi_cancel__ 318 #define mpi_comm_dup_ mpi_comm_dup__ 319 #define mpi_comm_free_ mpi_comm_free__ 320 #define mpi_get_count_ mpi_get_count__ 321 #define mpi_get_processor_name_ mpi_get_processor_name__ 322 #define mpi_initialized_ mpi_initialized__ 323 #define mpi_iprobe_ mpi_iprobe__ 324 #define mpi_probe_ mpi_probe__ 325 #define mpi_request_free_ mpi_request_free__ 326 #define mpi_ssend_ mpi_ssend__ 327 #define mpi_wait_ mpi_wait__ 328 #define mpi_comm_group_ mpi_comm_group__ 329 #define mpi_exscan_ mpi_exscan__ 330 #endif 331 332 333 /* Do not build fortran interface if MPI namespace colision is to be avoided */ 334 #if !defined(MPIUNI_AVOID_MPI_NAMESPACE) 335 336 void PETSC_STDCALL mpi_init_(int *ierr) 337 { 338 *ierr = MPI_Init((int*)0, (char***)0); 339 } 340 341 void PETSC_STDCALL mpi_finalize_(int *ierr) 342 { 343 *ierr = MPI_Finalize(); 344 } 345 346 void PETSC_STDCALL mpi_comm_size_(MPI_Comm *comm,int *size,int *ierr) 347 { 348 *size = 1; 349 *ierr = 0; 350 } 351 352 void PETSC_STDCALL mpi_comm_rank_(MPI_Comm *comm,int *rank,int *ierr) 353 { 354 *rank=0; 355 *ierr=MPI_SUCCESS; 356 } 357 358 void PETSC_STDCALL mpi_comm_split_(MPI_Comm *comm,int *color,int *key, MPI_Comm *newcomm, int *ierr) 359 { 360 *newcomm = *comm; 361 *ierr=MPI_SUCCESS; 362 } 363 364 void PETSC_STDCALL mpi_abort_(MPI_Comm *comm,int *errorcode,int *ierr) 365 { 366 abort(); 367 *ierr = MPI_SUCCESS; 368 } 369 370 void PETSC_STDCALL mpi_reduce_(void *sendbuf,void *recvbuf,int *count,int *datatype,int *op,int *root,int *comm,int *ierr) 371 { 372 MPIUNI_Memcpy(recvbuf,sendbuf,(*count)*MPIUNI_DATASIZE[*datatype]); 373 *ierr = MPI_SUCCESS; 374 } 375 376 void PETSC_STDCALL mpi_allreduce_(void *sendbuf,void *recvbuf,int *count,int *datatype,int *op,int *comm,int *ierr) 377 { 378 MPIUNI_Memcpy(recvbuf,sendbuf,(*count)*MPIUNI_DATASIZE[*datatype]); 379 *ierr = MPI_SUCCESS; 380 } 381 382 void PETSC_STDCALL mpi_barrier_(MPI_Comm *comm,int *ierr) 383 { 384 *ierr = MPI_SUCCESS; 385 } 386 387 void PETSC_STDCALL mpi_bcast_(void *buf,int *count,int *datatype,int *root,int *comm,int *ierr) 388 { 389 *ierr = MPI_SUCCESS; 390 } 391 392 393 void PETSC_STDCALL mpi_gather_(void *sendbuf,int *scount,int *sdatatype, void* recvbuf, int* rcount, int* rdatatype, int *root,int *comm,int *ierr) 394 { 395 MPIUNI_Memcpy(recvbuf,sendbuf,(*scount)*MPIUNI_DATASIZE[*sdatatype]); 396 *ierr = MPI_SUCCESS; 397 } 398 399 void PETSC_STDCALL mpi_allgather_(void *sendbuf,int *scount,int *sdatatype, void* recvbuf, int* rcount, int* rdatatype,int *comm,int *ierr) 400 { 401 MPIUNI_Memcpy(recvbuf,sendbuf,(*scount)*MPIUNI_DATASIZE[*sdatatype]); 402 *ierr = MPI_SUCCESS; 403 } 404 405 void PETSC_STDCALL mpi_scan_(void *sendbuf,void *recvbuf,int *count,int *datatype,int *op,int *comm,int *ierr) 406 { 407 MPIUNI_Memcpy(recvbuf,sendbuf,(*count)*MPIUNI_DATASIZE[*datatype]); 408 *ierr = MPI_SUCCESS; 409 } 410 411 void PETSC_STDCALL mpi_send_(void*buf,int *count,int *datatype,int *dest,int *tag,int *comm,int *ierr ) 412 { 413 *ierr = MPI_Abort(MPI_COMM_WORLD,0); 414 } 415 416 void PETSC_STDCALL mpi_recv_(void*buf,int *count,int *datatype,int *source,int *tag,int *comm,int status,int *ierr ) 417 { 418 *ierr = MPI_Abort(MPI_COMM_WORLD,0); 419 } 420 421 void PETSC_STDCALL mpi_reduce_scatter_(void*sendbuf,void*recvbuf,int *recvcounts,int *datatype,int *op,int *comm,int *ierr) 422 { 423 *ierr = MPI_Abort(MPI_COMM_WORLD,0); 424 } 425 426 void PETSC_STDCALL mpi_irecv_(void*buf,int *count, int *datatype, int *source, int *tag, int *comm, int *request, int *ierr) 427 { 428 *ierr = MPI_Abort(MPI_COMM_WORLD,0); 429 } 430 431 void PETSC_STDCALL mpi_isend_(void*buf,int *count,int *datatype,int *dest,int *tag,int *comm,int *request, int *ierr) 432 { 433 *ierr = MPI_Abort(MPI_COMM_WORLD,0); 434 } 435 436 void PETSC_STDCALL mpi_sendrecv_(void*sendbuf,int *sendcount,int *sendtype,int *dest,int *sendtag,void*recvbuf,int *recvcount,int *recvtype,int *source,int *recvtag,int *comm,int *status,int *ierr) 437 { 438 MPIUNI_Memcpy(recvbuf,sendbuf,(*sendcount)*MPIUNI_DATASIZE[*sendtype]); 439 *ierr = MPI_SUCCESS; 440 } 441 442 void PETSC_STDCALL mpi_test_(int *request,int *flag,int *status,int *ierr) 443 { 444 *ierr = MPI_Abort(MPI_COMM_WORLD,0); 445 } 446 447 void PETSC_STDCALL mpi_waitall_(int *count,int *array_of_requests,int *array_of_statuses,int *ierr) 448 { 449 *ierr = MPI_SUCCESS; 450 } 451 452 void PETSC_STDCALL mpi_waitany_(int *count,int *array_of_requests,int * index, int *status,int *ierr) 453 { 454 *ierr = MPI_SUCCESS; 455 } 456 457 void PETSC_STDCALL mpi_allgatherv_(void*sendbuf,int *sendcount,int *sendtype,void*recvbuf,int *recvcounts,int *displs,int *recvtype,int *comm,int *ierr) 458 { 459 MPIUNI_Memcpy(recvbuf,sendbuf,(*sendcount)*MPIUNI_DATASIZE[*sendtype]); 460 *ierr = MPI_SUCCESS; 461 } 462 463 void PETSC_STDCALL mpi_alltoallv_(void*sendbuf,int *sendcounts,int *sdispls,int *sendtype,void*recvbuf,int *recvcounts,int *rdispls,int *recvtype,int *comm,int *ierr) 464 { 465 MPIUNI_Memcpy(recvbuf,sendbuf,(*sendcounts)*MPIUNI_DATASIZE[*sendtype]); 466 *ierr = MPI_SUCCESS; 467 } 468 469 void PETSC_STDCALL mpi_comm_create_(int *comm,int *group,int *newcomm,int *ierr) 470 { 471 *newcomm = *comm; 472 *ierr = MPI_SUCCESS; 473 } 474 475 void PETSC_STDCALL mpi_address_(void*location,MPIUNI_INTPTR *address,int *ierr) 476 { 477 *address = (MPIUNI_INTPTR) location; 478 *ierr = MPI_SUCCESS; 479 } 480 481 void PETSC_STDCALL mpi_pack_(void*inbuf,int *incount,int *datatype,void*outbuf,int *outsize,int *position,int *comm,int *ierr) 482 { 483 *ierr = MPI_Abort(MPI_COMM_WORLD,0); 484 } 485 486 void PETSC_STDCALL mpi_unpack_(void*inbuf,int *insize,int *position,void*outbuf,int *outcount,int *datatype,int *comm,int *ierr) 487 { 488 *ierr = MPI_Abort(MPI_COMM_WORLD,0); 489 } 490 491 void PETSC_STDCALL mpi_pack_size_(int *incount,int *datatype,int *comm,int *size,int *ierr) 492 { 493 *ierr = MPI_Abort(MPI_COMM_WORLD,0); 494 } 495 496 void PETSC_STDCALL mpi_type_struct_(int *count,int *array_of_blocklengths,int * array_of_displaments,int *array_of_types,int *newtype,int *ierr) 497 { 498 *ierr = MPI_Abort(MPI_COMM_WORLD,0); 499 } 500 501 void PETSC_STDCALL mpi_type_commit_(int *datatype,int *ierr) 502 { 503 *ierr = MPI_SUCCESS; 504 } 505 506 double PETSC_STDCALL mpi_wtime_(void) 507 { 508 return 0.0; 509 } 510 511 void PETSC_STDCALL mpi_cancel_(int *request,int *ierr) 512 { 513 *ierr = MPI_SUCCESS; 514 } 515 516 void PETSC_STDCALL mpi_comm_dup_(int *comm,int *out,int *ierr) 517 { 518 *out = *comm; 519 *ierr = MPI_SUCCESS; 520 } 521 522 void PETSC_STDCALL mpi_comm_free_(int *comm,int *ierr) 523 { 524 *ierr = MPI_SUCCESS; 525 } 526 527 void PETSC_STDCALL mpi_get_count_(int *status,int *datatype,int *count,int *ierr) 528 { 529 *ierr = MPI_Abort(MPI_COMM_WORLD,0); 530 } 531 532 /* duplicate from fortranimpl.h */ 533 #if defined(PETSC_HAVE_FORTRAN_MIXED_STR_ARG) 534 #define PETSC_MIXED_LEN(len) ,int len 535 #define PETSC_END_LEN(len) 536 #else 537 #define PETSC_MIXED_LEN(len) 538 #define PETSC_END_LEN(len) ,int len 539 #endif 540 541 void PETSC_STDCALL mpi_get_processor_name_(char *name PETSC_MIXED_LEN(len),int *result_len,int *ierr PETSC_END_LEN(len)) 542 { 543 MPIUNI_Memcpy(name,"localhost",9*sizeof(char)); 544 *result_len = 9; 545 *ierr = MPI_SUCCESS; 546 } 547 548 void PETSC_STDCALL mpi_initialized_(int *flag,int *ierr) 549 { 550 *flag = MPI_was_initialized; 551 *ierr = MPI_SUCCESS; 552 } 553 554 void PETSC_STDCALL mpi_iprobe_(int *source,int *tag,int *comm,int *glag,int *status,int *ierr) 555 { 556 *ierr = MPI_SUCCESS; 557 } 558 559 void PETSC_STDCALL mpi_probe_(int *source,int *tag,int *comm,int *flag,int *status,int *ierr) 560 { 561 *ierr = MPI_SUCCESS; 562 } 563 564 void PETSC_STDCALL mpi_request_free_(int *request,int *ierr) 565 { 566 *ierr = MPI_SUCCESS; 567 } 568 569 void PETSC_STDCALL mpi_ssend_(void*buf,int *count,int *datatype,int *dest,int *tag,int *comm,int *ierr) 570 { 571 *ierr = MPI_Abort(MPI_COMM_WORLD,0); 572 } 573 574 void PETSC_STDCALL mpi_wait_(int *request,int *status,int *ierr) 575 { 576 *ierr = MPI_SUCCESS; 577 } 578 579 void PETSC_STDCALL mpi_comm_group_(int*comm,int*group,int *ierr) 580 { 581 *ierr = MPI_SUCCESS; 582 } 583 584 void PETSC_STDCALL mpi_exscan_(void*sendbuf,void*recvbuf,int*count,int*datatype,int*op,int*comm,int*ierr) 585 { 586 *ierr = MPI_SUCCESS; 587 } 588 589 #endif /* MPIUNI_AVOID_MPI_NAMESPACE */ 590 591 #if defined(__cplusplus) 592 } 593 #endif 594