VMPI_wrappers.c

Go to the documentation of this file.

/* ############################ MALP License ############################## */
/* # Fri Jan 18 14:00:00 CET 2013                                         # */
/* # Copyright or (C) or Copr. Commissariat a l'Energie Atomique          # */
/* #                                                                      # */
/* # This software is governed by the CeCILL-C license under French law   # */
/* # and abiding by the rules of distribution of free software.  You can  # */
/* # use, modify and/ or redistribute the software under the terms of     # */
/* # the CeCILL-C license as circulated by CEA, CNRS and INRIA at the     # */
/* # following URL http://www.cecill.info.                                # */
/* #                                                                      # */
/* # The fact that you are presently reading this means that you have     # */
/* # had knowledge of the CeCILL-C license and that you accept its        # */
/* # terms.                                                               # */
/* #                                                                      # */
/* # Authors:                                                             # */
/* #   - BESNARD Jean-Baptiste jean-baptiste.besnard@cea.fr               # */
/* #                                                                      # */
/* ######################################################################## */
#include <VMPI.h>
#include "VMPI_Wrap.h"

#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>


/* We have a special case for Init and Finalize to init and release the Virtualization interface */

int  MPI_Init(int * argc, char *** argv)
{
        int ret;
        
        ret = PMPI_Init(argc , argv );  

        /* run VMPI init */
        VMPI_Init(argc, argv);
        
        return ret;
}




int MPI_Init_thread(int * argc ,char * * * argv ,int required ,int * provided)
{
        int ret;
        
        /* run MPI init */
        if( (ret = PMPI_Init_thread(argc, argv, required, provided)) != MPI_SUCCESS )
                return -1;

        /* run VMPI init */
        VMPI_Init(argc, argv);

        return ret;
}

int MPI_Finalize()
{
        int ret;
        
        /* Cleanup VMPI */
        VMPI_Release();
        
        ret = PMPI_Finalize();
        
        return ret;

}

/* Lets wrap all MPI functions except those we already defined */

int MPI_Abort( MPI_Comm comm, int errorcode )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Abort( comm, errorcode );
        return ret;
}
int MPI_Accumulate( void * origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win )
{

        
        int ret = PMPI_Accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, op, win );
        return ret;
}
int MPI_Add_error_class( int * errorclass )
{

        
        int ret = PMPI_Add_error_class( errorclass );
        return ret;
}
int MPI_Add_error_code( int errorclass, int * errorcode )
{

        
        int ret = PMPI_Add_error_code( errorclass, errorcode );
        return ret;
}
int MPI_Add_error_string( int errorcode, char * string )
{

        
        int ret = PMPI_Add_error_string( errorcode, string );
        return ret;
}
int MPI_Address( void * location, MPI_Aint * address )
{

        
        int ret = PMPI_Address( location, address );
        return ret;
}
int MPI_Allgather( void * sendbuf, int sendcount, MPI_Datatype sendtype, void * recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Allgather( sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm );
        return ret;
}
int MPI_Allgatherv( void * sendbuf, int sendcount, MPI_Datatype sendtype, void * recvbuf, int * recvcounts, int * displs, MPI_Datatype recvtype, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Allgatherv( sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm );
        return ret;
}
int MPI_Alloc_mem( MPI_Aint size, MPI_Info info, void * baseptr )
{

        
        int ret = PMPI_Alloc_mem( size, info, baseptr );
        return ret;
}
int MPI_Allreduce( void * sendbuf, void * recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Allreduce( sendbuf, recvbuf, count, datatype, op, comm );
        return ret;
}
int MPI_Alltoall( void * sendbuf, int sendcount, MPI_Datatype sendtype, void * recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Alltoall( sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm );
        return ret;
}
int MPI_Alltoallv( void * sendbuf, int * sendcounts, int * sdispls, MPI_Datatype sendtype, void * recvbuf, int * recvcounts, int * rdispls, MPI_Datatype recvtype, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Alltoallv( sendbuf, sendcounts, sdispls, sendtype, recvbuf, recvcounts, rdispls, recvtype, comm );
        return ret;
}
int MPI_Alltoallw( void * sendbuf, int * sendcounts, int * sdispls, MPI_Datatype * sendtypes, void * recvbuf, int * recvcounts, int * rdispls, MPI_Datatype * recvtypes, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Alltoallw( sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm );
        return ret;
}
int MPI_Attr_delete( MPI_Comm comm, int keyval )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Attr_delete( comm, keyval );
        return ret;
}
int MPI_Attr_get( MPI_Comm comm, int keyval, void * attribute_val, int * flag )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Attr_get( comm, keyval, attribute_val, flag );
        return ret;
}
int MPI_Attr_put( MPI_Comm comm, int keyval, void * attribute_val )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Attr_put( comm, keyval, attribute_val );
        return ret;
}
int MPI_Barrier( MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Barrier( comm );
        return ret;
}
int MPI_Bcast( void * buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Bcast( buffer, count, datatype, root, comm );
        return ret;
}
int MPI_Bsend( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Bsend( buf, count, datatype, dest, tag, comm );
        return ret;
}
int MPI_Bsend_init( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Bsend_init( buf, count, datatype, dest, tag, comm, request );
        return ret;
}
int MPI_Buffer_attach( void * buffer, int size )
{

        
        int ret = PMPI_Buffer_attach( buffer, size );
        return ret;
}
int MPI_Buffer_detach( void * buffer, int * size )
{

        
        int ret = PMPI_Buffer_detach( buffer, size );
        return ret;
}
int MPI_Cancel( MPI_Request * request )
{

        
        int ret = PMPI_Cancel( request );
        return ret;
}
int MPI_Cart_coords( MPI_Comm comm, int rank, int maxdims, int * coords )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Cart_coords( comm, rank, maxdims, coords );
        return ret;
}
int MPI_Cart_create( MPI_Comm old_comm, int ndims, int * dims, int * periods, int reorder, MPI_Comm * comm_cart )
{
         MACRO_MPI_Comm (old_comm)
        
        int ret = PMPI_Cart_create( old_comm, ndims, dims, periods, reorder, comm_cart );
        return ret;
}
int MPI_Cart_get( MPI_Comm comm, int maxdims, int * dims, int * periods, int * coords )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Cart_get( comm, maxdims, dims, periods, coords );
        return ret;
}
int MPI_Cart_map( MPI_Comm comm, int ndims, int * dims, int * periods, int * newrank )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Cart_map( comm, ndims, dims, periods, newrank );
        return ret;
}
int MPI_Cart_rank( MPI_Comm comm, int * coords, int * rank )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Cart_rank( comm, coords, rank );
        return ret;
}
int MPI_Cart_shift( MPI_Comm comm, int direction, int disp, int * rank_source, int * rank_dest )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Cart_shift( comm, direction, disp, rank_source, rank_dest );
        return ret;
}
int MPI_Cart_sub( MPI_Comm comm, int * remain_dims, MPI_Comm * new_comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Cart_sub( comm, remain_dims, new_comm );
        return ret;
}
int MPI_Cartdim_get( MPI_Comm comm, int * ndims )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Cartdim_get( comm, ndims );
        return ret;
}
int MPI_Close_port( char * port_name )
{

        
        int ret = PMPI_Close_port( port_name );
        return ret;
}
int MPI_Comm_accept( char * port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm * newcomm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_accept( port_name, info, root, comm, newcomm );
        return ret;
}
int MPI_Comm_c2f( MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_c2f( comm );
        return ret;
}
int MPI_Comm_call_errhandler( MPI_Comm comm, int errorcode )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_call_errhandler( comm, errorcode );
        return ret;
}
int MPI_Comm_compare( MPI_Comm comm1, MPI_Comm comm2, int * result )
{
         MACRO_MPI_Comm (comm1)  MACRO_MPI_Comm (comm2)
        
        int ret = PMPI_Comm_compare( comm1, comm2, result );
        return ret;
}
int MPI_Comm_connect( char * port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm * newcomm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_connect( port_name, info, root, comm, newcomm );
        return ret;
}
int MPI_Comm_create_errhandler( MPI_Comm_errhandler_function * function, MPI_Errhandler * errhandler )
{

        
        int ret = PMPI_Comm_create_errhandler( function, errhandler );
        return ret;
}
int MPI_Comm_create_keyval( MPI_Comm_copy_attr_function * comm_copy_attr_fn, MPI_Comm_delete_attr_function * comm_delete_attr_fn, int * comm_keyval, void * extra_state )
{

        
        int ret = PMPI_Comm_create_keyval( comm_copy_attr_fn, comm_delete_attr_fn, comm_keyval, extra_state );
        return ret;
}
int MPI_Comm_create( MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_create( comm, group, newcomm );
        return ret;
}
int MPI_Comm_delete_attr( MPI_Comm comm, int comm_keyval )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_delete_attr( comm, comm_keyval );
        return ret;
}
int MPI_Comm_disconnect( MPI_Comm * comm )
{

        
        int ret = PMPI_Comm_disconnect( comm );
        return ret;
}
int MPI_Comm_dup( MPI_Comm comm, MPI_Comm * newcomm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_dup( comm, newcomm );
        return ret;
}
int MPI_Comm_free_keyval( int * comm_keyval )
{

        
        int ret = PMPI_Comm_free_keyval( comm_keyval );
        return ret;
}
int MPI_Comm_free( MPI_Comm * comm )
{

        
        int ret = PMPI_Comm_free( comm );
        return ret;
}
int MPI_Comm_get_attr( MPI_Comm comm, int comm_keyval, void * attribute_val, int * flag )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_get_attr( comm, comm_keyval, attribute_val, flag );
        return ret;
}
int MPI_Comm_get_errhandler( MPI_Comm comm, MPI_Errhandler * erhandler )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_get_errhandler( comm, erhandler );
        return ret;
}
int MPI_Comm_get_name( MPI_Comm comm, char * comm_name, int * resultlen )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_get_name( comm, comm_name, resultlen );
        return ret;
}
int MPI_Comm_get_parent( MPI_Comm * parent )
{

        
        int ret = PMPI_Comm_get_parent( parent );
        return ret;
}
int MPI_Comm_group( MPI_Comm comm, MPI_Group * group )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_group( comm, group );
        return ret;
}
int MPI_Comm_join( int fd, MPI_Comm * intercomm )
{

        
        int ret = PMPI_Comm_join( fd, intercomm );
        return ret;
}
int MPI_Comm_rank( MPI_Comm comm, int * rank )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_rank( comm, rank );
        return ret;
}
int MPI_Comm_remote_group( MPI_Comm comm, MPI_Group * group )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_remote_group( comm, group );
        return ret;
}
int MPI_Comm_remote_size( MPI_Comm comm, int * size )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_remote_size( comm, size );
        return ret;
}
int MPI_Comm_set_attr( MPI_Comm comm, int comm_keyval, void * attribute_val )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_set_attr( comm, comm_keyval, attribute_val );
        return ret;
}
int MPI_Comm_set_errhandler( MPI_Comm comm, MPI_Errhandler errhandler )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_set_errhandler( comm, errhandler );
        return ret;
}
int MPI_Comm_set_name( MPI_Comm comm, char * comm_name )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_set_name( comm, comm_name );
        return ret;
}
int MPI_Comm_size( MPI_Comm comm, int * size )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_size( comm, size );
        return ret;
}
int MPI_Comm_spawn( char * command, char ** argv, int maxprocs, MPI_Info info, int root, MPI_Comm comm, MPI_Comm * intercomm, int * array_of_errcodes )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_spawn( command, argv, maxprocs, info, root, comm, intercomm, array_of_errcodes );
        return ret;
}
int MPI_Comm_spawn_multiple( int count, char ** array_of_commands, char *** array_of_argv, int * array_of_maxprocs, MPI_Info * array_of_info, int root, MPI_Comm comm, MPI_Comm * intercomm, int * array_of_errcodes )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_spawn_multiple( count, array_of_commands, array_of_argv, array_of_maxprocs, array_of_info, root, comm, intercomm, array_of_errcodes );
        return ret;
}
int MPI_Comm_split( MPI_Comm comm, int color, int key, MPI_Comm * newcomm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_split( comm, color, key, newcomm );
        return ret;
}
int MPI_Comm_test_inter( MPI_Comm comm, int * flag )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Comm_test_inter( comm, flag );
        return ret;
}
int MPI_Dims_create( int nnodes, int ndims, int * dims )
{

        
        int ret = PMPI_Dims_create( nnodes, ndims, dims );
        return ret;
}
int MPI_Errhandler_c2f( MPI_Errhandler errhandler )
{

        
        int ret = PMPI_Errhandler_c2f( errhandler );
        return ret;
}
int MPI_Errhandler_create( MPI_Handler_function * function, MPI_Errhandler * errhandler )
{

        
        int ret = PMPI_Errhandler_create( function, errhandler );
        return ret;
}
int MPI_Errhandler_free( MPI_Errhandler * errhandler )
{

        
        int ret = PMPI_Errhandler_free( errhandler );
        return ret;
}
int MPI_Errhandler_get( MPI_Comm comm, MPI_Errhandler * errhandler )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Errhandler_get( comm, errhandler );
        return ret;
}
int MPI_Errhandler_set( MPI_Comm comm, MPI_Errhandler errhandler )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Errhandler_set( comm, errhandler );
        return ret;
}
int MPI_Error_class( int errorcode, int * errorclass )
{

        
        int ret = PMPI_Error_class( errorcode, errorclass );
        return ret;
}
int MPI_Error_string( int errorcode, char * string, int * resultlen )
{

        
        int ret = PMPI_Error_string( errorcode, string, resultlen );
        return ret;
}
int MPI_Exscan( void * sendbuf, void * recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Exscan( sendbuf, recvbuf, count, datatype, op, comm );
        return ret;
}
int MPI_File_c2f( MPI_File file )
{

        
        int ret = PMPI_File_c2f( file );
        return ret;
}
int MPI_File_call_errhandler( MPI_File fh, int errorcode )
{

        
        int ret = PMPI_File_call_errhandler( fh, errorcode );
        return ret;
}
int MPI_File_create_errhandler( MPI_File_errhandler_function * function, MPI_Errhandler * errhandler )
{

        
        int ret = PMPI_File_create_errhandler( function, errhandler );
        return ret;
}
int MPI_File_set_errhandler( MPI_File file, MPI_Errhandler errhandler )
{

        
        int ret = PMPI_File_set_errhandler( file, errhandler );
        return ret;
}
int MPI_File_get_errhandler( MPI_File file, MPI_Errhandler * errhandler )
{

        
        int ret = PMPI_File_get_errhandler( file, errhandler );
        return ret;
}
int MPI_File_open( MPI_Comm comm, char * filename, int amode, MPI_Info info, MPI_File * fh )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_File_open( comm, filename, amode, info, fh );
        return ret;
}
int MPI_File_close( MPI_File * fh )
{

        
        int ret = PMPI_File_close( fh );
        return ret;
}
int MPI_File_delete( char * filename, MPI_Info info )
{

        
        int ret = PMPI_File_delete( filename, info );
        return ret;
}
int MPI_File_set_size( MPI_File fh, MPI_Offset size )
{

        
        int ret = PMPI_File_set_size( fh, size );
        return ret;
}
int MPI_File_preallocate( MPI_File fh, MPI_Offset size )
{

        
        int ret = PMPI_File_preallocate( fh, size );
        return ret;
}
int MPI_File_get_size( MPI_File fh, MPI_Offset * size )
{

        
        int ret = PMPI_File_get_size( fh, size );
        return ret;
}
int MPI_File_get_group( MPI_File fh, MPI_Group * group )
{

        
        int ret = PMPI_File_get_group( fh, group );
        return ret;
}
int MPI_File_get_amode( MPI_File fh, int * amode )
{

        
        int ret = PMPI_File_get_amode( fh, amode );
        return ret;
}
int MPI_File_set_info( MPI_File fh, MPI_Info info )
{

        
        int ret = PMPI_File_set_info( fh, info );
        return ret;
}
int MPI_File_get_info( MPI_File fh, MPI_Info * info_used )
{

        
        int ret = PMPI_File_get_info( fh, info_used );
        return ret;
}
int MPI_File_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype, MPI_Datatype filetype, char * datarep, MPI_Info info )
{

        
        int ret = PMPI_File_set_view( fh, disp, etype, filetype, datarep, info );
        return ret;
}
int MPI_File_get_view( MPI_File fh, MPI_Offset * disp, MPI_Datatype * etype, MPI_Datatype * filetype, char * datarep )
{

        
        int ret = PMPI_File_get_view( fh, disp, etype, filetype, datarep );
        return ret;
}
int MPI_File_read_at( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
{

        
        int ret = PMPI_File_read_at( fh, offset, buf, count, datatype, status );
        return ret;
}
int MPI_File_read_at_all( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
{

        
        int ret = PMPI_File_read_at_all( fh, offset, buf, count, datatype, status );
        return ret;
}
int MPI_File_write_at( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
{

        
        int ret = PMPI_File_write_at( fh, offset, buf, count, datatype, status );
        return ret;
}
int MPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
{

        
        int ret = PMPI_File_write_at_all( fh, offset, buf, count, datatype, status );
        return ret;
}
int MPI_File_iread_at( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, MPI_Request * request )
{

        
        int ret = PMPI_File_iread_at( fh, offset, buf, count, datatype, request );
        return ret;
}
int MPI_File_iwrite_at( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, MPI_Request * request )
{

        
        int ret = PMPI_File_iwrite_at( fh, offset, buf, count, datatype, request );
        return ret;
}
int MPI_File_read( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
{

        
        int ret = PMPI_File_read( fh, buf, count, datatype, status );
        return ret;
}
int MPI_File_read_all( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
{

        
        int ret = PMPI_File_read_all( fh, buf, count, datatype, status );
        return ret;
}
int MPI_File_write( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
{

        
        int ret = PMPI_File_write( fh, buf, count, datatype, status );
        return ret;
}
int MPI_File_write_all( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
{

        
        int ret = PMPI_File_write_all( fh, buf, count, datatype, status );
        return ret;
}
int MPI_File_iread( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Request * request )
{

        
        int ret = PMPI_File_iread( fh, buf, count, datatype, request );
        return ret;
}
int MPI_File_iwrite( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Request * request )
{

        
        int ret = PMPI_File_iwrite( fh, buf, count, datatype, request );
        return ret;
}
int MPI_File_seek( MPI_File fh, MPI_Offset offset, int whence )
{

        
        int ret = PMPI_File_seek( fh, offset, whence );
        return ret;
}
int MPI_File_get_position( MPI_File fh, MPI_Offset * offset )
{

        
        int ret = PMPI_File_get_position( fh, offset );
        return ret;
}
int MPI_File_get_byte_offset( MPI_File fh, MPI_Offset offset, MPI_Offset * disp )
{

        
        int ret = PMPI_File_get_byte_offset( fh, offset, disp );
        return ret;
}
int MPI_File_read_shared( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
{

        
        int ret = PMPI_File_read_shared( fh, buf, count, datatype, status );
        return ret;
}
int MPI_File_write_shared( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
{

        
        int ret = PMPI_File_write_shared( fh, buf, count, datatype, status );
        return ret;
}
int MPI_File_iread_shared( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Request * request )
{

        
        int ret = PMPI_File_iread_shared( fh, buf, count, datatype, request );
        return ret;
}
int MPI_File_iwrite_shared( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Request * request )
{

        
        int ret = PMPI_File_iwrite_shared( fh, buf, count, datatype, request );
        return ret;
}
int MPI_File_read_ordered( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
{

        
        int ret = PMPI_File_read_ordered( fh, buf, count, datatype, status );
        return ret;
}
int MPI_File_write_ordered( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
{

        
        int ret = PMPI_File_write_ordered( fh, buf, count, datatype, status );
        return ret;
}
int MPI_File_seek_shared( MPI_File fh, MPI_Offset offset, int whence )
{

        
        int ret = PMPI_File_seek_shared( fh, offset, whence );
        return ret;
}
int MPI_File_get_position_shared( MPI_File fh, MPI_Offset * offset )
{

        
        int ret = PMPI_File_get_position_shared( fh, offset );
        return ret;
}
int MPI_File_read_at_all_begin( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype )
{

        
        int ret = PMPI_File_read_at_all_begin( fh, offset, buf, count, datatype );
        return ret;
}
int MPI_File_read_at_all_end( MPI_File fh, void * buf, MPI_Status * status )
{

        
        int ret = PMPI_File_read_at_all_end( fh, buf, status );
        return ret;
}
int MPI_File_write_at_all_begin( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype )
{

        
        int ret = PMPI_File_write_at_all_begin( fh, offset, buf, count, datatype );
        return ret;
}
int MPI_File_write_at_all_end( MPI_File fh, void * buf, MPI_Status * status )
{

        
        int ret = PMPI_File_write_at_all_end( fh, buf, status );
        return ret;
}
int MPI_File_read_all_begin( MPI_File fh, void * buf, int count, MPI_Datatype datatype )
{

        
        int ret = PMPI_File_read_all_begin( fh, buf, count, datatype );
        return ret;
}
int MPI_File_read_all_end( MPI_File fh, void * buf, MPI_Status * status )
{

        
        int ret = PMPI_File_read_all_end( fh, buf, status );
        return ret;
}
int MPI_File_write_all_begin( MPI_File fh, void * buf, int count, MPI_Datatype datatype )
{

        
        int ret = PMPI_File_write_all_begin( fh, buf, count, datatype );
        return ret;
}
int MPI_File_write_all_end( MPI_File fh, void * buf, MPI_Status * status )
{

        
        int ret = PMPI_File_write_all_end( fh, buf, status );
        return ret;
}
int MPI_File_read_ordered_begin( MPI_File fh, void * buf, int count, MPI_Datatype datatype )
{

        
        int ret = PMPI_File_read_ordered_begin( fh, buf, count, datatype );
        return ret;
}
int MPI_File_read_ordered_end( MPI_File fh, void * buf, MPI_Status * status )
{

        
        int ret = PMPI_File_read_ordered_end( fh, buf, status );
        return ret;
}
int MPI_File_write_ordered_begin( MPI_File fh, void * buf, int count, MPI_Datatype datatype )
{

        
        int ret = PMPI_File_write_ordered_begin( fh, buf, count, datatype );
        return ret;
}
int MPI_File_write_ordered_end( MPI_File fh, void * buf, MPI_Status * status )
{

        
        int ret = PMPI_File_write_ordered_end( fh, buf, status );
        return ret;
}
int MPI_File_get_type_extent( MPI_File fh, MPI_Datatype datatype, MPI_Aint * extent )
{

        
        int ret = PMPI_File_get_type_extent( fh, datatype, extent );
        return ret;
}
int MPI_File_set_atomicity( MPI_File fh, int flag )
{

        
        int ret = PMPI_File_set_atomicity( fh, flag );
        return ret;
}
int MPI_File_get_atomicity( MPI_File fh, int * flag )
{

        
        int ret = PMPI_File_get_atomicity( fh, flag );
        return ret;
}
int MPI_File_sync( MPI_File fh )
{

        
        int ret = PMPI_File_sync( fh );
        return ret;
}
int MPI_Finalized( int * flag )
{

        
        int ret = PMPI_Finalized( flag );
        return ret;
}
int MPI_Free_mem( void * base )
{

        
        int ret = PMPI_Free_mem( base );
        return ret;
}
int MPI_Gather( void * sendbuf, int sendcount, MPI_Datatype sendtype, void * recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Gather( sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm );
        return ret;
}
int MPI_Gatherv( void * sendbuf, int sendcount, MPI_Datatype sendtype, void * recvbuf, int * recvcounts, int * displs, MPI_Datatype recvtype, int root, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Gatherv( sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, root, comm );
        return ret;
}
int MPI_Get_address( void * location, MPI_Aint * address )
{

        
        int ret = PMPI_Get_address( location, address );
        return ret;
}
int MPI_Get_count( MPI_Status * status, MPI_Datatype datatype, int * count )
{

        
        int ret = PMPI_Get_count( status, datatype, count );
        return ret;
}
int MPI_Get_elements( MPI_Status * status, MPI_Datatype datatype, int * count )
{

        
        int ret = PMPI_Get_elements( status, datatype, count );
        return ret;
}
int MPI_Get( void * origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win )
{

        
        int ret = PMPI_Get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, win );
        return ret;
}
int MPI_Get_processor_name( char * name, int * resultlen )
{

        
        int ret = PMPI_Get_processor_name( name, resultlen );
        return ret;
}
int MPI_Get_version( int * version, int * subversion )
{

        
        int ret = PMPI_Get_version( version, subversion );
        return ret;
}
int MPI_Graph_create( MPI_Comm comm_old, int nnodes, int * index, int * edges, int reorder, MPI_Comm * comm_graph )
{
         MACRO_MPI_Comm (comm_old)
        
        int ret = PMPI_Graph_create( comm_old, nnodes, index, edges, reorder, comm_graph );
        return ret;
}
int MPI_Graph_get( MPI_Comm comm, int maxindex, int maxedges, int * index, int * edges )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Graph_get( comm, maxindex, maxedges, index, edges );
        return ret;
}
int MPI_Graph_map( MPI_Comm comm, int nnodes, int * index, int * edges, int * newrank )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Graph_map( comm, nnodes, index, edges, newrank );
        return ret;
}
int MPI_Graph_neighbors_count( MPI_Comm comm, int rank, int * nneighbors )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Graph_neighbors_count( comm, rank, nneighbors );
        return ret;
}
int MPI_Graph_neighbors( MPI_Comm comm, int rank, int maxneighbors, int * neighbors )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Graph_neighbors( comm, rank, maxneighbors, neighbors );
        return ret;
}
int MPI_Graphdims_get( MPI_Comm comm, int * nnodes, int * nedges )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Graphdims_get( comm, nnodes, nedges );
        return ret;
}
int MPI_Grequest_complete( MPI_Request request )
{

        
        int ret = PMPI_Grequest_complete( request );
        return ret;
}
int MPI_Grequest_start( MPI_Grequest_query_function * query_fn, MPI_Grequest_free_function * free_fn, MPI_Grequest_cancel_function * cancel_fn, void * extra_state, MPI_Request * request )
{

        
        int ret = PMPI_Grequest_start( query_fn, free_fn, cancel_fn, extra_state, request );
        return ret;
}
int MPI_Group_c2f( MPI_Group group )
{

        
        int ret = PMPI_Group_c2f( group );
        return ret;
}
int MPI_Group_compare( MPI_Group group1, MPI_Group group2, int * result )
{

        
        int ret = PMPI_Group_compare( group1, group2, result );
        return ret;
}
int MPI_Group_difference( MPI_Group group1, MPI_Group group2, MPI_Group * newgroup )
{

        
        int ret = PMPI_Group_difference( group1, group2, newgroup );
        return ret;
}
int MPI_Group_excl( MPI_Group group, int n, int * ranks, MPI_Group * newgroup )
{

        
        int ret = PMPI_Group_excl( group, n, ranks, newgroup );
        return ret;
}
int MPI_Group_free( MPI_Group * group )
{

        
        int ret = PMPI_Group_free( group );
        return ret;
}
int MPI_Group_incl( MPI_Group group, int n, int * ranks, MPI_Group * newgroup )
{

        
        int ret = PMPI_Group_incl( group, n, ranks, newgroup );
        return ret;
}
int MPI_Group_intersection( MPI_Group group1, MPI_Group group2, MPI_Group * newgroup )
{

        
        int ret = PMPI_Group_intersection( group1, group2, newgroup );
        return ret;
}
int MPI_Group_range_excl( MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup )
{

        
        int ret = PMPI_Group_range_excl( group, n, ranges, newgroup );
        return ret;
}
int MPI_Group_range_incl( MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup )
{

        
        int ret = PMPI_Group_range_incl( group, n, ranges, newgroup );
        return ret;
}
int MPI_Group_rank( MPI_Group group, int * rank )
{

        
        int ret = PMPI_Group_rank( group, rank );
        return ret;
}
int MPI_Group_size( MPI_Group group, int * size )
{

        
        int ret = PMPI_Group_size( group, size );
        return ret;
}
int MPI_Group_translate_ranks( MPI_Group group1, int n, int * ranks1, MPI_Group group2, int * ranks2 )
{

        
        int ret = PMPI_Group_translate_ranks( group1, n, ranks1, group2, ranks2 );
        return ret;
}
int MPI_Group_union( MPI_Group group1, MPI_Group group2, MPI_Group * newgroup )
{

        
        int ret = PMPI_Group_union( group1, group2, newgroup );
        return ret;
}
int MPI_Ibsend( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Ibsend( buf, count, datatype, dest, tag, comm, request );
        return ret;
}
int MPI_Info_c2f( MPI_Info info )
{

        
        int ret = PMPI_Info_c2f( info );
        return ret;
}
int MPI_Info_create( MPI_Info * info )
{

        
        int ret = PMPI_Info_create( info );
        return ret;
}
int MPI_Info_delete( MPI_Info info, char * key )
{

        
        int ret = PMPI_Info_delete( info, key );
        return ret;
}
int MPI_Info_dup( MPI_Info info, MPI_Info * newinfo )
{

        
        int ret = PMPI_Info_dup( info, newinfo );
        return ret;
}
int MPI_Info_free( MPI_Info * info )
{

        
        int ret = PMPI_Info_free( info );
        return ret;
}
int MPI_Info_get( MPI_Info info, char * key, int valuelen, char * value, int * flag )
{

        
        int ret = PMPI_Info_get( info, key, valuelen, value, flag );
        return ret;
}
int MPI_Info_get_nkeys( MPI_Info info, int * nkeys )
{

        
        int ret = PMPI_Info_get_nkeys( info, nkeys );
        return ret;
}
int MPI_Info_get_nthkey( MPI_Info info, int n, char * key )
{

        
        int ret = PMPI_Info_get_nthkey( info, n, key );
        return ret;
}
int MPI_Info_get_valuelen( MPI_Info info, char * key, int * valuelen, int * flag )
{

        
        int ret = PMPI_Info_get_valuelen( info, key, valuelen, flag );
        return ret;
}
int MPI_Info_set( MPI_Info info, char * key, char * value )
{

        
        int ret = PMPI_Info_set( info, key, value );
        return ret;
}
int MPI_Initialized( int * flag )
{

        
        int ret = PMPI_Initialized( flag );
        return ret;
}
int MPI_Intercomm_create( MPI_Comm local_comm, int local_leader, MPI_Comm bridge_comm, int remote_leader, int tag, MPI_Comm * newintercomm )
{
         MACRO_MPI_Comm (local_comm)     MACRO_MPI_Comm (bridge_comm)
        
        int ret = PMPI_Intercomm_create( local_comm, local_leader, bridge_comm, remote_leader, tag, newintercomm );
        return ret;
}
int MPI_Intercomm_merge( MPI_Comm intercomm, int high, MPI_Comm * newintercomm )
{
         MACRO_MPI_Comm (intercomm)
        
        int ret = PMPI_Intercomm_merge( intercomm, high, newintercomm );
        return ret;
}
int MPI_Iprobe( int source, int tag, MPI_Comm comm, int * flag, MPI_Status * status )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Iprobe( source, tag, comm, flag, status );
        return ret;
}
int MPI_Irecv( void * buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request * request )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Irecv( buf, count, datatype, source, tag, comm, request );
        return ret;
}
int MPI_Irsend( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Irsend( buf, count, datatype, dest, tag, comm, request );
        return ret;
}
int MPI_Isend( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Isend( buf, count, datatype, dest, tag, comm, request );
        return ret;
}
int MPI_Issend( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Issend( buf, count, datatype, dest, tag, comm, request );
        return ret;
}
int MPI_Is_thread_main( int * flag )
{

        
        int ret = PMPI_Is_thread_main( flag );
        return ret;
}
int MPI_Keyval_create( MPI_Copy_function * copy_fn, MPI_Delete_function * delete_fn, int * keyval, void * extra_state )
{

        
        int ret = PMPI_Keyval_create( copy_fn, delete_fn, keyval, extra_state );
        return ret;
}
int MPI_Keyval_free( int * keyval )
{

        
        int ret = PMPI_Keyval_free( keyval );
        return ret;
}
int MPI_Lookup_name( char * service_name, MPI_Info info, char * port_name )
{

        
        int ret = PMPI_Lookup_name( service_name, info, port_name );
        return ret;
}
int MPI_Op_c2f( MPI_Op op )
{

        
        int ret = PMPI_Op_c2f( op );
        return ret;
}
int MPI_Op_commutative( MPI_Op op, int * commute )
{

        
        int ret = PMPI_Op_commutative( op, commute );
        return ret;
}
int MPI_Op_create( MPI_User_function * function, int commute, MPI_Op * op )
{

        
        int ret = PMPI_Op_create( function, commute, op );
        return ret;
}
int MPI_Open_port( MPI_Info info, char * port_name )
{

        
        int ret = PMPI_Open_port( info, port_name );
        return ret;
}
int MPI_Op_free( MPI_Op * op )
{

        
        int ret = PMPI_Op_free( op );
        return ret;
}
int MPI_Pack_external( char * datarep, void * inbuf, int incount, MPI_Datatype datatype, void * outbuf, MPI_Aint outsize, MPI_Aint * position )
{

        
        int ret = PMPI_Pack_external( datarep, inbuf, incount, datatype, outbuf, outsize, position );
        return ret;
}
int MPI_Pack_external_size( char * datarep, int incount, MPI_Datatype datatype, MPI_Aint * size )
{

        
        int ret = PMPI_Pack_external_size( datarep, incount, datatype, size );
        return ret;
}
int MPI_Pack( void * inbuf, int incount, MPI_Datatype datatype, void * outbuf, int outsize, int * position, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Pack( inbuf, incount, datatype, outbuf, outsize, position, comm );
        return ret;
}
int MPI_Pack_size( int incount, MPI_Datatype datatype, MPI_Comm comm, int * size )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Pack_size( incount, datatype, comm, size );
        return ret;
}
int MPI_Probe( int source, int tag, MPI_Comm comm, MPI_Status * status )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Probe( source, tag, comm, status );
        return ret;
}
int MPI_Publish_name( char * service_name, MPI_Info info, char * port_name )
{

        
        int ret = PMPI_Publish_name( service_name, info, port_name );
        return ret;
}
int MPI_Put( void * origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win )
{

        
        int ret = PMPI_Put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, win );
        return ret;
}
int MPI_Query_thread( int * provided )
{

        
        int ret = PMPI_Query_thread( provided );
        return ret;
}
int MPI_Recv_init( void * buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request * request )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Recv_init( buf, count, datatype, source, tag, comm, request );
        return ret;
}
int MPI_Recv( void * buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Status * status )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Recv( buf, count, datatype, source, tag, comm, status );
        return ret;
}
int MPI_Reduce( void * sendbuf, void * recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Reduce( sendbuf, recvbuf, count, datatype, op, root, comm );
        return ret;
}
int MPI_Reduce_local( void * inbuf, void * inoutbuf, int count, MPI_Datatype datatype, MPI_Op op )
{

        
        int ret = PMPI_Reduce_local( inbuf, inoutbuf, count, datatype, op );
        return ret;
}
int MPI_Reduce_scatter( void * sendbuf, void * recvbuf, int * recvcounts, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Reduce_scatter( sendbuf, recvbuf, recvcounts, datatype, op, comm );
        return ret;
}
int MPI_Register_datarep( char * datarep, MPI_Datarep_conversion_function * read_conversion_fn, MPI_Datarep_conversion_function * write_conversion_fn, MPI_Datarep_extent_function * dtype_file_extent_fn, void * extra_state )
{

        
        int ret = PMPI_Register_datarep( datarep, read_conversion_fn, write_conversion_fn, dtype_file_extent_fn, extra_state );
        return ret;
}
int MPI_Request_c2f( MPI_Request request )
{

        
        int ret = PMPI_Request_c2f( request );
        return ret;
}
int MPI_Request_free( MPI_Request * request )
{

        
        int ret = PMPI_Request_free( request );
        return ret;
}
int MPI_Request_get_status( MPI_Request request, int * flag, MPI_Status * status )
{

        
        int ret = PMPI_Request_get_status( request, flag, status );
        return ret;
}
int MPI_Rsend( void * ibuf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Rsend( ibuf, count, datatype, dest, tag, comm );
        return ret;
}
int MPI_Rsend_init( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Rsend_init( buf, count, datatype, dest, tag, comm, request );
        return ret;
}
int MPI_Scan( void * sendbuf, void * recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Scan( sendbuf, recvbuf, count, datatype, op, comm );
        return ret;
}
int MPI_Scatter( void * sendbuf, int sendcount, MPI_Datatype sendtype, void * recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Scatter( sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm );
        return ret;
}
int MPI_Scatterv( void * sendbuf, int * sendcounts, int * displs, MPI_Datatype sendtype, void * recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Scatterv( sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm );
        return ret;
}
int MPI_Send_init( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Send_init( buf, count, datatype, dest, tag, comm, request );
        return ret;
}
int MPI_Send( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Send( buf, count, datatype, dest, tag, comm );
        return ret;
}
int MPI_Sendrecv( void * sendbuf, int sendcount, MPI_Datatype sendtype, int dest, int sendtag, void * recvbuf, int recvcount, MPI_Datatype recvtype, int source, int recvtag, MPI_Comm comm, MPI_Status * status )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Sendrecv( sendbuf, sendcount, sendtype, dest, sendtag, recvbuf, recvcount, recvtype, source, recvtag, comm, status );
        return ret;
}
int MPI_Sendrecv_replace( void * buf, int count, MPI_Datatype datatype, int dest, int sendtag, int source, int recvtag, MPI_Comm comm, MPI_Status * status )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Sendrecv_replace( buf, count, datatype, dest, sendtag, source, recvtag, comm, status );
        return ret;
}
int MPI_Ssend_init( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Ssend_init( buf, count, datatype, dest, tag, comm, request );
        return ret;
}
int MPI_Ssend( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Ssend( buf, count, datatype, dest, tag, comm );
        return ret;
}
int MPI_Start( MPI_Request * request )
{

        
        int ret = PMPI_Start( request );
        return ret;
}
int MPI_Startall( int count, MPI_Request * array_of_requests )
{

        
        int ret = PMPI_Startall( count, array_of_requests );
        return ret;
}
int MPI_Status_c2f( MPI_Status * c_status, int * f_status )
{

        
        int ret = PMPI_Status_c2f( c_status, f_status );
        return ret;
}
int MPI_Status_f2c( int * f_status, MPI_Status * c_status )
{

        
        int ret = PMPI_Status_f2c( f_status, c_status );
        return ret;
}
int MPI_Status_set_cancelled( MPI_Status * status, int flag )
{

        
        int ret = PMPI_Status_set_cancelled( status, flag );
        return ret;
}
int MPI_Status_set_elements( MPI_Status * status, MPI_Datatype datatype, int count )
{

        
        int ret = PMPI_Status_set_elements( status, datatype, count );
        return ret;
}
int MPI_Testall( int count, MPI_Request array_of_requests[], int * flag, MPI_Status array_of_statuses[] )
{

        
        int ret = PMPI_Testall( count, array_of_requests, flag, array_of_statuses );
        return ret;
}
int MPI_Testany( int count, MPI_Request array_of_requests[], int * index, int * flag, MPI_Status * status )
{

        
        int ret = PMPI_Testany( count, array_of_requests, index, flag, status );
        return ret;
}
int MPI_Test( MPI_Request * request, int * flag, MPI_Status * status )
{

        
        int ret = PMPI_Test( request, flag, status );
        return ret;
}
int MPI_Test_cancelled( MPI_Status * status, int * flag )
{

        
        int ret = PMPI_Test_cancelled( status, flag );
        return ret;
}
int MPI_Testsome( int incount, MPI_Request array_of_requests[], int * outcount, int array_of_indices[], MPI_Status array_of_statuses[] )
{

        
        int ret = PMPI_Testsome( incount, array_of_requests, outcount, array_of_indices, array_of_statuses );
        return ret;
}
int MPI_Topo_test( MPI_Comm comm, int * status )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Topo_test( comm, status );
        return ret;
}
int MPI_Type_c2f( MPI_Datatype datatype )
{

        
        int ret = PMPI_Type_c2f( datatype );
        return ret;
}
int MPI_Type_commit( MPI_Datatype * type )
{

        
        int ret = PMPI_Type_commit( type );
        return ret;
}
int MPI_Type_contiguous( int count, MPI_Datatype oldtype, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_contiguous( count, oldtype, newtype );
        return ret;
}
int MPI_Type_create_darray( int size, int rank, int ndims, int gsize_array[], int distrib_array[], int darg_array[], int psize_array[], int order, MPI_Datatype oldtype, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_create_darray( size, rank, ndims, gsize_array, distrib_array, darg_array, psize_array, order, oldtype, newtype );
        return ret;
}
int MPI_Type_create_f90_complex( int p, int r, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_create_f90_complex( p, r, newtype );
        return ret;
}
int MPI_Type_create_f90_integer( int r, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_create_f90_integer( r, newtype );
        return ret;
}
int MPI_Type_create_f90_real( int p, int r, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_create_f90_real( p, r, newtype );
        return ret;
}
int MPI_Type_create_hindexed( int count, int array_of_blocklengths[], MPI_Aint array_of_displacements[], MPI_Datatype oldtype, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_create_hindexed( count, array_of_blocklengths, array_of_displacements, oldtype, newtype );
        return ret;
}
int MPI_Type_create_hvector( int count, int blocklength, MPI_Aint stride, MPI_Datatype oldtype, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_create_hvector( count, blocklength, stride, oldtype, newtype );
        return ret;
}
int MPI_Type_create_keyval( MPI_Type_copy_attr_function * type_copy_attr_fn, MPI_Type_delete_attr_function * type_delete_attr_fn, int * type_keyval, void * extra_state )
{

        
        int ret = PMPI_Type_create_keyval( type_copy_attr_fn, type_delete_attr_fn, type_keyval, extra_state );
        return ret;
}
int MPI_Type_create_indexed_block( int count, int blocklength, int array_of_displacements[], MPI_Datatype oldtype, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_create_indexed_block( count, blocklength, array_of_displacements, oldtype, newtype );
        return ret;
}
int MPI_Type_create_struct( int count, int array_of_block_lengths[], MPI_Aint array_of_displacements[], MPI_Datatype array_of_types[], MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_create_struct( count, array_of_block_lengths, array_of_displacements, array_of_types, newtype );
        return ret;
}
int MPI_Type_create_subarray( int ndims, int size_array[], int subsize_array[], int start_array[], int order, MPI_Datatype oldtype, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_create_subarray( ndims, size_array, subsize_array, start_array, order, oldtype, newtype );
        return ret;
}
int MPI_Type_create_resized( MPI_Datatype oldtype, MPI_Aint lb, MPI_Aint extent, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_create_resized( oldtype, lb, extent, newtype );
        return ret;
}
int MPI_Type_delete_attr( MPI_Datatype type, int type_keyval )
{

        
        int ret = PMPI_Type_delete_attr( type, type_keyval );
        return ret;
}
int MPI_Type_dup( MPI_Datatype type, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_dup( type, newtype );
        return ret;
}
int MPI_Type_extent( MPI_Datatype type, MPI_Aint * extent )
{

        
        int ret = PMPI_Type_extent( type, extent );
        return ret;
}
int MPI_Type_free( MPI_Datatype * type )
{

        
        int ret = PMPI_Type_free( type );
        return ret;
}
int MPI_Type_free_keyval( int * type_keyval )
{

        
        int ret = PMPI_Type_free_keyval( type_keyval );
        return ret;
}
int MPI_Type_get_attr( MPI_Datatype type, int type_keyval, void * attribute_val, int * flag )
{

        
        int ret = PMPI_Type_get_attr( type, type_keyval, attribute_val, flag );
        return ret;
}
int MPI_Type_get_contents( MPI_Datatype mtype, int max_integers, int max_addresses, int max_datatypes, int array_of_integers[], MPI_Aint array_of_addresses[], MPI_Datatype array_of_datatypes[] )
{

        
        int ret = PMPI_Type_get_contents( mtype, max_integers, max_addresses, max_datatypes, array_of_integers, array_of_addresses, array_of_datatypes );
        return ret;
}
int MPI_Type_get_envelope( MPI_Datatype type, int * num_integers, int * num_addresses, int * num_datatypes, int * combiner )
{

        
        int ret = PMPI_Type_get_envelope( type, num_integers, num_addresses, num_datatypes, combiner );
        return ret;
}
int MPI_Type_get_extent( MPI_Datatype type, MPI_Aint * lb, MPI_Aint * extent )
{

        
        int ret = PMPI_Type_get_extent( type, lb, extent );
        return ret;
}
int MPI_Type_get_name( MPI_Datatype type, char * type_name, int * resultlen )
{

        
        int ret = PMPI_Type_get_name( type, type_name, resultlen );
        return ret;
}
int MPI_Type_get_true_extent( MPI_Datatype datatype, MPI_Aint * true_lb, MPI_Aint * true_extent )
{

        
        int ret = PMPI_Type_get_true_extent( datatype, true_lb, true_extent );
        return ret;
}
int MPI_Type_hindexed( int count, int array_of_blocklengths[], MPI_Aint array_of_displacements[], MPI_Datatype oldtype, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_hindexed( count, array_of_blocklengths, array_of_displacements, oldtype, newtype );
        return ret;
}
int MPI_Type_hvector( int count, int blocklength, MPI_Aint stride, MPI_Datatype oldtype, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_hvector( count, blocklength, stride, oldtype, newtype );
        return ret;
}
int MPI_Type_indexed( int count, int array_of_blocklengths[], int array_of_displacements[], MPI_Datatype oldtype, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_indexed( count, array_of_blocklengths, array_of_displacements, oldtype, newtype );
        return ret;
}
int MPI_Type_lb( MPI_Datatype type, MPI_Aint * lb )
{

        
        int ret = PMPI_Type_lb( type, lb );
        return ret;
}
int MPI_Type_match_size( int typeclass, int size, MPI_Datatype * type )
{

        
        int ret = PMPI_Type_match_size( typeclass, size, type );
        return ret;
}
int MPI_Type_set_attr( MPI_Datatype type, int type_keyval, void * attr_val )
{

        
        int ret = PMPI_Type_set_attr( type, type_keyval, attr_val );
        return ret;
}
int MPI_Type_set_name( MPI_Datatype type, char * type_name )
{

        
        int ret = PMPI_Type_set_name( type, type_name );
        return ret;
}
int MPI_Type_size( MPI_Datatype type, int * size )
{

        
        int ret = PMPI_Type_size( type, size );
        return ret;
}
int MPI_Type_struct( int count, int array_of_blocklengths[], MPI_Aint array_of_displacements[], MPI_Datatype array_of_types[], MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_struct( count, array_of_blocklengths, array_of_displacements, array_of_types, newtype );
        return ret;
}
int MPI_Type_ub( MPI_Datatype mtype, MPI_Aint * ub )
{

        
        int ret = PMPI_Type_ub( mtype, ub );
        return ret;
}
int MPI_Type_vector( int count, int blocklength, int stride, MPI_Datatype oldtype, MPI_Datatype * newtype )
{

        
        int ret = PMPI_Type_vector( count, blocklength, stride, oldtype, newtype );
        return ret;
}
int MPI_Unpack( void * inbuf, int insize, int * position, void * outbuf, int outcount, MPI_Datatype datatype, MPI_Comm comm )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Unpack( inbuf, insize, position, outbuf, outcount, datatype, comm );
        return ret;
}
int MPI_Unpublish_name( char * service_name, MPI_Info info, char * port_name )
{

        
        int ret = PMPI_Unpublish_name( service_name, info, port_name );
        return ret;
}
int MPI_Unpack_external( char * datarep, void * inbuf, MPI_Aint insize, MPI_Aint * position, void * outbuf, int outcount, MPI_Datatype datatype )
{

        
        int ret = PMPI_Unpack_external( datarep, inbuf, insize, position, outbuf, outcount, datatype );
        return ret;
}
int MPI_Waitall( int count, MPI_Request * array_of_requests, MPI_Status * array_of_statuses )
{

        
        int ret = PMPI_Waitall( count, array_of_requests, array_of_statuses );
        return ret;
}
int MPI_Waitany( int count, MPI_Request * array_of_requests, int * index, MPI_Status * status )
{

        
        int ret = PMPI_Waitany( count, array_of_requests, index, status );
        return ret;
}
int MPI_Wait( MPI_Request * request, MPI_Status * status )
{

        
        int ret = PMPI_Wait( request, status );
        return ret;
}
int MPI_Waitsome( int incount, MPI_Request * array_of_requests, int * outcount, int * array_of_indices, MPI_Status * array_of_statuses )
{

        
        int ret = PMPI_Waitsome( incount, array_of_requests, outcount, array_of_indices, array_of_statuses );
        return ret;
}
int MPI_Win_c2f( MPI_Win win )
{

        
        int ret = PMPI_Win_c2f( win );
        return ret;
}
int MPI_Win_call_errhandler( MPI_Win win, int errorcode )
{

        
        int ret = PMPI_Win_call_errhandler( win, errorcode );
        return ret;
}
int MPI_Win_complete( MPI_Win win )
{

        
        int ret = PMPI_Win_complete( win );
        return ret;
}
int MPI_Win_create( void * base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win * win )
{
         MACRO_MPI_Comm (comm)
        
        int ret = PMPI_Win_create( base, size, disp_unit, info, comm, win );
        return ret;
}
int MPI_Win_create_errhandler( MPI_Win_errhandler_function * function, MPI_Errhandler * errhandler )
{

        
        int ret = PMPI_Win_create_errhandler( function, errhandler );
        return ret;
}
int MPI_Win_create_keyval( MPI_Win_copy_attr_function * win_copy_attr_fn, MPI_Win_delete_attr_function * win_delete_attr_fn, int * win_keyval, void * extra_state )
{

        
        int ret = PMPI_Win_create_keyval( win_copy_attr_fn, win_delete_attr_fn, win_keyval, extra_state );
        return ret;
}
int MPI_Win_delete_attr( MPI_Win win, int win_keyval )
{

        
        int ret = PMPI_Win_delete_attr( win, win_keyval );
        return ret;
}
int MPI_Win_fence( int assert, MPI_Win win )
{

        
        int ret = PMPI_Win_fence( assert, win );
        return ret;
}
int MPI_Win_free( MPI_Win * win )
{

        
        int ret = PMPI_Win_free( win );
        return ret;
}
int MPI_Win_free_keyval( int * win_keyval )
{

        
        int ret = PMPI_Win_free_keyval( win_keyval );
        return ret;
}
int MPI_Win_get_attr( MPI_Win win, int win_keyval, void * attribute_val, int * flag )
{

        
        int ret = PMPI_Win_get_attr( win, win_keyval, attribute_val, flag );
        return ret;
}
int MPI_Win_get_errhandler( MPI_Win win, MPI_Errhandler * errhandler )
{

        
        int ret = PMPI_Win_get_errhandler( win, errhandler );
        return ret;
}
int MPI_Win_get_group( MPI_Win win, MPI_Group * group )
{

        
        int ret = PMPI_Win_get_group( win, group );
        return ret;
}
int MPI_Win_get_name( MPI_Win win, char * win_name, int * resultlen )
{

        
        int ret = PMPI_Win_get_name( win, win_name, resultlen );
        return ret;
}
int MPI_Win_lock( int lock_type, int rank, int assert, MPI_Win win )
{

        
        int ret = PMPI_Win_lock( lock_type, rank, assert, win );
        return ret;
}
int MPI_Win_post( MPI_Group group, int assert, MPI_Win win )
{

        
        int ret = PMPI_Win_post( group, assert, win );
        return ret;
}
int MPI_Win_set_attr( MPI_Win win, int win_keyval, void * attribute_val )
{

        
        int ret = PMPI_Win_set_attr( win, win_keyval, attribute_val );
        return ret;
}
int MPI_Win_set_errhandler( MPI_Win win, MPI_Errhandler errhandler )
{

        
        int ret = PMPI_Win_set_errhandler( win, errhandler );
        return ret;
}
int MPI_Win_set_name( MPI_Win win, char * win_name )
{

        
        int ret = PMPI_Win_set_name( win, win_name );
        return ret;
}
int MPI_Win_start( MPI_Group group, int assert, MPI_Win win )
{

        
        int ret = PMPI_Win_start( group, assert, win );
        return ret;
}
int MPI_Win_test( MPI_Win win, int * flag )
{

        
        int ret = PMPI_Win_test( win, flag );
        return ret;
}
int MPI_Win_unlock( int rank, MPI_Win win )
{

        
        int ret = PMPI_Win_unlock( rank, win );
        return ret;
}
int MPI_Win_wait( MPI_Win win )
{

        
        int ret = PMPI_Win_wait( win );
        return ret;
}
double MPI_Wtick( )
{

        
        double ret = PMPI_Wtick( );
        return ret;
}
double MPI_Wtime( )
{

        
        double ret = PMPI_Wtime( );
        return ret;
}