trace_mpi_core.c

fortran并行计算包

/*
   (C) 2001 by Argonne National Laboratory.
       See COPYRIGHT in top-level directory.
*/
#ifdef MPI_BUILD_PROFILING
#undef MPI_BUILD_PROFILING
#endif
#include <stdio.h>
#include "mpe_wrappers_conf.h"
#include "mpi.h"

#if defined(NEEDS_STDLIB_PROTOTYPES)
#include "protofix.h"
#endif

int MPE_Trace_hasBeenInit = 0;
int MPE_Trace_hasBeenFinished = 0;     

#define TRACE_PRINTF(msg) \
if ( (MPE_Trace_hasBeenInit) && (!MPE_Trace_hasBeenFinished) ) {\
  PMPI_Comm_rank( MPI_COMM_WORLD, &llrank ); \
  printf( "[%d] %s\n", llrank, msg ); \
  fflush( stdout ); \
}

/*
   This was originally built with wrappergen, then modified to 
   print out some of the int values.
 */



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

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

  TRACE_PRINTF( "Starting MPI_Allgather..." );

  returnVal = PMPI_Allgather( sendbuf, sendcount, sendtype, recvbuf, 
			      recvcount, recvtype, comm );
  
  TRACE_PRINTF( "Ending MPI_Allgather" );

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

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

  TRACE_PRINTF( "Starting MPI_Allgatherv..." );
  
  returnVal = PMPI_Allgatherv( sendbuf, sendcount, sendtype, recvbuf, 
			       recvcounts, displs, recvtype, comm );

  TRACE_PRINTF( "Ending MPI_Allgatherv" );

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

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

  TRACE_PRINTF( "Starting MPI_Allreduce..." );
  
  returnVal = PMPI_Allreduce( sendbuf, recvbuf, count, datatype, op, comm );

  TRACE_PRINTF( "Ending MPI_Allreduce" );

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

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

  TRACE_PRINTF( "Starting MPI_Alltoall..." );
  
  returnVal = PMPI_Alltoall( sendbuf, sendcount, sendtype, recvbuf, recvcnt, 
			     recvtype, comm );

  TRACE_PRINTF( "Ending MPI_Alltoall" );

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

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

  TRACE_PRINTF( "Starting MPI_Alltoallv..." );
  
  returnVal = PMPI_Alltoallv( sendbuf, sendcnts, sdispls, sendtype, recvbuf, 
			      recvcnts, rdispls, recvtype, comm );

  TRACE_PRINTF( "Ending MPI_Alltoallv" );

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Barrier..." );
  
  returnVal = PMPI_Barrier( comm );

  TRACE_PRINTF( "Ending MPI_Barrier" );

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

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

  TRACE_PRINTF( "Starting MPI_Bcast..." );
  
  returnVal = PMPI_Bcast( buffer, count, datatype, root, comm );

  TRACE_PRINTF( "Ending MPI_Bcast" );

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

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

  TRACE_PRINTF( "Starting MPI_Gather..." );
  
  returnVal = PMPI_Gather( sendbuf, sendcnt, sendtype, recvbuf, recvcount, 
			   recvtype, root, comm );

  TRACE_PRINTF( "Ending MPI_Gather" );

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

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

  TRACE_PRINTF( "Starting MPI_Gatherv..." );
  
  returnVal = PMPI_Gatherv( sendbuf, sendcnt, sendtype, recvbuf, recvcnts, 
			    displs, recvtype, root, comm );

  TRACE_PRINTF( "Ending MPI_Gatherv" );

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Op_create..." );
  
  returnVal = PMPI_Op_create( function, commute, op );

  TRACE_PRINTF( "Ending MPI_Op_create" );

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Op_free..." );

  returnVal = PMPI_Op_free( op );

  TRACE_PRINTF( "Ending MPI_Op_free" );

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

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

  TRACE_PRINTF( "Starting MPI_Reduce_scatter..." );
  
  returnVal = PMPI_Reduce_scatter( sendbuf, recvbuf, recvcnts, datatype, op, 
				   comm );

  TRACE_PRINTF( "Ending MPI_Reduce_scatter" );

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

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

  TRACE_PRINTF( "Starting MPI_Reduce..." );
  
  returnVal = PMPI_Reduce( sendbuf, recvbuf, count, datatype, op, root, comm );

  TRACE_PRINTF( "Ending MPI_Reduce" );

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

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

  TRACE_PRINTF( "Starting MPI_Scan..." );
  
  returnVal = PMPI_Scan( sendbuf, recvbuf, count, datatype, op, comm );

  TRACE_PRINTF( "Ending MPI_Scan" );

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

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

  TRACE_PRINTF( "Starting MPI_Scatter..." );

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

  TRACE_PRINTF( "Ending MPI_Scatter" );

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

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

  TRACE_PRINTF( "Starting MPI_Scatterv..." );
  
  returnVal = PMPI_Scatterv( sendbuf, sendcnts, displs, sendtype, recvbuf, 
			     recvcnt, recvtype, root, comm );
  
  TRACE_PRINTF( "Ending MPI_Scatterv" );

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Attr_delete..." );
  
  returnVal = PMPI_Attr_delete( comm, keyval );

  TRACE_PRINTF( "Ending MPI_Attr_delete..." );

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Attr_get..." );
  
  returnVal = PMPI_Attr_get( comm, keyval, attr_value, flag );

  TRACE_PRINTF( "Ending MPI_Attr_get" );

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Attr_put..." );
  
  returnVal = PMPI_Attr_put( comm, keyval, attr_value );

  TRACE_PRINTF( "Ending MPI_Attr_put" );

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Comm_compare..." );
  
  returnVal = PMPI_Comm_compare( comm1, comm2, result );

  TRACE_PRINTF( "Ending MPI_Comm_compare" );

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Comm_create..." );
  
  returnVal = PMPI_Comm_create( comm, group, comm_out );

  TRACE_PRINTF( "Ending MPI_Comm_create" );

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Comm_dup..." );
  
  returnVal = PMPI_Comm_dup( comm, comm_out );

  TRACE_PRINTF( "Ending MPI_Comm_dup" );

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Comm_free..." );

  returnVal = PMPI_Comm_free( comm );

  TRACE_PRINTF( "Ending MPI_Comm_free" );

  return returnVal;
}

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

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