Date: 2013-07-02T14:39:21+00:00

Actual source code: mpi.c
petsc-3.4.2 2013-07-02

      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>
      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

     17: #define MPI_SUCCESS 0
     18: #define MPI_FAILURE 1

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

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

     29: */
     30: #define MAX_ATTR 128

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

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

     42: static MPI_Attr_keyval attr_keyval[MAX_ATTR];
     43: static MPI_Attr        attr[4][MAX_ATTR];
     44: static int             num_attr = 1,mpi_tag_ub = 100000000;

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

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

     59:   if (b == MPI_IN_PLACE) return 0;
     60:   for (i=0; i<n; i++) aa[i] = bb[i];
     61:   return 0;
     62: }

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

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

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

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

     91:   *keyval = 0;
     92:   return MPI_SUCCESS;
     93: }

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

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

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

    124: static int dups[4] = {1,1,1,1};
    125: int MPI_Comm_create(MPI_Comm comm,MPI_Group group,MPI_Comm *newcomm)
    126: {
    127:   if (comm-1 < 0 || comm-1 > 3) return 1;
    128:   dups[comm-1]++;
    129:   *newcomm =  comm;
    130:   return MPI_SUCCESS;
    131: }

    133: int MPI_Comm_dup(MPI_Comm comm,MPI_Comm *out)
    134: {
    135:   if (comm-1 < 0 || comm-1 > 3) return 1;
    136:   if (comm == MPI_COMM_WORLD || comm == MPI_COMM_SELF) *out = comm + 2;
    137:   else {
    138:     *out = comm;
    139:     dups[comm-1]++;
    140:   }
    141:   return 0;
    142: }

    144: int MPI_Comm_free(MPI_Comm *comm)
    145: {
    146:   int i;

    148:   if (*comm-1 < 0 || *comm-1 > 3) return 1;
    149:   if (dups[*comm-1] == 1) {
    150:     for (i=0; i<num_attr; i++) {
    151:       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);
    152:       attr[*comm-1][i].active        = 0;
    153:       attr[*comm-1][i].attribute_val = 0;
    154:     }
    155:     dups[*comm-1] = 1;
    156:     *comm = 0;
    157:   } else if (dups[*comm-1] > 1) dups[*comm-1]--;
    158:   return MPI_SUCCESS;
    159: }

    161: int MPI_Comm_size(MPI_Comm comm, int *size)
    162: {
    163:   *size=1;
    164:   return MPI_SUCCESS;
    165: }

    167: int MPI_Comm_rank(MPI_Comm comm, int *rank)
    168: {
    169:   *rank=0;
    170:   return MPI_SUCCESS;
    171: }

    173: int MPI_Abort(MPI_Comm comm,int errorcode)
    174: {
    175:   abort();
    176:   return MPI_SUCCESS;
    177: }

    179: /* --------------------------------------------------------------------------*/

    181: static int MPI_was_initialized = 0;
    182: static int MPI_was_finalized   = 0;

    184: int MPI_Init(int *argc, char ***argv)
    185: {
    186:   if (MPI_was_initialized) return 1;
    187:   if (MPI_was_finalized) return 1;
    188:   MPI_was_initialized = 1;
    189:   return 0;
    190: }

    192: int MPI_Finalize(void)
    193: {
    194:   MPI_Comm comm;
    195:   if (MPI_was_finalized) return 1;
    196:   if (!MPI_was_initialized) return 1;
    197:   comm = MPI_COMM_WORLD;
    198:   MPI_Comm_free(&comm);
    199:   comm = MPI_COMM_SELF;
    200:   MPI_Comm_free(&comm);
    201:   MPI_was_finalized = 1;
    202:   return 0;
    203: }

    205: int MPI_Initialized(int *flag)
    206: {
    207:   *flag = MPI_was_initialized;
    208:   return 0;
    209: }

    211: int MPI_Finalized(int *flag)
    212: {
    213:   *flag = MPI_was_finalized;
    214:   return 0;
    215: }

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

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

    313: #if defined(PETSC_HAVE_FORTRAN_UNDERSCORE_UNDERSCORE)
    314: #define mpi_init_             mpi_init__
    315: #define mpi_finalize_         mpi_finalize__
    316: #define mpi_comm_size_        mpi_comm_size__
    317: #define mpi_comm_rank_        mpi_comm_rank__
    318: #define mpi_abort_            mpi_abort__
    319: #define mpi_reduce_           mpi_reduce__
    320: #define mpi_allreduce_        mpi_allreduce__
    321: #define mpi_barrier_          mpi_barrier__
    322: #define mpi_bcast_            mpi_bcast__
    323: #define mpi_gather_           mpi_gather__
    324: #define mpi_allgather_        mpi_allgather__
    325: #define mpi_comm_split_       mpi_comm_split__
    326: #define mpi_scan_             mpi_scan__
    327: #define mpi_send_             mpi_send__
    328: #define mpi_recv_             mpi_recv__
    329: #define mpi_reduce_scatter_   mpi_reduce_scatter__
    330: #define mpi_irecv_            mpi_irecv__
    331: #define mpi_isend_            mpi_isend__
    332: #define mpi_sendrecv_         mpi_sendrecv__
    333: #define mpi_test_             mpi_test__
    334: #define mpi_waitall_          mpi_waitall__
    335: #define mpi_waitany_          mpi_waitany__
    336: #define mpi_allgatherv_       mpi_allgatherv__
    337: #define mpi_alltoallv_        mpi_alltoallv__
    338: #define mpi_comm_create_      mpi_comm_create__
    339: #define mpi_address_          mpi_address__
    340: #define mpi_pack_             mpi_pack__
    341: #define mpi_unpack_           mpi_unpack__
    342: #define mpi_pack_size_        mpi_pack_size__
    343: #define mpi_type_struct_      mpi_type_struct__
    344: #define mpi_type_commit_      mpi_type_commit__
    345: #define mpi_wtime_            mpi_wtime__
    346: #define mpi_cancel_           mpi_cancel__
    347: #define mpi_comm_dup_         mpi_comm_dup__
    348: #define mpi_comm_free_        mpi_comm_free__
    349: #define mpi_get_count_        mpi_get_count__
    350: #define mpi_get_processor_name_ mpi_get_processor_name__
    351: #define mpi_initialized_      mpi_initialized__
    352: #define mpi_iprobe_           mpi_iprobe__
    353: #define mpi_probe_            mpi_probe__
    354: #define mpi_request_free_     mpi_request_free__
    355: #define mpi_ssend_            mpi_ssend__
    356: #define mpi_wait_             mpi_wait__
    357: #define mpi_comm_group_       mpi_comm_group__
    358: #define mpi_exscan_           mpi_exscan__
    359: #endif

    362: /* Do not build fortran interface if MPI namespace colision is to be avoided */
    363: #if !defined(MPIUNI_AVOID_MPI_NAMESPACE)

    365: void PETSC_STDCALL  mpi_init_(int *ierr)
    366: {
    367:   *MPI_Init((int*)0, (char***)0);
    368: }

    370: void PETSC_STDCALL  mpi_finalize_(int *ierr)
    371: {
    372:   *MPI_Finalize();
    373: }

    375: void PETSC_STDCALL mpi_comm_size_(MPI_Comm *comm,int *size,int *ierr)
    376: {
    377:   *size = 1;
    378:   *0;
    379: }

    381: void PETSC_STDCALL mpi_comm_rank_(MPI_Comm *comm,int *rank,int *ierr)
    382: {
    383:   *rank=0;
    384:   *ierr=MPI_SUCCESS;
    385: }

    387: void PETSC_STDCALL mpi_comm_split_(MPI_Comm *comm,int *color,int *key, MPI_Comm *newcomm, int *ierr)
    388: {
    389:   *newcomm = *comm;
    390:   *ierr    =MPI_SUCCESS;
    391: }

    393: void PETSC_STDCALL mpi_abort_(MPI_Comm *comm,int *errorcode,int *ierr)
    394: {
    395:   abort();
    396:   *MPI_SUCCESS;
    397: }

    399: void PETSC_STDCALL mpi_reduce_(void *sendbuf,void *recvbuf,int *count,int *datatype,int *op,int *root,int *comm,int *ierr)
    400: {
    401:   MPIUNI_Memcpy(recvbuf,sendbuf,(*count)*MPIUNI_DATASIZE[*datatype]);
    402:   *MPI_SUCCESS;
    403: }

    405: void PETSC_STDCALL mpi_allreduce_(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:   *MPI_SUCCESS;
    409: }

    411: void PETSC_STDCALL mpi_barrier_(MPI_Comm *comm,int *ierr)
    412: {
    413:   *MPI_SUCCESS;
    414: }

    416: void PETSC_STDCALL mpi_bcast_(void *buf,int *count,int *datatype,int *root,int *comm,int *ierr)
    417: {
    418:   *MPI_SUCCESS;
    419: }

    422: void PETSC_STDCALL mpi_gather_(void *sendbuf,int *scount,int *sdatatype, void *recvbuf, int *rcount, int *rdatatype, int *root,int *comm,int *ierr)
    423: {
    424:   MPIUNI_Memcpy(recvbuf,sendbuf,(*scount)*MPIUNI_DATASIZE[*sdatatype]);
    425:   *MPI_SUCCESS;
    426: }

    428: void PETSC_STDCALL mpi_allgather_(void *sendbuf,int *scount,int *sdatatype, void *recvbuf, int *rcount, int *rdatatype,int *comm,int *ierr)
    429: {
    430:   MPIUNI_Memcpy(recvbuf,sendbuf,(*scount)*MPIUNI_DATASIZE[*sdatatype]);
    431:   *MPI_SUCCESS;
    432: }

    434: void PETSC_STDCALL mpi_scan_(void *sendbuf,void *recvbuf,int *count,int *datatype,int *op,int *comm,int *ierr)
    435: {
    436:   MPIUNI_Memcpy(recvbuf,sendbuf,(*count)*MPIUNI_DATASIZE[*datatype]);
    437:   *MPI_SUCCESS;
    438: }

    440: void PETSC_STDCALL mpi_send_(void *buf,int *count,int *datatype,int *dest,int *tag,int *comm,int *ierr)
    441: {
    442:   *MPI_Abort(MPI_COMM_WORLD,0);
    443: }

    445: void PETSC_STDCALL mpi_recv_(void *buf,int *count,int *datatype,int *source,int *tag,int *comm,int status,int *ierr)
    446: {
    447:   *MPI_Abort(MPI_COMM_WORLD,0);
    448: }

    450: void PETSC_STDCALL mpi_reduce_scatter_(void *sendbuf,void *recvbuf,int *recvcounts,int *datatype,int *op,int *comm,int *ierr)
    451: {
    452:   *MPI_Abort(MPI_COMM_WORLD,0);
    453: }

    455: void PETSC_STDCALL mpi_irecv_(void *buf,int *count, int *datatype, int *source, int *tag, int *comm, int *request, int *ierr)
    456: {
    457:   *MPI_Abort(MPI_COMM_WORLD,0);
    458: }

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

    465: 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)
    466: {
    467:   MPIUNI_Memcpy(recvbuf,sendbuf,(*sendcount)*MPIUNI_DATASIZE[*sendtype]);
    468:   *MPI_SUCCESS;
    469: }

    471: void PETSC_STDCALL mpi_test_(int *request,int *flag,int *status,int *ierr)
    472: {
    473:   *MPI_Abort(MPI_COMM_WORLD,0);
    474: }

    476: void PETSC_STDCALL mpi_waitall_(int *count,int *array_of_requests,int *array_of_statuses,int *ierr)
    477: {
    478:   *MPI_SUCCESS;
    479: }

    481: void PETSC_STDCALL mpi_waitany_(int *count,int *array_of_requests,int * index, int *status,int *ierr)
    482: {
    483:   *MPI_SUCCESS;
    484: }

    486: void PETSC_STDCALL mpi_allgatherv_(void *sendbuf,int *sendcount,int *sendtype,void *recvbuf,int *recvcounts,int *displs,int *recvtype,int *comm,int *ierr)
    487: {
    488:   MPIUNI_Memcpy(recvbuf,sendbuf,(*sendcount)*MPIUNI_DATASIZE[*sendtype]);
    489:   *MPI_SUCCESS;
    490: }

    492: 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)
    493: {
    494:   MPIUNI_Memcpy(recvbuf,sendbuf,(*sendcounts)*MPIUNI_DATASIZE[*sendtype]);
    495:   *MPI_SUCCESS;
    496: }

    498: void PETSC_STDCALL mpi_comm_create_(int *comm,int *group,int *newcomm,int *ierr)
    499: {
    500:   *newcomm =  *comm;
    501:   *MPI_SUCCESS;
    502: }

    504: void PETSC_STDCALL mpi_address_(void *location,MPIUNI_INTPTR *address,int *ierr)
    505: {
    506:   *address =  (MPIUNI_INTPTR) location;
    507:   *MPI_SUCCESS;
    508: }

    510: void PETSC_STDCALL mpi_pack_(void *inbuf,int *incount,int *datatype,void *outbuf,int *outsize,int *position,int *comm,int *ierr)
    511: {
    512:   *MPI_Abort(MPI_COMM_WORLD,0);
    513: }

    515: void PETSC_STDCALL mpi_unpack_(void *inbuf,int *insize,int *position,void *outbuf,int *outcount,int *datatype,int *comm,int *ierr)
    516: {
    517:   *MPI_Abort(MPI_COMM_WORLD,0);
    518: }

    520: void PETSC_STDCALL mpi_pack_size_(int *incount,int *datatype,int *comm,int *size,int *ierr)
    521: {
    522:   *MPI_Abort(MPI_COMM_WORLD,0);
    523: }

    525: void PETSC_STDCALL mpi_type_struct_(int *count,int *array_of_blocklengths,int * array_of_displaments,int *array_of_types,int *newtype,int *ierr)
    526: {
    527:   *MPI_Abort(MPI_COMM_WORLD,0);
    528: }

    530: void PETSC_STDCALL mpi_type_commit_(int *datatype,int *ierr)
    531: {
    532:   *MPI_SUCCESS;
    533: }

    535: double PETSC_STDCALL mpi_wtime_(void)
    536: {
    537:   return 0.0;
    538: }

    540: void PETSC_STDCALL mpi_cancel_(int *request,int *ierr)
    541: {
    542:   *MPI_SUCCESS;
    543: }

    545: void PETSC_STDCALL mpi_comm_dup_(int *comm,int *out,int *ierr)
    546: {
    547:   *out  = *comm;
    548:   *MPI_SUCCESS;
    549: }

    551: void PETSC_STDCALL mpi_comm_free_(int *comm,int *ierr)
    552: {
    553:   *MPI_SUCCESS;
    554: }

    556: void PETSC_STDCALL mpi_get_count_(int *status,int *datatype,int *count,int *ierr)
    557: {
    558:   *MPI_Abort(MPI_COMM_WORLD,0);
    559: }

    561: /* duplicate from fortranimpl.h */
    562: #if defined(PETSC_HAVE_FORTRAN_MIXED_STR_ARG)
    563: #define PETSC_MIXED_LEN(len) ,int len
    564: #define PETSC_END_LEN(len)
    565: #else
    566: #define PETSC_MIXED_LEN(len)
    567: #define PETSC_END_LEN(len)   ,int len
    568: #endif

    570: void PETSC_STDCALL mpi_get_processor_name_(char *name PETSC_MIXED_LEN(len),int *result_len,int *ierr PETSC_END_LEN(len))
    571: {
    572:   MPIUNI_Memcpy(name,"localhost",9*sizeof(char));
    573:   *result_len = 9;
    574:   *MPI_SUCCESS;
    575: }

    577: void PETSC_STDCALL mpi_initialized_(int *flag,int *ierr)
    578: {
    579:   *flag = MPI_was_initialized;
    580:   *MPI_SUCCESS;
    581: }

    583: void PETSC_STDCALL mpi_iprobe_(int *source,int *tag,int *comm,int *glag,int *status,int *ierr)
    584: {
    585:   *MPI_SUCCESS;
    586: }

    588: void PETSC_STDCALL mpi_probe_(int *source,int *tag,int *comm,int *flag,int *status,int *ierr)
    589: {
    590:   *MPI_SUCCESS;
    591: }

    593: void PETSC_STDCALL mpi_request_free_(int *request,int *ierr)
    594: {
    595:   *MPI_SUCCESS;
    596: }

    598: void PETSC_STDCALL mpi_ssend_(void *buf,int *count,int *datatype,int *dest,int *tag,int *comm,int *ierr)
    599: {
    600:   *MPI_Abort(MPI_COMM_WORLD,0);
    601: }

    603: void PETSC_STDCALL mpi_wait_(int *request,int *status,int *ierr)
    604: {
    605:   *MPI_SUCCESS;
    606: }

    608: void PETSC_STDCALL mpi_comm_group_(int *comm,int *group,int *ierr)
    609: {
    610:   *MPI_SUCCESS;
    611: }

    613: void PETSC_STDCALL mpi_exscan_(void *sendbuf,void *recvbuf,int *count,int *datatype,int *op,int *comm,int *ierr)
    614: {
    615:   *MPI_SUCCESS;
    616: }

    618: #endif /* MPIUNI_AVOID_MPI_NAMESPACE */

    620: #if defined(__cplusplus)
    621: }
    622: #endif