Adding C bindings of MPI functions beginning with alphabet MPI_C*

This commit was SVN r507.

src/include/mpi.h

@@ -414,55 +414,66 @@ extern "C" {
                      int dest, int tag, MPI_Comm comm, MPI_Request *request); 
   int MPI_Buffer_attach(void *buffer, int size);
   int MPI_Buffer_detach(void *buffer, int *size);
+  int MPI_Cancel(MPI_Request *request);
+  int MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int *coords);
+  int MPI_Cart_create(MPI_Comm old_comm, int ndims, int *dims, 
+                      int *periods, int redorder, MPI_Comm *comm_cart);
+  int MPI_Cart_get(MPI_Comm comm, int maxdims, int *dims, 
+                   int *periods, int *coords);
+  int MPI_Cart_map(MPI_Comm comm, int ndims, int *dims, 
+                   int *periods, int *newrank);
+  int MPI_Cart_rank(MPI_Comm comm, int *coords, int *rank);
+  int MPI_Cart_shift(MPI_Comm comm, int direction, int disp, 
+                     int *rank_source, int *rank_dest);
+  int MPI_Cart_sub(MPI_Comm comm, int *remain_dims, MPI_Comm *new_comm);
+  int MPI_Cartdim_get(MPI_Comm comm, int *ndims);
+  int MPI_Close_port(char *port_name);
+  int MPI_Comm_accept(char *port_name, MPI_Info info, int root, 
+                      MPI_Comm comm, MPI_Comm *newcomm);
+  MPI_Fint MPI_Comm_c2f(MPI_Comm comm);
+  int MPI_Comm_call_error_handler(MPI_Comm comm, int errorcode);
+  int MPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result);
+  int MPI_Comm_connect(char *port_name, MPI_Info info, int root, 
+                       MPI_Comm comm, MPI_Comm *newcomm);
+  int MPI_Comm_create_errhandler(MPI_Comm_errhandler_fn *function, 
+                                 MPI_Errhandler *errhandler);
+  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 MPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm *newcomm);
+  int MPI_Comm_delete_attr(MPI_Comm comm, int comm_keyval);
+  int MPI_Comm_disconnect(MPI_Comm *comm);
+  int MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm);
+  MPI_Comm MPI_Comm_f2c(MPI_Fint comm);
+  int MPI_Comm_free_keyval(int *comm_keyval);
+  int MPI_Comm_free(MPI_Comm *comm);
+  int MPI_Comm_get_attr(MPI_Comm comm, int comm_keyval, 
+                        void *attribute_val, int *flag);
+  int MPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler *erhandler);
+  int MPI_Comm_get_name(MPI_Comm comm, char *comm_name, int *resultlen);
+  int MPI_Comm_get_parent(MPI_Comm *parent);
+  int MPI_Comm_group(MPI_Comm comm, MPI_Group *group);
+  int MPI_Comm_join(int fd, MPI_Comm *intercomm);
+  int MPI_Comm_rank(MPI_Comm comm, int *rank);
+  int MPI_Comm_remote_group(MPI_Comm comm, MPI_Group *group);
+  int MPI_Comm_remote_size(MPI_Comm comm, int *size);
+  int MPI_Comm_set_attr(MPI_Comm comm, int comm_keyval, void *attribute_val);
+  int MPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler);
+  int MPI_Comm_set_name(MPI_Comm comm, char *comm_name);
+  int MPI_Comm_size(MPI_Comm comm, int *size);
+  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);
+  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);
+  int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm);
+  int MPI_Comm_test_inter(MPI_Comm comm, int *flag);
   /* 
-   * Anju: Shell functions done till here 
+   * Anju:
+   * Here ends the alphabet C
    */
-  int MPI_Cancel(MPI_Request *);
-  int MPI_Cart_coords(MPI_Comm, int, int, int *);
-  int MPI_Cart_create(MPI_Comm, int, int *, int *, int, MPI_Comm *);
-  int MPI_Cartdim_get(MPI_Comm, int *);
-  int MPI_Cart_get(MPI_Comm, int, int *, int *, int *);
-  int MPI_Cart_map(MPI_Comm, int, int *, int *, int *);
-  int MPI_Cart_rank(MPI_Comm, int *, int *);
-  int MPI_Cart_shift(MPI_Comm, int, int, int *, int *);
-  int MPI_Cart_sub(MPI_Comm, int *, MPI_Comm *);
-  int MPI_Close_port(char *);
-  MPI_Fint MPI_Comm_c2f(MPI_Comm);
-  int MPI_Comm_accept(char *, MPI_Info, int, MPI_Comm, MPI_Comm *);
-  int MPI_Comm_compare(MPI_Comm, MPI_Comm, int *);
-  int MPI_Comm_connect(char *, MPI_Info, int, MPI_Comm, MPI_Comm *);
-  int MPI_Comm_create(MPI_Comm, MPI_Group, MPI_Comm *);
-  int MPI_Comm_create_errhandler(MPI_Comm_errhandler_fn *, 
-                                 MPI_Errhandler *);
-  int MPI_Comm_create_keyval(MPI_Comm_copy_attr_function *, 
-                             MPI_Comm_delete_attr_function *, 
-                             int *, void *);
-  int MPI_Comm_delete_attr(MPI_Comm, int);
-  int MPI_Comm_disconnect(MPI_Comm *);
-  int MPI_Comm_dup(MPI_Comm, MPI_Comm *);
-  MPI_Comm MPI_Comm_f2c(MPI_Fint);
-  int MPI_Comm_free(MPI_Comm *);
-  int MPI_Comm_free_keyval(int *);
-  int MPI_Comm_get_attr(MPI_Comm, int, void *, int *);
-  int MPI_Comm_get_errhandler(MPI_Comm, MPI_Errhandler *);
-  int MPI_Comm_get_name(MPI_Comm, char *, int *);
-  int MPI_Comm_get_parent(MPI_Comm *);
-  int MPI_Comm_group(MPI_Comm, MPI_Group *);
-  int MPI_Comm_join(int, MPI_Comm *);
-  int MPI_Comm_rank(MPI_Comm, int *);
-  int MPI_Comm_remote_group(MPI_Comm, MPI_Group *);
-  int MPI_Comm_remote_size(MPI_Comm, int *);
-  int MPI_Comm_set_attr(MPI_Comm, int, void *);
-  int MPI_Comm_set_errhandler(MPI_Comm, MPI_Errhandler);
-  int MPI_Comm_set_name(MPI_Comm, char *);
-  int MPI_Comm_size(MPI_Comm, int *);
-  int MPI_Comm_spawn(char *, char **, int, MPI_Info, int, 
-                     MPI_Comm, MPI_Comm *, int *);
-  int MPI_Comm_spawn_multiple(int, char **, char ***, int *, 
-                              MPI_Info *, int, MPI_Comm, 
-                              MPI_Comm *, int *);
-  int MPI_Comm_split(MPI_Comm, int, int, MPI_Comm *);
-  int MPI_Comm_test_inter(MPI_Comm, int *);
   int MPI_Dims_create(int, int, int *);
   MPI_Fint MPI_Errhandler_c2f(MPI_Errhandler err);
   int MPI_Errhandler_create(MPI_Handler_function *, MPI_Errhandler *);
@@ -670,80 +681,104 @@ extern "C" {
   /*
    * Profiling MPI API
    */
-  int PMPI_Abort(MPI_Comm, int);
-  int PMPI_Accumulate(void *, int, MPI_Datatype, int, MPI_Aint, 
-                      int, MPI_Datatype, MPI_Op, MPI_Win);
-  int PMPI_Address(void *, MPI_Aint *);
-  int PMPI_Allgather(void *, int, MPI_Datatype, void *, int, 
-                     MPI_Datatype, MPI_Comm);
-  int PMPI_Allgatherv(void *, int, MPI_Datatype, void *, int *, 
-                      int *, MPI_Datatype, MPI_Comm);
+  int PMPI_Abort(MPI_Comm comm, int errorcode);
+  int PMPI_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 PMPI_Add_error_class(int *errorclass);
+  int PMPI_Add_error_code(int errorclass, int *errorcode);
+  int PMPI_Add_error_string(int errorcode, char *string);
+  int PMPI_Address(void *location, MPI_Aint *address);
+  int PMPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype, 
+                    void *recvbuf, int recvcount, 
+                    MPI_Datatype recvtype, MPI_Comm comm);
+  int PMPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, 
+                     void *recvbuf, int *recvcounts, 
+                     int *displs, MPI_Datatype recvtype, MPI_Comm comm);
   int PMPI_Alloc_mem(MPI_Aint size, MPI_Info info, 
-                     void *baseptr);
-  int PMPI_Allreduce(void *, void *, int, MPI_Datatype, 
-                     MPI_Op, MPI_Comm);
-  int PMPI_Alltoall(void *, int, MPI_Datatype, void *, int, 
-                    MPI_Datatype, MPI_Comm);
-  int PMPI_Alltoallv(void *, int *, int *, MPI_Datatype, void *, 
-                     int *, int *, MPI_Datatype, MPI_Comm);
-  int PMPI_Alltoallw(void *, int *, int *, MPI_Datatype *, void *,
-                     int *, int *, MPI_Datatype *, MPI_Comm);
-  int PMPI_Attr_delete(MPI_Comm, int);
-  int PMPI_Attr_get(MPI_Comm, int, void *, int *);
-  int PMPI_Attr_put(MPI_Comm, int, void *);
-  int PMPI_Barrier(MPI_Comm);
-  int PMPI_Bcast(void *, int, MPI_Datatype, int, MPI_Comm);
-  int PMPI_Bsend(void *, int, MPI_Datatype, int, int, MPI_Comm);
-  int PMPI_Bsend_init(void *, int, MPI_Datatype, int, int, 
-                      MPI_Comm, MPI_Request *);
-  int PMPI_Buffer_attach(void *, int);
-  int PMPI_Buffer_detach(void *, int *);
-  int PMPI_Cancel(MPI_Request *);
-  int PMPI_Cart_coords(MPI_Comm, int, int, int *);
-  int PMPI_Cart_create(MPI_Comm, int, int *, int *, int, MPI_Comm *);
-  int PMPI_Cartdim_get(MPI_Comm, int *);
-  int PMPI_Cart_get(MPI_Comm, int, int *, int *, int *);
-  int PMPI_Cart_map(MPI_Comm, int, int *, int *, int *);
-  int PMPI_Cart_rank(MPI_Comm, int *, int *);
-  int PMPI_Cart_shift(MPI_Comm, int, int, int *, int *);
-  int PMPI_Cart_sub(MPI_Comm, int *, MPI_Comm *);
-  int PMPI_Close_port(char *);
-  MPI_Fint PMPI_Comm_c2f(MPI_Comm);
-  int PMPI_Comm_accept(char *, MPI_Info, int, MPI_Comm, MPI_Comm *);
-  int PMPI_Comm_compare(MPI_Comm, MPI_Comm, int *);
-  int PMPI_Comm_connect(char *, MPI_Info, int, MPI_Comm, MPI_Comm *);
-  int PMPI_Comm_create(MPI_Comm, MPI_Group, MPI_Comm *);
-  int PMPI_Comm_create_errhandler(MPI_Comm_errhandler_fn *, 
-                                  MPI_Errhandler *);
-  int PMPI_Comm_create_keyval(MPI_Comm_copy_attr_function *, 
-                              MPI_Comm_delete_attr_function *, 
-                              int *, void *);
-  int PMPI_Comm_delete_attr(MPI_Comm, int);
-  int PMPI_Comm_disconnect(MPI_Comm *);
-  int PMPI_Comm_dup(MPI_Comm, MPI_Comm *);
-  MPI_Comm PMPI_Comm_f2c(MPI_Fint);
-  int PMPI_Comm_free(MPI_Comm *);
-  int PMPI_Comm_free_keyval(int *);
-  int PMPI_Comm_get_attr(MPI_Comm, int, void *, int *);
-  int PMPI_Comm_get_errhandler(MPI_Comm, MPI_Errhandler *);
-  int PMPI_Comm_get_name(MPI_Comm, char *, int *);
-  int PMPI_Comm_get_parent(MPI_Comm *);
-  int PMPI_Comm_group(MPI_Comm, MPI_Group *);
-  int PMPI_Comm_join(int, MPI_Comm *);
-  int PMPI_Comm_rank(MPI_Comm, int *);
-  int PMPI_Comm_remote_group(MPI_Comm, MPI_Group *);
-  int PMPI_Comm_remote_size(MPI_Comm, int *);
-  int PMPI_Comm_set_attr(MPI_Comm, int, void *);
-  int PMPI_Comm_set_errhandler(MPI_Comm, MPI_Errhandler);
-  int PMPI_Comm_set_name(MPI_Comm, char *);
-  int PMPI_Comm_size(MPI_Comm, int *);
-  int PMPI_Comm_spawn(char *, char **, int, MPI_Info, int, 
-                      MPI_Comm, MPI_Comm *, int *);
-  int PMPI_Comm_spawn_multiple(int, char **, char ***, int *, 
-                               MPI_Info *, int, MPI_Comm, 
-                               MPI_Comm *, int *);
-  int PMPI_Comm_split(MPI_Comm, int, int, MPI_Comm *);
-  int PMPI_Comm_test_inter(MPI_Comm, int *);
+                    void *baseptr);
+  int PMPI_Allreduce(void *sendbuf, void *recvbuf, int count, 
+                    MPI_Datatype datatype, MPI_Op op, MPI_Comm comm); 
+  int PMPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype sendtype, 
+                   void *recvbuf, int recvcount, 
+                   MPI_Datatype recvtype, MPI_Comm comm);
+  int PMPI_Alltoallv(void *sendbuf, int *sendcounts, int *sdispls, 
+                    MPI_Datatype sendtype, void *recvbuf, int *recvcounts,
+                    int *rdispls, MPI_Datatype recvtype, MPI_Comm comm);
+  int PMPI_Alltoallw(void *sendbuf, int *sendcounts, int *sdispls, MPI_Datatype *sendtypes, 
+                    void *recvbuf, int *recvcounts, int *rdispls, MPI_Datatype *recvtypes,
+                    MPI_Comm comm);
+  int PMPI_Attr_delete(MPI_Comm comm, int keyval);
+  int PMPI_Attr_get(MPI_Comm comm, int keyval, void *attribute_val, int *flag);
+  int PMPI_Attr_put(MPI_Comm comm, int keyval, void *attribute_val);
+  int PMPI_Barrier(MPI_Comm comm);
+  int PMPI_Bcast(void *buffer, int count, MPI_Datatype datatype, 
+                int root, MPI_Comm comm);
+  int PMPI_Bsend(void *buf, int count, MPI_Datatype datatype, 
+                int dest, int tag, MPI_Comm comm);
+  int PMPI_Bsend_init(void *buf, int count, MPI_Datatype datatype, 
+                     int dest, int tag, MPI_Comm comm, MPI_Request *request); 
+  int PMPI_Buffer_attach(void *buffer, int size);
+  int PMPI_Buffer_detach(void *buffer, int *size);
+  int PMPI_Cancel(MPI_Request *request);
+  int PMPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int *coords);
+  int PMPI_Cart_create(MPI_Comm old_comm, int ndims, int *dims, 
+                      int *periods, int redorder, MPI_Comm *comm_cart);
+  int PMPI_Cart_get(MPI_Comm comm, int maxdims, int *dims, 
+                   int *periods, int *coords);
+  int PMPI_Cart_map(MPI_Comm comm, int ndims, int *dims, 
+                   int *periods, int *newrank);
+  int PMPI_Cart_rank(MPI_Comm comm, int *coords, int *rank);
+  int PMPI_Cart_shift(MPI_Comm comm, int direction, int disp, 
+                     int *rank_source, int *rank_dest);
+  int PMPI_Cart_sub(MPI_Comm comm, int *remain_dims, MPI_Comm *new_comm);
+  int PMPI_Cartdim_get(MPI_Comm comm, int *ndims);
+  int PMPI_Close_port(char *port_name);
+  int PMPI_Comm_accept(char *port_name, MPI_Info info, int root, 
+                      MPI_Comm comm, MPI_Comm *newcomm);
+  MPI_Fint PMPI_Comm_c2f(MPI_Comm comm);
+  int PMPI_Comm_call_error_handler(MPI_Comm comm, int errorcode);
+  int PMPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result);
+  int PMPI_Comm_connect(char *port_name, MPI_Info info, int root, 
+                       MPI_Comm comm, MPI_Comm *newcomm);
+  int PMPI_Comm_create_errhandler(MPI_Comm_errhandler_fn *function, 
+                                 MPI_Errhandler *errhandler);
+  int PMPI_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 PMPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm *newcomm);
+  int PMPI_Comm_delete_attr(MPI_Comm comm, int comm_keyval);
+  int PMPI_Comm_disconnect(MPI_Comm *comm);
+  int PMPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm);
+  MPI_Comm PMPI_Comm_f2c(MPI_Fint comm);
+  int PMPI_Comm_free_keyval(int *comm_keyval);
+  int PMPI_Comm_free(MPI_Comm *comm);
+  int PMPI_Comm_get_attr(MPI_Comm comm, int comm_keyval, 
+                        void *attribute_val, int *flag);
+  int PMPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler *erhandler);
+  int PMPI_Comm_get_name(MPI_Comm comm, char *comm_name, int *resultlen);
+  int PMPI_Comm_get_parent(MPI_Comm *parent);
+  int PMPI_Comm_group(MPI_Comm comm, MPI_Group *group);
+  int PMPI_Comm_join(int fd, MPI_Comm *intercomm);
+  int PMPI_Comm_rank(MPI_Comm comm, int *rank);
+  int PMPI_Comm_remote_group(MPI_Comm comm, MPI_Group *group);
+  int PMPI_Comm_remote_size(MPI_Comm comm, int *size);
+  int PMPI_Comm_set_attr(MPI_Comm comm, int comm_keyval, void *attribute_val);
+  int PMPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler);
+  int PMPI_Comm_set_name(MPI_Comm comm, char *comm_name);
+  int PMPI_Comm_size(MPI_Comm comm, int *size);
+  int PMPI_Comm_spawn(char *command, char **argv, int maxprocs, MPI_Info info, 
+                     int root, MPI_Comm comm, MPI_Comm *intercomm, 
+                     int *array_of_errcodes);
+  int PMPI_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);
+  int PMPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm);
+  int PMPI_Comm_test_inter(MPI_Comm comm, int *flag);
+  /*
+   * Here ends Aplphabet C
+   */
   int PMPI_Dims_create(int, int, int *);
   MPI_Fint PMPI_Errhandler_c2f(MPI_Errhandler err);
   int PMPI_Errhandler_create(MPI_Handler_function *, MPI_Errhandler *);

src/mpi/interface/c/Makefile.am

@@ -78,8 +78,47 @@ libmpi_c_mpi_la_SOURCES = \
 				bsend.c \
 				buffer_attach.c \
 				buffer_detach.c \
-                comm_get_name.c \
-                comm_set_name.c \
+				cancel.c \
+				cart_coords.c \
+				cart_create.c \
+				cart_get.c \
+				cart_map.c \
+				cart_rank.c \
+				cart_shift.c \
+				cart_sub.c \
+				cartdim_get.c \
+				close_port.c \
+				comm_accept.c \
+				comm_c2f.c \
+				comm_call_errhandler.c \
+				comm_compare.c \
+				comm_connect.c \
+				comm_create_errhandler.c \
+				comm_create_keyval.c \
+				comm_create.c \
+				comm_delete_attr.c \
+				comm_disconnect.c \
+				comm_dup.c \
+				comm_f2c.c \
+				comm_free_keyval.c \
+				comm_free.c \
+				comm_get_attr.c \
+				comm_get_errhandler.c \
+				comm_get_name.c \
+				comm_get_parent.c \
+				comm_group.c \
+				comm_join.c \
+				comm_rank.c \
+				comm_remote_group.c \
+				comm_remote_size.c \
+				comm_set_attribute.c \
+				comm_set_errhandler.c \
+				comm_set_name.c \
+				comm_size.c \
+				comm_spawn.c \
+				comm_spawn_multiple.c \
+				comm_split.c \
+				comm_test_inter.c \
                 finalize.c \
                 free_mem.c \
                 init.c

src/mpi/interface/c/cancel.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Cancel = PMPI_Cancel
+#endif
+
+int MPI_Cancel(MPI_Request *request) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/cart_coords.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Cart_coords = PMPI_Cart_coords
+#endif
+
+int MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int *coords) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/cart_create.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Cart_create = PMPI_Cart_create
+#endif
+
+int MPI_Cart_create(MPI_Comm old_comm, int ndims, int *dims,
+                    int *periods, int redorder, MPI_Comm *comm_cart) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/cart_get.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Cart_get = PMPI_Cart_get
+#endif
+
+int MPI_Cart_get(MPI_Comm comm, int maxdims, int *dims,
+                 int *periods, int *coords) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/cart_map.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Cart_map = PMPI_Cart_map
+#endif
+
+int MPI_Cart_map(MPI_Comm comm, int ndims, int *dims,
+                int *periods, int *newrank) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/cart_rank.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Cart_rank = PMPI_Cart_rank
+#endif
+
+
+int MPI_Cart_rank(MPI_Comm comm, int *coords, int *rank) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/cart_shift.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Cart_shift = PMPI_Cart_shift
+#endif
+
+int MPI_Cart_shift(MPI_Comm comm, int direction, int disp,
+                   int *rank_source, int *rank_dest) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/cart_sub.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Cart_sub = PMPI_Cart_sub
+#endif
+
+
+int MPI_Cart_sub(MPI_Comm comm, int *remain_dims, MPI_Comm *new_comm) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/cartdim_get.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Cartdim_get = PMPI_Cartdim_get
+#endif
+
+
+int MPI_Cartdim_get(MPI_Comm comm, int *ndims) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/close_port.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Close_port = PMPI_Close_port
+#endif
+
+int MPI_Close_port(char *port_name) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_accept.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_accept = PMPI_Comm_accept
+#endif
+
+int MPI_Comm_accept(char *port_name, MPI_Info info, int root,
+                    MPI_Comm comm, MPI_Comm *newcomm) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_c2f.c

@@ -0,0 +1,20 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_c2f = PMPI_Comm_c2f
+#endif
+
+MPI_Fint MPI_Comm_c2f(MPI_Comm comm) {
+	/*
+	 * Anju:
+	 * Dont know what it is supposed to return
+	 */
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_call_errhandler.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_call_errhandler = PMPI_Comm_call_errhandler
+#endif
+    
+
+int MPI_Comm_call_error_handler(MPI_Comm comm, int errorcode) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_compare.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_compare = PMPI_Comm_compare
+#endif
+
+int MPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_connect.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_connect = PMPI_Comm_connect
+#endif
+
+int MPI_Comm_connect(char *port_name, MPI_Info info, int root,
+                     MPI_Comm comm, MPI_Comm *newcomm) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_create.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_create = PMPI_Comm_create
+#endif
+
+int MPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm *newcomm) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_create_errhandler.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_create_errhandler = PMPI_Comm_create_errhandler
+#endif
+
+int MPI_Comm_create_errhandler(MPI_Comm_errhandler_fn *function,
+                               MPI_Errhandler *errhandler) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_create_keyval.c

@@ -0,0 +1,18 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Create_keyval = PMPI_Create_keyval
+#endif
+
+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) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_delete_attr.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_delete_attr = PMPI_Comm_delete_attr
+#endif
+
+int MPI_Comm_delete_attr(MPI_Comm comm, int comm_keyval) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_disconnect.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_disconnect = PMPI_Comm_disconnect
+#endif
+
+int MPI_Comm_disconnect(MPI_Comm *comm) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_dup.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_dup = PMPI_Comm_dup
+#endif
+
+int MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_f2c.c

@@ -0,0 +1,21 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_f2c = PMPI_Comm_f2c
+#endif
+
+
+MPI_Comm MPI_Comm_f2c(MPI_Fint comm) {
+    /*
+     * Anju:
+     * Check if what I have returned is right
+     */
+    return MPI_COMM_NULL;
+}

src/mpi/interface/c/comm_free.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_free = PMPI_Comm_free
+#endif
+
+int MPI_Comm_free(MPI_Comm *comm) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_free_keyval.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_free_keyval = PMPI_Comm_free_keyval
+#endif
+
+int MPI_Comm_free_keyval(int *comm_keyval) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_get_attr.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_get_attr = PMPI_Comm_get_attr
+#endif
+
+int MPI_Comm_get_attr(MPI_Comm comm, int comm_keyval,
+                      void *attribute_val, int *flag) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_get_errhandler.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_get_errhandler = PMPI_Comm_get_errhandler
+#endif
+
+int MPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler *erhandler) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_get_parent.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_get_parent = PMPI_Comm_get_parent
+#endif
+
+int MPI_Comm_get_parent(MPI_Comm *parent) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_group.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_group = PMPI_Comm_group
+#endif
+
+int MPI_Comm_group(MPI_Comm comm, MPI_Group *group) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_join.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_join = PMPI_Comm_join
+#endif
+
+int MPI_Comm_join(int fd, MPI_Comm *intercomm) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_rank.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_rank = PMPI_Comm_rank
+#endif
+
+
+int MPI_Comm_rank(MPI_Comm comm, int *rank) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_remote_group.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_remote_group = PMPI_Comm_remote_group
+#endif
+
+
+int MPI_Comm_remote_group(MPI_Comm comm, MPI_Group *group) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_remote_size.c

@@ -0,0 +1,17 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_remote_size = PMPI_Comm_remote_size
+#endif
+
+
+int MPI_Comm_remote_size(MPI_Comm comm, int *size) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_set_attribute.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_set_attribute = PMPI_Comm_set_attribute
+#endif
+
+int MPI_Comm_set_attr(MPI_Comm comm, int comm_keyval, void *attribute_val) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_set_errhandler.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_set_errhandler = PMPI_Comm_set_errhandler
+#endif
+
+int MPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_size.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_size = PMPI_Comm_size
+#endif
+
+int MPI_Comm_size(MPI_Comm comm, int *size) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_spawn.c

@@ -0,0 +1,18 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_spawn = PMPI_Comm_spawn
+#endif
+
+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) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_spawn_multiple.c

@@ -0,0 +1,19 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_spawn_multiple = PMPI_Comm_spawn_multiple
+#endif
+
+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) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_split.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_split = PMPI_Comm_split
+#endif
+
+int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/comm_test_inter.c

@@ -0,0 +1,16 @@
+/*
+ * $HEADERS$
+ */
+#include "lam_config.h"
+#include <stdio.h>
+
+#include "mpi.h"
+#include "mpi/interface/c/bindings.h"
+
+#if LAM_HAVE_WEAK_SYMBOLS && LAM_PROFILING_DEFINES
+#pragma weak MPI_Comm_test_inter = PMPI_Comm_test_inter
+#endif
+
+int MPI_Comm_test_inter(MPI_Comm comm, int *flag) {
+    return MPI_SUCCESS;
+}

src/mpi/interface/c/profile/Makefile.am

@@ -51,8 +51,47 @@ nodist_libmpi_c_pmpi_la_SOURCES = \
 				pbsend.c \
 				pbuffer_attach.c \
 				pbuffer_detach.c \
-                pcomm_get_name.c \
-                pcomm_set_name.c \
+				pcancel.c \
+				pcart_coords.c \
+				pcart_create.c \
+				pcart_get.c \
+				pcart_map.c \
+				pcart_rank.c \
+				pcart_shift.c \
+				pcart_sub.c \
+				pcartdim_get.c \
+				pclose_port.c \
+				pcomm_accept.c \
+				pcomm_c2f.c \
+				pcomm_call_errhandler.c \
+				pcomm_compare.c \
+				pcomm_connect.c \
+				pcomm_create_errhandler.c \
+				pcomm_create_keyval.c \
+				pcomm_create.c \
+				pcomm_delete_attr.c \
+				pcomm_disconnect.c \
+				pcomm_dup.c \
+				pcomm_f2c.c \
+				pcomm_free_keyval.c \
+				pcomm_free.c \
+				pcomm_get_attr.c \
+				pcomm_get_errhandler.c \
+				pcomm_get_name.c \
+				pcomm_get_parent.c \
+				pcomm_group.c \
+				pcomm_join.c \
+				pcomm_rank.c \
+				pcomm_remote_group.c \
+				pcomm_remote_size.c \
+				pcomm_set_attribute.c \
+				pcomm_set_errhandler.c \
+				pcomm_set_name.c \
+				pcomm_size.c \
+				pcomm_spawn.c \
+				pcomm_spawn_multiple.c \
+				pcomm_split.c \
+				pcomm_test_inter.c \
                 pfinalize.c \
                 pfree_mem.c \
                 pinit.c

src/mpi/interface/c/profile/defines.h

@@ -33,8 +33,47 @@
 #define MPI_Bsend PMPI_Bsend
 #define MPI_Buffer_attach PMPI_Buffer_attach
 #define MPI_Buffer_detach PMPI_Buffer_detach
+#define MPI_Cancel PMPI_Cancel
+#define MPI_Cart_coords PMPI_Cart_coords
+#define MPI_Cart_create PMPI_Cart_create
+#define MPI_Cart_get PMPI_Cart_get
+#define MPI_Cart_map PMPI_Cart_map
+#define MPI_Cart_rank PMPI_Cart_rank
+#define MPI_Cart_shift PMPI_Cart_shift
+#define MPI_Cart_sub PMPI_Cart_sub
+#define MPI_Cartdim_get PMPI_Cartdim_get
+#define MPI_Close_port PMPI_Close_port
+#define MPI_Comm_accept PMPI_Comm_accept
+#define MPI_Comm_c2f PMPI_Comm_c2f
+#define MPI_Comm_call_errhandler PMPI_Comm_call_errhandler
+#define MPI_Comm_compare PMPI_Comm_compare
+#define MPI_Comm_connect PMPI_Comm_connect
+#define MPI_Comm_create_errhandler PMPI_Comm_create_errhandler
+#define MPI_Comm_create_keyval PMPI_Comm_create_keyval
+#define MPI_Comm_create PMPI_Comm_create
+#define MPI_Comm_delete_attr PMPI_Comm_delete_attr
+#define MPI_Comm_disconnect PMPI_Comm_disconnect
+#define MPI_Comm_dup PMPI_Comm_dup
+#define MPI_Comm_f2c PMPI_Comm_f2c
+#define MPI_Comm_free_keyval PMPI_Comm_free_keyval
+#define MPI_Comm_free PMPI_Comm_free
+#define MPI_Comm_get_attr PMPI_Comm_get_attr
+#define MPI_Comm_get_errhandler PMPI_Comm_get_errhandler
 #define MPI_Comm_get_name PMPI_Comm_get_name
+#define MPI_Comm_get_parent PMPI_Comm_get_parent
+#define MPI_Comm_group PMPI_Comm_group
+#define MPI_Comm_join PMPI_Comm_join
+#define MPI_Comm_rank PMPI_Comm_rank
+#define MPI_Comm_remote_group PMPI_Comm_remote_group
+#define MPI_Comm_remote_size PMPI_Comm_remote_size
+#define MPI_Comm_set_attr PMPI_Comm_set_attr
+#define MPI_Comm_set_errhandler PMPI_Comm_set_errhandler
 #define MPI_Comm_set_name PMPI_Comm_set_name
+#define MPI_Comm_size PMPI_Comm_size
+#define MPI_Comm_spawn PMPI_Comm_spawn
+#define MPI_Comm_spawn_multiple PMPI_Comm_spawn_multiple
+#define MPI_Comm_split PMPI_Comm_split
+#define MPI_Comm_test_inter PMPI_Comm_test_inter
 #define MPI_Finalize PMPI_Finalize
 #define MPI_Free_mem PMPI_Free_mem
 #define MPI_Init PMPI_Init