prof.c

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

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


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

  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 ;
int  * 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;
}