sample.c

MPICH是MPI的重要研究,提供了一系列的接口函数,为并行计算的实现提供了编程环境.

#include "mpi.h"


static int MPI_Send_nsends_0; 
static int MPI_Bsend_nsends_0; 
static int MPI_Isend_nsends_0; 

int MPI_Allgather_ncalls_0;
int MPI_Allgatherv_ncalls_0;
int MPI_Allreduce_ncalls_0;
int MPI_Alltoall_ncalls_0;
int MPI_Alltoallv_ncalls_0;
int MPI_Barrier_ncalls_0;
int MPI_Bcast_ncalls_0;
int MPI_Gather_ncalls_0;
int MPI_Gatherv_ncalls_0;
int MPI_Op_create_ncalls_0;
int MPI_Op_free_ncalls_0;
int MPI_Reduce_scatter_ncalls_0;
int MPI_Reduce_ncalls_0;
int MPI_Scan_ncalls_0;
int MPI_Scatter_ncalls_0;
int MPI_Scatterv_ncalls_0;
int MPI_Attr_delete_ncalls_0;
int MPI_Attr_get_ncalls_0;
int MPI_Attr_put_ncalls_0;
int MPI_Comm_compare_ncalls_0;
int MPI_Comm_create_ncalls_0;
int MPI_Comm_dup_ncalls_0;
int MPI_Comm_free_ncalls_0;
int MPI_Comm_group_ncalls_0;
int MPI_Comm_rank_ncalls_0;
int MPI_Comm_remote_group_ncalls_0;
int MPI_Comm_remote_size_ncalls_0;
int MPI_Comm_size_ncalls_0;
int MPI_Comm_split_ncalls_0;
int MPI_Comm_test_inter_ncalls_0;
int MPI_Group_compare_ncalls_0;
int MPI_Group_difference_ncalls_0;
int MPI_Group_excl_ncalls_0;
int MPI_Group_free_ncalls_0;
int MPI_Group_incl_ncalls_0;
int MPI_Group_intersection_ncalls_0;
int MPI_Group_rank_ncalls_0;
int MPI_Group_range_excl_ncalls_0;
int MPI_Group_range_incl_ncalls_0;
int MPI_Group_size_ncalls_0;
int MPI_Group_translate_ranks_ncalls_0;
int MPI_Group_union_ncalls_0;
int MPI_Intercomm_create_ncalls_0;
int MPI_Intercomm_merge_ncalls_0;
int MPI_Keyval_create_ncalls_0;
int MPI_Keyval_free_ncalls_0;
int MPI_Abort_ncalls_0;
int MPI_Error_class_ncalls_0;
int MPI_Errhandler_create_ncalls_0;
int MPI_Errhandler_free_ncalls_0;
int MPI_Errhandler_get_ncalls_0;
int MPI_Error_string_ncalls_0;
int MPI_Errhandler_set_ncalls_0;
int MPI_Get_processor_name_ncalls_0;
int MPI_Initialized_ncalls_0;
int MPI_Wtick_ncalls_0;
int MPI_Address_ncalls_0;
int MPI_Bsend_ncalls_0;
int MPI_Bsend_init_ncalls_0;
int MPI_Buffer_attach_ncalls_0;
int MPI_Buffer_detach_ncalls_0;
int MPI_Cancel_ncalls_0;
int MPI_Request_free_ncalls_0;
int MPI_Recv_init_ncalls_0;
int MPI_Send_init_ncalls_0;
int MPI_Get_elements_ncalls_0;
int MPI_Get_count_ncalls_0;
int MPI_Ibsend_ncalls_0;
int MPI_Iprobe_ncalls_0;
int MPI_Irecv_ncalls_0;
int MPI_Irsend_ncalls_0;
int MPI_Isend_ncalls_0;
int MPI_Issend_ncalls_0;
int MPI_Pack_ncalls_0;
int MPI_Pack_size_ncalls_0;
int MPI_Probe_ncalls_0;
int MPI_Recv_ncalls_0;
int MPI_Rsend_ncalls_0;
int MPI_Rsend_init_ncalls_0;
int MPI_Send_ncalls_0;
int MPI_Sendrecv_ncalls_0;
int MPI_Sendrecv_replace_ncalls_0;
int MPI_Ssend_ncalls_0;
int MPI_Ssend_init_ncalls_0;
int MPI_Start_ncalls_0;
int MPI_Startall_ncalls_0;
int MPI_Test_ncalls_0;
int MPI_Testall_ncalls_0;
int MPI_Testany_ncalls_0;
int MPI_Test_cancelled_ncalls_0;
int MPI_Testsome_ncalls_0;
int MPI_Type_commit_ncalls_0;
int MPI_Type_contiguous_ncalls_0;
int MPI_Type_count_ncalls_0;
int MPI_Type_extent_ncalls_0;
int MPI_Type_free_ncalls_0;
int MPI_Type_hindexed_ncalls_0;
int MPI_Type_hvector_ncalls_0;
int MPI_Type_indexed_ncalls_0;
int MPI_Type_lb_ncalls_0;
int MPI_Type_size_ncalls_0;
int MPI_Type_struct_ncalls_0;
int MPI_Type_ub_ncalls_0;
int MPI_Type_vector_ncalls_0;
int MPI_Unpack_ncalls_0;
int MPI_Wait_ncalls_0;
int MPI_Waitall_ncalls_0;
int MPI_Waitany_ncalls_0;
int MPI_Waitsome_ncalls_0;
int MPI_Cart_coords_ncalls_0;
int MPI_Cart_create_ncalls_0;
int MPI_Cart_get_ncalls_0;
int MPI_Cart_map_ncalls_0;
int MPI_Cart_rank_ncalls_0;
int MPI_Cart_shift_ncalls_0;
int MPI_Cart_sub_ncalls_0;
int MPI_Cartdim_get_ncalls_0;
int MPI_Dims_create_ncalls_0;
int MPI_Graph_create_ncalls_0;
int MPI_Graph_get_ncalls_0;
int MPI_Graph_map_ncalls_0;
int MPI_Graph_neighbors_ncalls_0;
int MPI_Graph_neighbors_count_ncalls_0;
int MPI_Graphdims_get_ncalls_0;
int MPI_Topo_test_ncalls_0;





int   MPI_Allgather( sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm )
void * sendbuf;
int sendcount;
MPI_Datatype sendtype;
void * recvbuf;
int recvcount;
MPI_Datatype recvtype;
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Allgather is being called.\n" );

  
  returnVal = PMPI_Allgather( sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm );


  MPI_Allgather_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Allgatherv( sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm )
void * sendbuf;
int sendcount;
MPI_Datatype sendtype;
void * recvbuf;
int * recvcounts;
int * displs;
MPI_Datatype recvtype;
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Allgatherv is being called.\n" );

  
  returnVal = PMPI_Allgatherv( sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm );


  MPI_Allgatherv_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Allreduce( sendbuf, recvbuf, count, datatype, op, comm )
void * sendbuf;
void * recvbuf;
int count;
MPI_Datatype datatype;
MPI_Op op;
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Allreduce is being called.\n" );

  
  returnVal = PMPI_Allreduce( sendbuf, recvbuf, count, datatype, op, comm );


  MPI_Allreduce_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int  MPI_Alltoall( sendbuf, sendcount, sendtype, recvbuf, recvcnt, recvtype, comm )
void * sendbuf;
int sendcount;
MPI_Datatype sendtype;
void * recvbuf;
int recvcnt;
MPI_Datatype recvtype;
MPI_Comm comm;
{
  int  returnVal;
  int i;

  
  printf( "MPI_Alltoall is being called.\n" );

  
  returnVal = PMPI_Alltoall( sendbuf, sendcount, sendtype, recvbuf, recvcnt, recvtype, comm );


  MPI_Alltoall_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Alltoallv( sendbuf, sendcnts, sdispls, sendtype, recvbuf, recvcnts, rdispls, recvtype, comm )
void * sendbuf;
int * sendcnts;
int * sdispls;
MPI_Datatype sendtype;
void * recvbuf;
int * recvcnts;
int * rdispls;
MPI_Datatype recvtype;
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Alltoallv is being called.\n" );

  
  returnVal = PMPI_Alltoallv( sendbuf, sendcnts, sdispls, sendtype, recvbuf, recvcnts, rdispls, recvtype, comm );


  MPI_Alltoallv_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Barrier( comm )
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Barrier is being called.\n" );

  
  returnVal = PMPI_Barrier( comm );


  MPI_Barrier_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Bcast( buffer, count, datatype, root, comm )
void * buffer;
int count;
MPI_Datatype datatype;
int root;
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Bcast is being called.\n" );

  
  returnVal = PMPI_Bcast( buffer, count, datatype, root, comm );


  MPI_Bcast_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Gather( sendbuf, sendcnt, sendtype, recvbuf, recvcount, recvtype, root, comm )
void * sendbuf;
int sendcnt;
MPI_Datatype sendtype;
void * recvbuf;
int recvcount;
MPI_Datatype recvtype;
int root;
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Gather is being called.\n" );

  
  returnVal = PMPI_Gather( sendbuf, sendcnt, sendtype, recvbuf, recvcount, recvtype, root, comm );


  MPI_Gather_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Gatherv( sendbuf, sendcnt, sendtype, recvbuf, recvcnts, displs, recvtype, root, comm )
void * sendbuf;
int sendcnt;
MPI_Datatype sendtype;
void * recvbuf;
int * recvcnts;
int * displs;
MPI_Datatype recvtype;
int root;
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Gatherv is being called.\n" );

  
  returnVal = PMPI_Gatherv( sendbuf, sendcnt, sendtype, recvbuf, recvcnts, displs, recvtype, root, comm );


  MPI_Gatherv_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int  MPI_Op_create( function, commute, op )
MPI_User_function * function;
int commute;
MPI_Op * op;
{
  int  returnVal;
  int i;

  
  printf( "MPI_Op_create is being called.\n" );

  
  returnVal = PMPI_Op_create( function, commute, op );


  MPI_Op_create_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int  MPI_Op_free( op )
MPI_Op * op;
{
  int  returnVal;
  int i;

  
  printf( "MPI_Op_free is being called.\n" );

  
  returnVal = PMPI_Op_free( op );


  MPI_Op_free_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Reduce_scatter( sendbuf, recvbuf, recvcnts, datatype, op, comm )
void * sendbuf;
void * recvbuf;
int * recvcnts;
MPI_Datatype datatype;
MPI_Op op;
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Reduce_scatter is being called.\n" );

  
  returnVal = PMPI_Reduce_scatter( sendbuf, recvbuf, recvcnts, datatype, op, comm );


  MPI_Reduce_scatter_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Reduce( sendbuf, recvbuf, count, datatype, op, root, comm )
void * sendbuf;
void * recvbuf;
int count;
MPI_Datatype datatype;
MPI_Op op;
int root;
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Reduce is being called.\n" );

  
  returnVal = PMPI_Reduce( sendbuf, recvbuf, count, datatype, op, root, comm );


  MPI_Reduce_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Scan( sendbuf, recvbuf, count, datatype, op, comm )
void * sendbuf;
void * recvbuf;
int count;
MPI_Datatype datatype;
MPI_Op op;
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Scan is being called.\n" );

  
  returnVal = PMPI_Scan( sendbuf, recvbuf, count, datatype, op, comm );


  MPI_Scan_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Scatter( sendbuf, sendcnt, sendtype, recvbuf, recvcnt, recvtype, root, comm )
void * sendbuf;
int sendcnt;
MPI_Datatype sendtype;
void * recvbuf;
int recvcnt;
MPI_Datatype recvtype;
int root;
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Scatter is being called.\n" );

  
  returnVal = PMPI_Scatter( sendbuf, sendcnt, sendtype, recvbuf, recvcnt, recvtype, root, comm );


  MPI_Scatter_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Scatterv( sendbuf, sendcnts, displs, sendtype, recvbuf, recvcnt, recvtype, root, comm )
void * sendbuf;
int * sendcnts;
int * displs;
MPI_Datatype sendtype;
void * recvbuf;
int recvcnt;
MPI_Datatype recvtype;
int root;
MPI_Comm comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Scatterv is being called.\n" );

  
  returnVal = PMPI_Scatterv( sendbuf, sendcnts, displs, sendtype, recvbuf, recvcnt, recvtype, root, comm );


  MPI_Scatterv_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Attr_delete( comm, keyval )
MPI_Comm comm;
int keyval;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Attr_delete is being called.\n" );

  
  returnVal = PMPI_Attr_delete( comm, keyval );


  MPI_Attr_delete_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Attr_get( comm, keyval, attr_value, flag )
MPI_Comm comm;
int keyval;
void * attr_value;
int * flag;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Attr_get is being called.\n" );

  
  returnVal = PMPI_Attr_get( comm, keyval, attr_value, flag );


  MPI_Attr_get_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Attr_put( comm, keyval, attr_value )
MPI_Comm comm;
int keyval;
void * attr_value;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Attr_put is being called.\n" );

  
  returnVal = PMPI_Attr_put( comm, keyval, attr_value );


  MPI_Attr_put_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Comm_compare( comm1, comm2, result )
MPI_Comm comm1;
MPI_Comm comm2;
int * result;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Comm_compare is being called.\n" );

  
  returnVal = PMPI_Comm_compare( comm1, comm2, result );


  MPI_Comm_compare_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Comm_create( comm, group, comm_out )
MPI_Comm comm;
MPI_Group group;
MPI_Comm * comm_out;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Comm_create is being called.\n" );

  
  returnVal = PMPI_Comm_create( comm, group, comm_out );


  MPI_Comm_create_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Comm_dup( comm, comm_out )
MPI_Comm comm;
MPI_Comm * comm_out;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Comm_dup is being called.\n" );

  
  returnVal = PMPI_Comm_dup( comm, comm_out );


  MPI_Comm_dup_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Comm_free( comm )
MPI_Comm * comm;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Comm_free is being called.\n" );

  
  returnVal = PMPI_Comm_free( comm );


  MPI_Comm_free_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Comm_group( comm, group )
MPI_Comm comm;
MPI_Group * group;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Comm_group is being called.\n" );

  
  returnVal = PMPI_Comm_group( comm, group );


  MPI_Comm_group_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Comm_rank( comm, rank )
MPI_Comm comm;
int * rank;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Comm_rank is being called.\n" );

  
  returnVal = PMPI_Comm_rank( comm, rank );


  MPI_Comm_rank_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Comm_remote_group( comm, group )
MPI_Comm comm;
MPI_Group * group;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Comm_remote_group is being called.\n" );

  
  returnVal = PMPI_Comm_remote_group( comm, group );


  MPI_Comm_remote_group_ncalls_0++;
  printf( "i unused (%d).\n", i );

  return returnVal;
}

int   MPI_Comm_remote_size( comm, size )
MPI_Comm comm;
int * size;
{
  int   returnVal;
  int i;

  
  printf( "MPI_Comm_remote_size is being called.\n" );

  
  returnVal = PMPI_Comm_remote_size( comm, size );