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