Actual source code: mpi.c

petsc-3.7.3 2016-08-01
Report Typos and Errors
  1: /*
  2:       This provides a few of the MPI-uni functions that cannot be implemented
  3:     with C macros
  4: */
  5: #include <petscsys.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

 13: #define MPI_SUCCESS 0
 14: #define MPI_FAILURE 1

 16: void *MPIUNI_TMP         = 0;
 17: 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)};
 18: /*
 19:        With MPI Uni there are exactly four distinct communicators:
 20:     MPI_COMM_SELF, MPI_COMM_WORLD, and a MPI_Comm_dup() of each of these (duplicates of duplicates return the same communictor)

 22:     MPI_COMM_SELF and MPI_COMM_WORLD are MPI_Comm_free() in MPI_Finalize() but in general with PETSc,
 23:      the other communicators are freed once the last PETSc object is freed (before MPI_Finalize()).

 25: */
 26: #define MAX_ATTR 128
 27: #define MAX_COMM 128

 29: static int MaxComm = 2;

 31: typedef struct {
 32:   void *attribute_val;
 33:   int  active;
 34: } MPI_Attr;

 36: typedef struct {
 37:   void                *extra_state;
 38:   MPI_Delete_function *del;
 39: } MPI_Attr_keyval;

 41: static MPI_Attr_keyval attr_keyval[MAX_ATTR];
 42: static MPI_Attr        attr[MAX_COMM][MAX_ATTR];
 43: static int             comm_active[MAX_COMM];
 44: static int             num_attr = 1,mpi_tag_ub = 100000000;
 45: static void*           MPIUNIF_mpi_in_place = 0;

 47: #if defined(__cplusplus)
 48: extern "C" {
 49: #endif

 51: /*
 52:    To avoid problems with prototypes to the system memcpy() it is duplicated here
 53: */
 54: int MPIUNI_Memcpy(void *a,const void *b,int n)
 55: {
 56:   int  i;
 57:   char *aa= (char*)a;
 58:   char *bb= (char*)b;

 60:   if (a == MPI_IN_PLACE || a == MPIUNIF_mpi_in_place) return 0;
 61:   if (b == MPI_IN_PLACE || b == MPIUNIF_mpi_in_place) return 0;
 62:   for (i=0; i<n; i++) aa[i] = bb[i];
 63:   return 0;
 64: }

 66: /*
 67:    Used to set the built-in MPI_TAG_UB attribute
 68: */
 69: static int Keyval_setup(void)
 70: {
 71:   attr[MPI_COMM_WORLD-1][0].active        = 1;
 72:   attr[MPI_COMM_WORLD-1][0].attribute_val = &mpi_tag_ub;
 73:   attr[MPI_COMM_SELF-1][0].active         = 1;
 74:   attr[MPI_COMM_SELF-1][0].attribute_val  = &mpi_tag_ub;
 75:   return 0;
 76: }

 78: int MPI_Keyval_create(MPI_Copy_function *copy_fn,MPI_Delete_function *delete_fn,int *keyval,void *extra_state)
 79: {
 80:   if (num_attr >= MAX_ATTR) MPI_Abort(MPI_COMM_WORLD,1);

 82:   attr_keyval[num_attr].extra_state = extra_state;
 83:   attr_keyval[num_attr].del         = delete_fn;
 84:   *keyval                           = num_attr++;
 85:   return 0;
 86: }

 88: int MPI_Keyval_free(int *keyval)
 89: {
 90:   attr_keyval[*keyval].extra_state = 0;
 91:   attr_keyval[*keyval].del         = 0;

 93:   *keyval = 0;
 94:   return MPI_SUCCESS;
 95: }

 97: int MPI_Attr_put(MPI_Comm comm,int keyval,void *attribute_val)
 98: {
 99:   if (comm-1 < 0 || comm-1 > MaxComm) return 1;
100:   attr[comm-1][keyval].active        = 1;
101:   attr[comm-1][keyval].attribute_val = attribute_val;
102:   return MPI_SUCCESS;
103: }

105: int MPI_Attr_delete(MPI_Comm comm,int keyval)
106: {
107:   if (comm-1 < 0 || comm-1 > MaxComm) return 1;
108:   if (attr[comm-1][keyval].active && attr_keyval[keyval].del) {
109:     void *save_attribute_val = attr[comm-1][keyval].attribute_val;
110:     attr[comm-1][keyval].active        = 0;
111:     attr[comm-1][keyval].attribute_val = 0;
112:     (*(attr_keyval[keyval].del))(comm,keyval,save_attribute_val,attr_keyval[keyval].extra_state);
113:   }
114:   return MPI_SUCCESS;
115: }

117: int MPI_Attr_get(MPI_Comm comm,int keyval,void *attribute_val,int *flag)
118: {
119:   if (comm-1 < 0 || comm-1 > MaxComm) return 1;
120:   if (!keyval) Keyval_setup();
121:   *flag                  = attr[comm-1][keyval].active;
122:   *(void**)attribute_val = attr[comm-1][keyval].attribute_val;
123:   return MPI_SUCCESS;
124: }

126: int MPI_Comm_create(MPI_Comm comm,MPI_Group group,MPI_Comm *newcomm)
127: {
128:   int j;
129:   if (comm-1 < 0 || comm-1 > MaxComm) return 1;
130:   for (j=3; j<MaxComm; j++) {
131:     if (!comm_active[j-1]) {
132:       comm_active[j-1] = 1;
133:       *newcomm = j;
134:       return MPI_SUCCESS;
135:     }
136:   }
137:   if (MaxComm > MAX_COMM) return MPI_FAILURE;
138:   *newcomm =  MaxComm++;
139:   comm_active[*newcomm-1] = 1;
140:   return MPI_SUCCESS;
141: }

143: int MPI_Comm_dup(MPI_Comm comm,MPI_Comm *out)
144: {
145:   int j;
146:   if (comm-1 < 0 || comm-1 > MaxComm) return 1;
147:   for (j=3; j<MaxComm; j++) {
148:     if (!comm_active[j-1]) {
149:       comm_active[j-1] = 1;
150:       *out = j;
151:       return MPI_SUCCESS;
152:     }
153:   }
154:   if (MaxComm > MAX_COMM) return MPI_FAILURE;
155:   *out = MaxComm++;
156:   comm_active[*out-1] = 1;
157:   return 0;
158: }

160: int MPI_Comm_free(MPI_Comm *comm)
161: {
162:   int i;

164:   if (*comm-1 < 0 || *comm-1 > MaxComm) return 1;
165:   for (i=0; i<num_attr; i++) {
166:     if (attr[*comm-1][i].active && attr_keyval[i].del) (*attr_keyval[i].del)(*comm,i,attr[*comm-1][i].attribute_val,attr_keyval[i].extra_state);
167:     attr[*comm-1][i].active        = 0;
168:     attr[*comm-1][i].attribute_val = 0;
169:   }
170:   if (*comm >= 3) comm_active[*comm-1] = 0;
171:   *comm = 0;
172:   return MPI_SUCCESS;
173: }

175: int MPI_Comm_size(MPI_Comm comm, int *size)
176: {
177:   if (comm-1 < 0 || comm-1 > MaxComm) return 1;
178:   *size=1;
179:   return MPI_SUCCESS;
180: }

182: int MPI_Comm_rank(MPI_Comm comm, int *rank)
183: {
184:   if (comm-1 < 0 || comm-1 > MaxComm) return 1;
185:   *rank=0;
186:   return MPI_SUCCESS;
187: }

189: int MPI_Abort(MPI_Comm comm,int errorcode)
190: {
191:   abort();
192:   return MPI_SUCCESS;
193: }

195: /* --------------------------------------------------------------------------*/

197: static int MPI_was_initialized = 0;
198: static int MPI_was_finalized   = 0;

200: int MPI_Init(int *argc, char ***argv)
201: {
202:   if (MPI_was_initialized) return 1;
203:   if (MPI_was_finalized) return 1;
204:   MPI_was_initialized = 1;
205:   return 0;
206: }

208: int MPI_Finalize(void)
209: {
210:   MPI_Comm comm;
211:   if (MPI_was_finalized) return 1;
212:   if (!MPI_was_initialized) return 1;
213:   comm = MPI_COMM_WORLD;
214:   MPI_Comm_free(&comm);
215:   comm = MPI_COMM_SELF;
216:   MPI_Comm_free(&comm);
217:   MPI_was_finalized = 1;
218:   return 0;
219: }

221: int MPI_Initialized(int *flag)
222: {
223:   *flag = MPI_was_initialized;
224:   return 0;
225: }

227: int MPI_Finalized(int *flag)
228: {
229:   *flag = MPI_was_finalized;
230:   return 0;
231: }

233: /* -------------------     Fortran versions of several routines ------------------ */

235: #if defined(PETSC_HAVE_FORTRAN_CAPS)
236: #define mpiunisetcommonblock_ MPIUNISETCOMMONBLOCK
237: #define mpiunisetfortranbasepointers_  MPIUNISETFORTRANBASEPOINTERS
238: #define mpi_init_             MPI_INIT
239: #define mpi_finalize_         MPI_FINALIZE
240: #define mpi_comm_size_        MPI_COMM_SIZE
241: #define mpi_comm_rank_        MPI_COMM_RANK
242: #define mpi_abort_            MPI_ABORT
243: #define mpi_reduce_           MPI_REDUCE
244: #define mpi_allreduce_        MPI_ALLREDUCE
245: #define mpi_barrier_          MPI_BARRIER
246: #define mpi_bcast_            MPI_BCAST
247: #define mpi_gather_           MPI_GATHER
248: #define mpi_allgather_        MPI_ALLGATHER
249: #define mpi_comm_split_       MPI_COMM_SPLIT
250: #define mpi_scan_             MPI_SCAN
251: #define mpi_send_             MPI_SEND
252: #define mpi_recv_             MPI_RECV
253: #define mpi_reduce_scatter_   MPI_REDUCE_SCATTER
254: #define mpi_irecv_            MPI_IRECV
255: #define mpi_isend_            MPI_ISEND
256: #define mpi_sendrecv_         MPI_SENDRECV
257: #define mpi_test_             MPI_TEST
258: #define mpi_waitall_          MPI_WAITALL
259: #define mpi_waitany_          MPI_WAITANY
260: #define mpi_allgatherv_       MPI_ALLGATHERV
261: #define mpi_alltoallv_        MPI_ALLTOALLV
262: #define mpi_comm_create_      MPI_COMM_CREATE
263: #define mpi_address_          MPI_ADDRESS
264: #define mpi_pack_             MPI_PACK
265: #define mpi_unpack_           MPI_UNPACK
266: #define mpi_pack_size_        MPI_PACK_SIZE
267: #define mpi_type_struct_      MPI_TYPE_STRUCT
268: #define mpi_type_commit_      MPI_TYPE_COMMIT
269: #define mpi_wtime_            MPI_WTIME
270: #define mpi_cancel_           MPI_CANCEL
271: #define mpi_comm_dup_         MPI_COMM_DUP
272: #define mpi_comm_free_        MPI_COMM_FREE
273: #define mpi_get_count_        MPI_GET_COUNT
274: #define mpi_get_processor_name_ MPI_GET_PROCESSOR_NAME
275: #define mpi_initialized_      MPI_INITIALIZED
276: #define mpi_iprobe_           MPI_IPROBE
277: #define mpi_probe_            MPI_PROBE
278: #define mpi_request_free_     MPI_REQUEST_FREE
279: #define mpi_ssend_            MPI_SSEND
280: #define mpi_wait_             MPI_WAIT
281: #define mpi_comm_group_       MPI_COMM_GROUP
282: #define mpi_exscan_           MPI_EXSCAN
283: #elif !defined(PETSC_HAVE_FORTRAN_UNDERSCORE)
284: #define mpiunisetcommonblock_ mpiunisetcommonblock
285: #define mpiunisetfortranbasepointers_  mpiunisetfortranbasepointers
286: #define mpi_init_             mpi_init
287: #define mpi_finalize_         mpi_finalize
288: #define mpi_comm_size_        mpi_comm_size
289: #define mpi_comm_rank_        mpi_comm_rank
290: #define mpi_abort_            mpi_abort
291: #define mpi_reduce_           mpi_reduce
292: #define mpi_allreduce_        mpi_allreduce
293: #define mpi_barrier_          mpi_barrier
294: #define mpi_bcast_            mpi_bcast
295: #define mpi_gather_           mpi_gather
296: #define mpi_allgather_        mpi_allgather
297: #define mpi_comm_split_       mpi_comm_split
298: #define mpi_scan_             mpi_scan
299: #define mpi_send_             mpi_send
300: #define mpi_recv_             mpi_recv
301: #define mpi_reduce_scatter_   mpi_reduce_scatter
302: #define mpi_irecv_            mpi_irecv
303: #define mpi_isend_            mpi_isend
304: #define mpi_sendrecv_         mpi_sendrecv
305: #define mpi_test_             mpi_test
306: #define mpi_waitall_          mpi_waitall
307: #define mpi_waitany_          mpi_waitany
308: #define mpi_allgatherv_       mpi_allgatherv
309: #define mpi_alltoallv_        mpi_alltoallv
310: #define mpi_comm_create_      mpi_comm_create
311: #define mpi_address_          mpi_address
312: #define mpi_pack_             mpi_pack
313: #define mpi_unpack_           mpi_unpack
314: #define mpi_pack_size_        mpi_pack_size
315: #define mpi_type_struct_      mpi_type_struct
316: #define mpi_type_commit_      mpi_type_commit
317: #define mpi_wtime_            mpi_wtime
318: #define mpi_cancel_           mpi_cancel
319: #define mpi_comm_dup_         mpi_comm_dup
320: #define mpi_comm_free_        mpi_comm_free
321: #define mpi_get_count_        mpi_get_count
322: #define mpi_get_processor_name_ mpi_get_processor_name
323: #define mpi_initialized_      mpi_initialized
324: #define mpi_iprobe_           mpi_iprobe
325: #define mpi_probe_            mpi_probe
326: #define mpi_request_free_     mpi_request_free
327: #define mpi_ssend_            mpi_ssend
328: #define mpi_wait_             mpi_wait
329: #define mpi_comm_group_       mpi_comm_group
330: #define mpi_exscan_           mpi_exscan
331: #endif

333: #if defined(PETSC_HAVE_FORTRAN_UNDERSCORE_UNDERSCORE)
334: #define mpi_init_             mpi_init__
335: #define mpi_finalize_         mpi_finalize__
336: #define mpi_comm_size_        mpi_comm_size__
337: #define mpi_comm_rank_        mpi_comm_rank__
338: #define mpi_abort_            mpi_abort__
339: #define mpi_reduce_           mpi_reduce__
340: #define mpi_allreduce_        mpi_allreduce__
341: #define mpi_barrier_          mpi_barrier__
342: #define mpi_bcast_            mpi_bcast__
343: #define mpi_gather_           mpi_gather__
344: #define mpi_allgather_        mpi_allgather__
345: #define mpi_comm_split_       mpi_comm_split__
346: #define mpi_scan_             mpi_scan__
347: #define mpi_send_             mpi_send__
348: #define mpi_recv_             mpi_recv__
349: #define mpi_reduce_scatter_   mpi_reduce_scatter__
350: #define mpi_irecv_            mpi_irecv__
351: #define mpi_isend_            mpi_isend__
352: #define mpi_sendrecv_         mpi_sendrecv__
353: #define mpi_test_             mpi_test__
354: #define mpi_waitall_          mpi_waitall__
355: #define mpi_waitany_          mpi_waitany__
356: #define mpi_allgatherv_       mpi_allgatherv__
357: #define mpi_alltoallv_        mpi_alltoallv__
358: #define mpi_comm_create_      mpi_comm_create__
359: #define mpi_address_          mpi_address__
360: #define mpi_pack_             mpi_pack__
361: #define mpi_unpack_           mpi_unpack__
362: #define mpi_pack_size_        mpi_pack_size__
363: #define mpi_type_struct_      mpi_type_struct__
364: #define mpi_type_commit_      mpi_type_commit__
365: #define mpi_wtime_            mpi_wtime__
366: #define mpi_cancel_           mpi_cancel__
367: #define mpi_comm_dup_         mpi_comm_dup__
368: #define mpi_comm_free_        mpi_comm_free__
369: #define mpi_get_count_        mpi_get_count__
370: #define mpi_get_processor_name_ mpi_get_processor_name__
371: #define mpi_initialized_      mpi_initialized__
372: #define mpi_iprobe_           mpi_iprobe__
373: #define mpi_probe_            mpi_probe__
374: #define mpi_request_free_     mpi_request_free__
375: #define mpi_ssend_            mpi_ssend__
376: #define mpi_wait_             mpi_wait__
377: #define mpi_comm_group_       mpi_comm_group__
378: #define mpi_exscan_           mpi_exscan__
379: #endif

381: /* Do not build fortran interface if MPI namespace colision is to be avoided */
382: #if defined(MPIUNI_FORTRAN_BINDING)

384: PETSC_EXTERN void PETSC_STDCALL mpiunisetcommonblock_(void);

386: PETSC_EXTERN void PETSC_STDCALL mpiunisetfortranbasepointers_(void *f_mpi_in_place)
387: {
388:   MPIUNIF_mpi_in_place   = f_mpi_in_place;
389: }

391: PETSC_EXTERN void PETSC_STDCALL   mpi_init_(int *ierr)
392: {
393:   mpiunisetcommonblock_();
394:   *MPI_Init((int*)0, (char***)0);
395: }

397: PETSC_EXTERN void PETSC_STDCALL   mpi_finalize_(int *ierr)
398: {
399:   *MPI_Finalize();
400: }

402: PETSC_EXTERN void PETSC_STDCALL  mpi_comm_size_(MPI_Comm *comm,int *size,int *ierr)
403: {
404:   *size = 1;
405:   *0;
406: }

408: PETSC_EXTERN void PETSC_STDCALL  mpi_comm_rank_(MPI_Comm *comm,int *rank,int *ierr)
409: {
410:   *rank = 0;
411:   *MPI_SUCCESS;
412: }

414: PETSC_EXTERN void PETSC_STDCALL  mpi_comm_split_(MPI_Comm *comm,int *color,int *key, MPI_Comm *newcomm, int *ierr)
415: {
416:   *newcomm = *comm;
417:   *MPI_SUCCESS;
418: }

420: PETSC_EXTERN void PETSC_STDCALL  mpi_abort_(MPI_Comm *comm,int *errorcode,int *ierr)
421: {
422:   abort();
423:   *MPI_SUCCESS;
424: }

426: PETSC_EXTERN void PETSC_STDCALL  mpi_reduce_(void *sendbuf,void *recvbuf,int *count,int *datatype,int *op,int *root,int *comm,int *ierr)
427: {
428:   *MPI_Reduce(sendbuf,recvbuf,*count,*datatype,*op,*root,*comm);
429: }

431: PETSC_EXTERN void PETSC_STDCALL  mpi_allreduce_(void *sendbuf,void *recvbuf,int *count,int *datatype,int *op,int *comm,int *ierr)
432: {
433:   *MPI_Allreduce(sendbuf,recvbuf,*count,*datatype,*op,*comm);
434: }

436: PETSC_EXTERN void PETSC_STDCALL  mpi_barrier_(MPI_Comm *comm,int *ierr)
437: {
438:   *MPI_SUCCESS;
439: }

441: PETSC_EXTERN void PETSC_STDCALL  mpi_bcast_(void *buf,int *count,int *datatype,int *root,int *comm,int *ierr)
442: {
443:   *MPI_SUCCESS;
444: }

446: PETSC_EXTERN void PETSC_STDCALL  mpi_gather_(void *sendbuf,int *scount,int *sdatatype, void *recvbuf, int *rcount, int *rdatatype, int *root,int *comm,int *ierr)
447: {
448:   *MPI_Gather(sendbuf,*scount,*sdatatype,recvbuf,rcount,rdatatype,*root,*comm);
449: }

451: PETSC_EXTERN void PETSC_STDCALL  mpi_allgather_(void *sendbuf,int *scount,int *sdatatype, void *recvbuf, int *rcount, int *rdatatype,int *comm,int *ierr)
452: {
453:   *MPI_Allgather(sendbuf,*scount,*sdatatype,recvbuf,rcount,rdatatype,*comm);
454: }

456: PETSC_EXTERN void PETSC_STDCALL  mpi_scan_(void *sendbuf,void *recvbuf,int *count,int *datatype,int *op,int *comm,int *ierr)
457: {
458:   *MPIUNI_Memcpy(recvbuf,sendbuf,(*count)*MPIUNI_DATASIZE[*datatype]);
459: }

461: PETSC_EXTERN void PETSC_STDCALL  mpi_send_(void *buf,int *count,int *datatype,int *dest,int *tag,int *comm,int *ierr)
462: {
463:   *MPI_Abort(MPI_COMM_WORLD,0);
464: }

466: PETSC_EXTERN void PETSC_STDCALL  mpi_recv_(void *buf,int *count,int *datatype,int *source,int *tag,int *comm,int status,int *ierr)
467: {
468:   *MPI_Abort(MPI_COMM_WORLD,0);
469: }

471: PETSC_EXTERN void PETSC_STDCALL  mpi_reduce_scatter_(void *sendbuf,void *recvbuf,int *recvcounts,int *datatype,int *op,int *comm,int *ierr)
472: {
473:   *MPI_Abort(MPI_COMM_WORLD,0);
474: }

476: PETSC_EXTERN void PETSC_STDCALL  mpi_irecv_(void *buf,int *count, int *datatype, int *source, int *tag, int *comm, int *request, int *ierr)
477: {
478:   *MPI_Abort(MPI_COMM_WORLD,0);
479: }

481: PETSC_EXTERN void PETSC_STDCALL  mpi_isend_(void *buf,int *count,int *datatype,int *dest,int *tag,int *comm,int *request, int *ierr)
482: {
483:   *MPI_Abort(MPI_COMM_WORLD,0);
484: }

486: PETSC_EXTERN 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)
487: {
488:   *MPIUNI_Memcpy(recvbuf,sendbuf,(*sendcount)*MPIUNI_DATASIZE[*sendtype]);
489: }

491: PETSC_EXTERN void PETSC_STDCALL  mpi_test_(int *request,int *flag,int *status,int *ierr)
492: {
493:   *MPI_Abort(MPI_COMM_WORLD,0);
494: }

496: PETSC_EXTERN void PETSC_STDCALL  mpi_waitall_(int *count,int *array_of_requests,int *array_of_statuses,int *ierr)
497: {
498:   *MPI_SUCCESS;
499: }

501: PETSC_EXTERN void PETSC_STDCALL  mpi_waitany_(int *count,int *array_of_requests,int * index, int *status,int *ierr)
502: {
503:   *MPI_SUCCESS;
504: }

506: PETSC_EXTERN void PETSC_STDCALL  mpi_allgatherv_(void *sendbuf,int *sendcount,int *sendtype,void *recvbuf,int *recvcounts,int *displs,int *recvtype,int *comm,int *ierr)
507: {
508:   *MPI_Allgatherv(sendbuf,*sendcount,*sendtype,recvbuf,recvcounts,displs,*recvtype,*comm);
509: }

511: PETSC_EXTERN 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)
512: {
513:   *MPI_Alltoallv(sendbuf,sendcounts,sdispls,*sendtype,recvbuf,recvcounts,rdispls,*recvtype,*comm);
514: }

516: PETSC_EXTERN void PETSC_STDCALL  mpi_comm_create_(int *comm,int *group,int *newcomm,int *ierr)
517: {
518:   *newcomm =  *comm;
519:   *MPI_SUCCESS;
520: }

522: PETSC_EXTERN void PETSC_STDCALL  mpi_address_(void *location,MPIUNI_INTPTR *address,int *ierr)
523: {
524:   *address =  (MPIUNI_INTPTR) location;
525:   *MPI_SUCCESS;
526: }

528: PETSC_EXTERN void PETSC_STDCALL  mpi_pack_(void *inbuf,int *incount,int *datatype,void *outbuf,int *outsize,int *position,int *comm,int *ierr)
529: {
530:   *MPI_Abort(MPI_COMM_WORLD,0);
531: }

533: PETSC_EXTERN void PETSC_STDCALL  mpi_unpack_(void *inbuf,int *insize,int *position,void *outbuf,int *outcount,int *datatype,int *comm,int *ierr)
534: {
535:   *MPI_Abort(MPI_COMM_WORLD,0);
536: }

538: PETSC_EXTERN void PETSC_STDCALL  mpi_pack_size_(int *incount,int *datatype,int *comm,int *size,int *ierr)
539: {
540:   *MPI_Abort(MPI_COMM_WORLD,0);
541: }

543: PETSC_EXTERN void PETSC_STDCALL  mpi_type_struct_(int *count,int *array_of_blocklengths,int * array_of_displaments,int *array_of_types,int *newtype,int *ierr)
544: {
545:   *MPI_Abort(MPI_COMM_WORLD,0);
546: }

548: PETSC_EXTERN void PETSC_STDCALL  mpi_type_commit_(int *datatype,int *ierr)
549: {
550:   *MPI_SUCCESS;
551: }

553: double PETSC_STDCALL mpi_wtime_(void)
554: {
555:   return 0.0;
556: }

558: PETSC_EXTERN void PETSC_STDCALL  mpi_cancel_(int *request,int *ierr)
559: {
560:   *MPI_SUCCESS;
561: }

563: PETSC_EXTERN void PETSC_STDCALL  mpi_comm_dup_(int *comm,int *out,int *ierr)
564: {
565:   *out  = *comm;
566:   *MPI_SUCCESS;
567: }

569: PETSC_EXTERN void PETSC_STDCALL  mpi_comm_free_(int *comm,int *ierr)
570: {
571:   *MPI_SUCCESS;
572: }

574: PETSC_EXTERN void PETSC_STDCALL  mpi_get_count_(int *status,int *datatype,int *count,int *ierr)
575: {
576:   *MPI_Abort(MPI_COMM_WORLD,0);
577: }

579: /* duplicate from fortranimpl.h */
580: #if defined(PETSC_HAVE_FORTRAN_MIXED_STR_ARG)
581: #define PETSC_MIXED_LEN(len) ,int len
582: #define PETSC_END_LEN(len)
583: #else
584: #define PETSC_MIXED_LEN(len)
585: #define PETSC_END_LEN(len)   ,int len
586: #endif

588: PETSC_EXTERN void PETSC_STDCALL  mpi_get_processor_name_(char *name PETSC_MIXED_LEN(len),int *result_len,int *ierr PETSC_END_LEN(len))
589: {
590:   MPIUNI_Memcpy(name,"localhost",9*sizeof(char));
591:   *result_len = 9;
592:   *MPI_SUCCESS;
593: }

595: PETSC_EXTERN void PETSC_STDCALL  mpi_initialized_(int *flag,int *ierr)
596: {
597:   *flag = MPI_was_initialized;
598:   *MPI_SUCCESS;
599: }

601: PETSC_EXTERN void PETSC_STDCALL  mpi_iprobe_(int *source,int *tag,int *comm,int *glag,int *status,int *ierr)
602: {
603:   *MPI_SUCCESS;
604: }

606: PETSC_EXTERN void PETSC_STDCALL  mpi_probe_(int *source,int *tag,int *comm,int *flag,int *status,int *ierr)
607: {
608:   *MPI_SUCCESS;
609: }

611: PETSC_EXTERN void PETSC_STDCALL  mpi_request_free_(int *request,int *ierr)
612: {
613:   *MPI_SUCCESS;
614: }

616: PETSC_EXTERN void PETSC_STDCALL  mpi_ssend_(void *buf,int *count,int *datatype,int *dest,int *tag,int *comm,int *ierr)
617: {
618:   *MPI_Abort(MPI_COMM_WORLD,0);
619: }

621: PETSC_EXTERN void PETSC_STDCALL  mpi_wait_(int *request,int *status,int *ierr)
622: {
623:   *MPI_SUCCESS;
624: }

626: PETSC_EXTERN void PETSC_STDCALL  mpi_comm_group_(int *comm,int *group,int *ierr)
627: {
628:   *MPI_SUCCESS;
629: }

631: PETSC_EXTERN void PETSC_STDCALL  mpi_exscan_(void *sendbuf,void *recvbuf,int *count,int *datatype,int *op,int *comm,int *ierr)
632: {
633:   *MPI_SUCCESS;
634: }

636: #endif /* MPIUNI_AVOID_MPI_NAMESPACE */

638: #if defined(__cplusplus)
639: }
640: #endif