sample.c

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

  return returnVal;
}

int   MPI_Type_commit( datatype )
MPI_Datatype * datatype;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Type_commit( datatype );


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

  return returnVal;
}

int  MPI_Type_contiguous( count, old_type, newtype )
int count;
MPI_Datatype old_type;
MPI_Datatype * newtype;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Type_contiguous( count, old_type, newtype );


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

  return returnVal;
}

int   MPI_Type_count( datatype, count )
MPI_Datatype datatype;
int * count;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Type_count( datatype, count );


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

  return returnVal;
}

int  MPI_Type_extent( datatype, extent )
MPI_Datatype datatype;
MPI_Aint * extent;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Type_extent( datatype, extent );


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

  return returnVal;
}

int   MPI_Type_free( datatype )
MPI_Datatype * datatype;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Type_free( datatype );


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

  return returnVal;
}

int  MPI_Type_hindexed( count, blocklens, indices, old_type, newtype )
int count;
int * blocklens;
MPI_Aint * indices;
MPI_Datatype old_type;
MPI_Datatype * newtype;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Type_hindexed( count, blocklens, indices, old_type, newtype );


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

  return returnVal;
}

int  MPI_Type_hvector( count, blocklen, stride, old_type, newtype )
int count;
int blocklen;
MPI_Aint stride;
MPI_Datatype old_type;
MPI_Datatype * newtype;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Type_hvector( count, blocklen, stride, old_type, newtype );


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

  return returnVal;
}

int  MPI_Type_indexed( count, blocklens, indices, old_type, newtype )
int count;
int * blocklens;
int * indices;
MPI_Datatype old_type;
MPI_Datatype * newtype;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Type_indexed( count, blocklens, indices, old_type, newtype );


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

  return returnVal;
}

int   MPI_Type_lb( datatype, displacement )
MPI_Datatype datatype;
MPI_Aint * displacement;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Type_lb( datatype, displacement );


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

  return returnVal;
}

int   MPI_Type_size( datatype, size )
MPI_Datatype datatype;
MPI_Aint * size;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Type_size( datatype, size );


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

  return returnVal;
}

int  MPI_Type_struct( count, blocklens, indices, old_types, newtype )
int count;
int * blocklens;
MPI_Aint * indices;
MPI_Datatype * old_types;
MPI_Datatype * newtype;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Type_struct( count, blocklens, indices, old_types, newtype );


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

  return returnVal;
}

int   MPI_Type_ub( datatype, displacement )
MPI_Datatype datatype;
MPI_Aint * displacement;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Type_ub( datatype, displacement );


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

  return returnVal;
}

int  MPI_Type_vector( count, blocklen, stride, old_type, newtype )
int count;
int blocklen;
int stride;
MPI_Datatype old_type;
MPI_Datatype * newtype;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Type_vector( count, blocklen, stride, old_type, newtype );


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

  return returnVal;
}

int   MPI_Unpack( inbuf, insize, position, outbuf, outcount, type, comm )
void * inbuf;
int insize;
int * position;
void * outbuf;
int outcount;
MPI_Datatype type;
MPI_Comm comm;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Unpack( inbuf, insize, position, outbuf, outcount, type, comm );


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

  return returnVal;
}

int   MPI_Wait( request, status )
MPI_Request * request;
MPI_Status * status;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Wait( request, status );


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

  return returnVal;
}

int  MPI_Waitall( count, array_of_requests, array_of_statuses )
int count;
MPI_Request * array_of_requests;
MPI_Status * array_of_statuses;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Waitall( count, array_of_requests, array_of_statuses );


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

  return returnVal;
}

int  MPI_Waitany( count, array_of_requests, index, status )
int count;
MPI_Request * array_of_requests;
int * index;
MPI_Status * status;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Waitany( count, array_of_requests, index, status );


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

  return returnVal;
}

int  MPI_Waitsome( incount, array_of_requests, outcount, array_of_indices, array_of_statuses )
int incount;
MPI_Request * array_of_requests;
int * outcount;
int * array_of_indices;
MPI_Status * array_of_statuses;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Waitsome( incount, array_of_requests, outcount, array_of_indices, array_of_statuses );


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

  return returnVal;
}

int   MPI_Cart_coords( comm, rank, maxdims, coords )
MPI_Comm comm;
int rank;
int maxdims;
int * coords;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Cart_coords( comm, rank, maxdims, coords );


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

  return returnVal;
}

int   MPI_Cart_create( comm_old, ndims, dims, periods, reorder, comm_cart )
MPI_Comm comm_old;
int ndims;
int * dims;
int * periods;
int reorder;
MPI_Comm * comm_cart;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Cart_create( comm_old, ndims, dims, periods, reorder, comm_cart );


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

  return returnVal;
}

int   MPI_Cart_get( comm, maxdims, dims, periods, coords )
MPI_Comm comm;
int maxdims;
int * dims;
int * periods;
int * coords;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Cart_get( comm, maxdims, dims, periods, coords );


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

  return returnVal;
}

int   MPI_Cart_map( comm_old, ndims, dims, periods, newrank )
MPI_Comm comm_old;
int ndims;
int * dims;
int * periods;
int * newrank;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Cart_map( comm_old, ndims, dims, periods, newrank );


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

  return returnVal;
}

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

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

  
  returnVal = PMPI_Cart_rank( comm, coords, rank );


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

  return returnVal;
}

int   MPI_Cart_shift( comm, direction, displ, source, dest )
MPI_Comm comm;
int direction;
int displ;
int * source;
int * dest;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Cart_shift( comm, direction, displ, source, dest );


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

  return returnVal;
}

int   MPI_Cart_sub( comm, remain_dims, comm_new )
MPI_Comm comm;
int * remain_dims;
MPI_Comm * comm_new;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Cart_sub( comm, remain_dims, comm_new );


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

  return returnVal;
}

int   MPI_Cartdim_get( comm, ndims )
MPI_Comm comm;
int * ndims;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Cartdim_get( comm, ndims );


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

  return returnVal;
}

int  MPI_Dims_create( nnodes, ndims, dims )
int nnodes;
int ndims;
int * dims;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Dims_create( nnodes, ndims, dims );


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

  return returnVal;
}

int   MPI_Graph_create( comm_old, nnodes, index, edges, reorder, comm_graph )
MPI_Comm comm_old;
int nnodes;
int * index;
int * edges;
int reorder;
MPI_Comm * comm_graph;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Graph_create( comm_old, nnodes, index, edges, reorder, comm_graph );


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

  return returnVal;
}

int   MPI_Graph_get( comm, maxindex, maxedges, index, edges )
MPI_Comm comm;
int maxindex;
int maxedges;
int * index;
int * edges;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Graph_get( comm, maxindex, maxedges, index, edges );


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

  return returnVal;
}

int   MPI_Graph_map( comm_old, nnodes, index, edges, newrank )
MPI_Comm comm_old;
int nnodes;
int * index;
int * edges;
int * newrank;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Graph_map( comm_old, nnodes, index, edges, newrank );


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

  return returnVal;
}

int   MPI_Graph_neighbors( comm, rank, maxneighbors, neighbors )
MPI_Comm comm;
int rank;
int  maxneighbors;
int * neighbors;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Graph_neighbors( comm, rank, maxneighbors, neighbors );


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

  return returnVal;
}

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

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

  
  returnVal = PMPI_Graph_neighbors_count( comm, rank, nneighbors );


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

  return returnVal;
}

int   MPI_Graphdims_get( comm, nnodes, nedges )
MPI_Comm comm;
int * nnodes;
int * nedges;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Graphdims_get( comm, nnodes, nedges );


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

  return returnVal;
}

int   MPI_Topo_test( comm, top_type )
MPI_Comm comm;
int * top_type;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Topo_test( comm, top_type );


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

  return returnVal;
}