log_wrappers.c

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

int  MPI_Isend( buf, count, datatype, dest, tag, comm, request )
void * buf;
int count;
MPI_Datatype datatype;
int dest;
int tag;
MPI_Comm comm;
MPI_Request * request;
{
  int  returnVal;

/*
    MPI_Isend - prototyping replacement for MPI_Isend
    Log the beginning and ending of the time spent in MPI_Isend calls.
*/

  ++MPI_Isend_ncalls_0;
  MPE_Log_event( MPI_Isend_stateid_0*2,
	         MPI_Isend_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Isend( buf, count, datatype, dest, tag, comm, request );

  MPE_Log_event( MPI_Isend_stateid_0*2+1,
	         MPI_Isend_ncalls_0, (char *)0 );


  return returnVal;
}

int  MPI_Issend( buf, count, datatype, dest, tag, comm, request )
void * buf;
int count;
MPI_Datatype datatype;
int dest;
int tag;
MPI_Comm comm;
MPI_Request * request;
{
  int  returnVal;

/*
    MPI_Issend - prototyping replacement for MPI_Issend
    Log the beginning and ending of the time spent in MPI_Issend calls.
*/

  ++MPI_Issend_ncalls_0;
  MPE_Log_event( MPI_Issend_stateid_0*2,
	         MPI_Issend_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Issend( buf, count, datatype, dest, tag, comm, request );

  MPE_Log_event( MPI_Issend_stateid_0*2+1,
	         MPI_Issend_ncalls_0, (char *)0 );


  return returnVal;
}

int  MPI_Probe( source, tag, comm, status )
int source;
int tag;
MPI_Comm comm;
MPI_Status * status;
{
  int  returnVal;

/*
    MPI_Probe - prototyping replacement for MPI_Probe
    Log the beginning and ending of the time spent in MPI_Probe calls.
*/

  ++MPI_Probe_ncalls_0;
  MPE_Log_event( MPI_Probe_stateid_0*2,
	         MPI_Probe_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Probe( source, tag, comm, status );

  MPE_Log_event( MPI_Probe_stateid_0*2+1,
	         MPI_Probe_ncalls_0, (char *)0 );


  return returnVal;
}

int  MPI_Recv( buf, count, datatype, source, tag, comm, status )
void * buf;
int count;
MPI_Datatype datatype;
int source;
int tag;
MPI_Comm comm;
MPI_Status * status;
{
  int  returnVal;

/*
    MPI_Recv - prototyping replacement for MPI_Recv
    Log the beginning and ending of the time spent in MPI_Recv calls.
*/

  ++MPI_Recv_ncalls_0;
  MPE_Log_event( MPI_Recv_stateid_0*2,
	         MPI_Recv_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Recv( buf, count, datatype, source, tag, comm, status );

  MPE_Log_event( MPI_Recv_stateid_0*2+1,
	         MPI_Recv_ncalls_0, (char *)0 );


  return returnVal;
}

int  MPI_Rsend( buf, count, datatype, dest, tag, comm )
void * buf;
int count;
MPI_Datatype datatype;
int dest;
int tag;
MPI_Comm comm;
{
  int  returnVal;

/*
    MPI_Rsend - prototyping replacement for MPI_Rsend
    Log the beginning and ending of the time spent in MPI_Rsend calls.
*/

  ++MPI_Rsend_ncalls_0;
  MPE_Log_event( MPI_Rsend_stateid_0*2,
	         MPI_Rsend_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Rsend( buf, count, datatype, dest, tag, comm );

  MPE_Log_event( MPI_Rsend_stateid_0*2+1,
	         MPI_Rsend_ncalls_0, (char *)0 );


  return returnVal;
}

int  MPI_Send( buf, count, datatype, dest, tag, comm )
void * buf;
int count;
MPI_Datatype datatype;
int dest;
int tag;
MPI_Comm comm;
{
  int  returnVal;

/*
    MPI_Send - prototyping replacement for MPI_Send
    Log the beginning and ending of the time spent in MPI_Send calls.
*/

  ++MPI_Send_ncalls_0;
  MPE_Log_event( MPI_Send_stateid_0*2,
	         MPI_Send_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Send( buf, count, datatype, dest, tag, comm );

  MPE_Log_event( MPI_Send_stateid_0*2+1,
	         MPI_Send_ncalls_0, (char *)0 );


  return returnVal;
}

int  MPI_Sendrecv( sendbuf, sendcount, sendtype, dest, sendtag, recvbuf, recvcount, recvtype, source, recvtag, comm, status )
void * sendbuf;
int sendcount;
MPI_Datatype sendtype;
int dest;
int sendtag;
void * recvbuf;
int recvcount;
MPI_Datatype recvtype;
int source;
int recvtag;
MPI_Comm comm;
MPI_Status * status;
{
  int  returnVal;

/*
    MPI_Sendrecv - prototyping replacement for MPI_Sendrecv
    Log the beginning and ending of the time spent in MPI_Sendrecv calls.
*/

  ++MPI_Sendrecv_ncalls_0;
  MPE_Log_event( MPI_Sendrecv_stateid_0*2,
	         MPI_Sendrecv_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Sendrecv( sendbuf, sendcount, sendtype, dest, sendtag, recvbuf, recvcount, recvtype, source, recvtag, comm, status );

  MPE_Log_event( MPI_Sendrecv_stateid_0*2+1,
	         MPI_Sendrecv_ncalls_0, (char *)0 );


  return returnVal;
}

int  MPI_Ssend( buf, count, datatype, dest, tag, comm )
void * buf;
int count;
MPI_Datatype datatype;
int dest;
int tag;
MPI_Comm comm;
{
  int  returnVal;

/*
    MPI_Ssend - prototyping replacement for MPI_Ssend
    Log the beginning and ending of the time spent in MPI_Ssend calls.
*/

  ++MPI_Ssend_ncalls_0;
  MPE_Log_event( MPI_Ssend_stateid_0*2,
	         MPI_Ssend_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Ssend( buf, count, datatype, dest, tag, comm );

  MPE_Log_event( MPI_Ssend_stateid_0*2+1,
	         MPI_Ssend_ncalls_0, (char *)0 );


  return returnVal;
}

int   MPI_Test( request, flag, status )
MPI_Request * request;
int * flag;
MPI_Status * status;
{
  int   returnVal;

/*
    MPI_Test - prototyping replacement for MPI_Test
    Log the beginning and ending of the time spent in MPI_Test calls.
*/

  ++MPI_Test_ncalls_0;
  MPE_Log_event( MPI_Test_stateid_0*2,
	         MPI_Test_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Test( request, flag, status );

  MPE_Log_event( MPI_Test_stateid_0*2+1,
	         MPI_Test_ncalls_0, (char *)0 );


  return returnVal;
}

int  MPI_Testall( count, array_of_requests, flag, array_of_statuses )
int count;
MPI_Request * array_of_requests;
int * flag;
MPI_Status * array_of_statuses;
{
  int  returnVal;

/*
    MPI_Testall - prototyping replacement for MPI_Testall
    Log the beginning and ending of the time spent in MPI_Testall calls.
*/

  ++MPI_Testall_ncalls_0;
  MPE_Log_event( MPI_Testall_stateid_0*2,
	         MPI_Testall_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Testall( count, array_of_requests, flag, array_of_statuses );

  MPE_Log_event( MPI_Testall_stateid_0*2+1,
	         MPI_Testall_ncalls_0, (char *)0 );


  return returnVal;
}

int  MPI_Testany( count, array_of_requests, index, flag, status )
int count;
MPI_Request * array_of_requests;
int * index;
int * flag;
MPI_Status * status;
{
  int  returnVal;

/*
    MPI_Testany - prototyping replacement for MPI_Testany
    Log the beginning and ending of the time spent in MPI_Testany calls.
*/

  ++MPI_Testany_ncalls_0;
  MPE_Log_event( MPI_Testany_stateid_0*2,
	         MPI_Testany_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Testany( count, array_of_requests, index, flag, status );

  MPE_Log_event( MPI_Testany_stateid_0*2+1,
	         MPI_Testany_ncalls_0, (char *)0 );


  return returnVal;
}

int  MPI_Testsome( 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;

/*
    MPI_Testsome - prototyping replacement for MPI_Testsome
    Log the beginning and ending of the time spent in MPI_Testsome calls.
*/

  ++MPI_Testsome_ncalls_0;
  MPE_Log_event( MPI_Testsome_stateid_0*2,
	         MPI_Testsome_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Testsome( incount, array_of_requests, outcount, array_of_indices, array_of_statuses );

  MPE_Log_event( MPI_Testsome_stateid_0*2+1,
	         MPI_Testsome_ncalls_0, (char *)0 );


  return returnVal;
}

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

/*
    MPI_Wait - prototyping replacement for MPI_Wait
    Log the beginning and ending of the time spent in MPI_Wait calls.
*/

  ++MPI_Wait_ncalls_0;
  MPE_Log_event( MPI_Wait_stateid_0*2,
	         MPI_Wait_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Wait( request, status );

  MPE_Log_event( MPI_Wait_stateid_0*2+1,
	         MPI_Wait_ncalls_0, (char *)0 );


  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;

/*
    MPI_Waitall - prototyping replacement for MPI_Waitall
    Log the beginning and ending of the time spent in MPI_Waitall calls.
*/

  ++MPI_Waitall_ncalls_0;
  MPE_Log_event( MPI_Waitall_stateid_0*2,
	         MPI_Waitall_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Waitall( count, array_of_requests, array_of_statuses );

  MPE_Log_event( MPI_Waitall_stateid_0*2+1,
	         MPI_Waitall_ncalls_0, (char *)0 );


  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;

/*
    MPI_Waitany - prototyping replacement for MPI_Waitany
    Log the beginning and ending of the time spent in MPI_Waitany calls.
*/

  ++MPI_Waitany_ncalls_0;
  MPE_Log_event( MPI_Waitany_stateid_0*2,
	         MPI_Waitany_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Waitany( count, array_of_requests, index, status );

  MPE_Log_event( MPI_Waitany_stateid_0*2+1,
	         MPI_Waitany_ncalls_0, (char *)0 );


  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;

/*
    MPI_Waitsome - prototyping replacement for MPI_Waitsome
    Log the beginning and ending of the time spent in MPI_Waitsome calls.
*/

  ++MPI_Waitsome_ncalls_0;
  MPE_Log_event( MPI_Waitsome_stateid_0*2,
	         MPI_Waitsome_ncalls_0, (char *)0 );
  
  returnVal = PMPI_Waitsome( incount, array_of_requests, outcount, array_of_indices, array_of_statuses );

  MPE_Log_event( MPI_Waitsome_stateid_0*2+1,
	         MPI_Waitsome_ncalls_0, (char *)0 );


  return returnVal;
}