Date: 2016-07-24T16:48:33+00:00

Actual source code: mpi.c
petsc-3.7.3 2016-07-24
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