trace_mpi_core.c

fortran并行计算包

  return returnVal;
}

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

/*
    MPI_Type_lb - prototyping replacement for MPI_Type_lb
    Trace the beginning and ending of MPI_Type_lb.
*/

  TRACE_PRINTF( "Starting MPI_Type_lb..." );
  
  returnVal = PMPI_Type_lb( datatype, displacement );

  TRACE_PRINTF( "Ending MPI_Type_lb" );

  return returnVal;
}

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

/*
    MPI_Type_size - prototyping replacement for MPI_Type_size
    Trace the beginning and ending of MPI_Type_size.
*/

  TRACE_PRINTF( "Starting MPI_Type_size..." );
  
  returnVal = PMPI_Type_size( datatype, size );

  TRACE_PRINTF( "Ending MPI_Type_size" );

  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 llrank;

/*
    MPI_Type_struct - prototyping replacement for MPI_Type_struct
    Trace the beginning and ending of MPI_Type_struct.
*/

  TRACE_PRINTF( "Starting MPI_Type_struct..." );

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

  TRACE_PRINTF( "Ending MPI_Type_struct" );

  return returnVal;
}

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

/*
    MPI_Type_ub - prototyping replacement for MPI_Type_ub
    Trace the beginning and ending of MPI_Type_ub.
*/

  TRACE_PRINTF( "Starting MPI_Type_ub..." );

  returnVal = PMPI_Type_ub( datatype, displacement );

  TRACE_PRINTF( "Ending MPI_Type_ub" );

  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 llrank;

/*
    MPI_Type_vector - prototyping replacement for MPI_Type_vector
    Trace the beginning and ending of MPI_Type_vector.
*/

  TRACE_PRINTF( "Starting MPI_Type_vector..." );
  
  returnVal = PMPI_Type_vector( count, blocklen, stride, old_type, newtype );

  TRACE_PRINTF( "Ending MPI_Type_vector" );

  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 llrank;

/*
    MPI_Unpack - prototyping replacement for MPI_Unpack
    Trace the beginning and ending of MPI_Unpack.
*/

  TRACE_PRINTF( "Starting MPI_Unpack..." );
  
  returnVal = PMPI_Unpack( inbuf, insize, position, outbuf, outcount, type, 
			   comm );

  TRACE_PRINTF( "Ending MPI_Unpack" );

  return returnVal;
}

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

/*
    MPI_Wait - prototyping replacement for MPI_Wait
    Trace the beginning and ending of MPI_Wait.
*/

  TRACE_PRINTF( "Starting MPI_Wait..." );
  
  returnVal = PMPI_Wait( request, status );

  TRACE_PRINTF( "Ending MPI_Wait" );

  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 llrank;

/*
    MPI_Waitall - prototyping replacement for MPI_Waitall
    Trace the beginning and ending of MPI_Waitall.
*/

  TRACE_PRINTF( "Starting MPI_Waitall..." );
  
  returnVal = PMPI_Waitall( count, array_of_requests, array_of_statuses );

  TRACE_PRINTF( "Ending MPI_Waitall" );

  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 llrank;

/*
    MPI_Waitany - prototyping replacement for MPI_Waitany
    Trace the beginning and ending of MPI_Waitany.
*/

  TRACE_PRINTF( "Starting MPI_Waitany..." );
  
  returnVal = PMPI_Waitany( count, array_of_requests, index, status );

  TRACE_PRINTF( "Ending MPI_Waitany" );

  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 llrank;

/*
    MPI_Waitsome - prototyping replacement for MPI_Waitsome
    Trace the beginning and ending of MPI_Waitsome.
*/

  TRACE_PRINTF( "Starting MPI_Waitsome..." );
  
  returnVal = PMPI_Waitsome( incount, array_of_requests, outcount, 
			     array_of_indices, array_of_statuses );

  TRACE_PRINTF( "Ending MPI_Waitsome" );

  return returnVal;
}

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

/*
    MPI_Cart_coords - prototyping replacement for MPI_Cart_coords
    Trace the beginning and ending of MPI_Cart_coords.
*/

  TRACE_PRINTF( "Starting MPI_Cart_coords..." );
  
  returnVal = PMPI_Cart_coords( comm, rank, maxdims, coords );

  TRACE_PRINTF( "Ending MPI_Cart_coords" );

  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 llrank;

/*
    MPI_Cart_create - prototyping replacement for MPI_Cart_create
    Trace the beginning and ending of MPI_Cart_create.
*/

  TRACE_PRINTF( "Starting MPI_Cart_create..." );
  
  returnVal = PMPI_Cart_create( comm_old, ndims, dims, periods, reorder, 
				comm_cart );

  TRACE_PRINTF( "Ending MPI_Cart_create" );

  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 llrank;

/*
    MPI_Cart_get - prototyping replacement for MPI_Cart_get
    Trace the beginning and ending of MPI_Cart_get.
*/

  TRACE_PRINTF( "Starting MPI_Cart_get..." );
  
  returnVal = PMPI_Cart_get( comm, maxdims, dims, periods, coords );

  TRACE_PRINTF( "Ending MPI_Cart_get" );

  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 llrank;

/*
    MPI_Cart_map - prototyping replacement for MPI_Cart_map
    Trace the beginning and ending of MPI_Cart_map.
*/

  TRACE_PRINTF( "Starting MPI_Cart_map..." );
  
  returnVal = PMPI_Cart_map( comm_old, ndims, dims, periods, newrank );

  TRACE_PRINTF( "Ending MPI_Cart_map" );

  return returnVal;
}

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

/*
    MPI_Cart_rank - prototyping replacement for MPI_Cart_rank
    Trace the beginning and ending of MPI_Cart_rank.
*/

  TRACE_PRINTF( "Starting MPI_Cart_rank..." );
  
  returnVal = PMPI_Cart_rank( comm, coords, rank );

  TRACE_PRINTF( "Ending MPI_Cart_rank" );

  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 llrank;

/*
    MPI_Cart_shift - prototyping replacement for MPI_Cart_shift
    Trace the beginning and ending of MPI_Cart_shift.
*/

  TRACE_PRINTF( "Starting MPI_Cart_shift..." );
  
  returnVal = PMPI_Cart_shift( comm, direction, displ, source, dest );

  TRACE_PRINTF( "Ending MPI_Cart_shift" );

  return returnVal;
}

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

/*
    MPI_Cart_sub - prototyping replacement for MPI_Cart_sub
    Trace the beginning and ending of MPI_Cart_sub.
*/

  TRACE_PRINTF( "Starting MPI_Cart_sub..." );
  
  returnVal = PMPI_Cart_sub( comm, remain_dims, comm_new );

  TRACE_PRINTF( "Ending MPI_Cart_sub" );

  return returnVal;
}

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

/*
    MPI_Cartdim_get - prototyping replacement for MPI_Cartdim_get
    Trace the beginning and ending of MPI_Cartdim_get.
*/

  TRACE_PRINTF( "Starting MPI_Cartdim_get..." );
  
  returnVal = PMPI_Cartdim_get( comm, ndims );

  TRACE_PRINTF( "Ending MPI_Cartdim_get" );

  return returnVal;
}

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

/*
    MPI_Dims_create - prototyping replacement for MPI_Dims_create
    Trace the beginning and ending of MPI_Dims_create.
*/

  TRACE_PRINTF( "Starting MPI_Dims_create..." );
  
  returnVal = PMPI_Dims_create( nnodes, ndims, dims );

  TRACE_PRINTF( "Ending MPI_Dims_create" );

  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 llrank;

/*
    MPI_Graph_create - prototyping replacement for MPI_Graph_create
    Trace the beginning and ending of MPI_Graph_create.
*/

  TRACE_PRINTF( "Starting MPI_Graph_create..." );
  
  returnVal = PMPI_Graph_create( comm_old, nnodes, index, edges, reorder, 
				 comm_graph );

  TRACE_PRINTF( "Ending MPI_Graph_create" );

  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 llrank;

/*
    MPI_Graph_get - prototyping replacement for MPI_Graph_get
    Trace the beginning and ending of MPI_Graph_get.
*/

  TRACE_PRINTF( "Starting MPI_Graph_get..." );
  
  returnVal = PMPI_Graph_get( comm, maxindex, maxedges, index, edges );

  TRACE_PRINTF( "Ending MPI_Graph_get" );

  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 llrank;

/*
    MPI_Graph_map - prototyping replacement for MPI_Graph_map
    Trace the beginning and ending of MPI_Graph_map.
*/

  TRACE_PRINTF( "Starting MPI_Graph_map..." );
  
  returnVal = PMPI_Graph_map( comm_old, nnodes, index, edges, newrank );

  TRACE_PRINTF( "Ending MPI_Graph_map" );

  return returnVal;
}

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

/*
    MPI_Graph_neighbors - prototyping replacement for MPI_Graph_neighbors
    Trace the beginning and ending of MPI_Graph_neighbors.
*/

  TRACE_PRINTF( "Starting MPI_Graph_neighbors..." );
  
  returnVal = PMPI_Graph_neighbors( comm, rank, maxneighbors, neighbors );

  TRACE_PRINTF( "Ending MPI_Graph_neighbors" );

  return returnVal;
}

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

/*
    MPI_Graph_neighbors_count - prototyping replacement for MPI_Graph_neighbors_count
    Trace the beginning and ending of MPI_Graph_neighbors_count.
*/

  TRACE_PRINTF( "Starting MPI_Graph_neighbors_count..." );
  
  returnVal = PMPI_Graph_neighbors_count( comm, rank, nneighbors );

  TRACE_PRINTF( "Ending MPI_Graph_neighbors_count" );

  return returnVal;
}

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

/*
    MPI_Graphdims_get - prototyping replacement for MPI_Graphdims_get
    Trace the beginning and ending of MPI_Graphdims_get.
*/

  TRACE_PRINTF( "Starting MPI_Graphdims_get..." );
  
  returnVal = PMPI_Graphdims_get( comm, nnodes, nedges );

  TRACE_PRINTF( "Ending MPI_Graphdims_get" );

  return returnVal;
}

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

/*
    MPI_Topo_test - prototyping replacement for MPI_Topo_test
    Trace the beginning and ending of MPI_Topo_test.
*/

  TRACE_PRINTF( "Starting MPI_Topo_test..." );
  
  returnVal = PMPI_Topo_test( comm, top_type );

  TRACE_PRINTF( "Ending MPI_Topo_test" );

  return returnVal;
}