trace_mpi_core.c

fortran并行计算包

  TRACE_PRINTF( "Starting MPI_Pack..." );
  
  returnVal = PMPI_Pack( inbuf, incount, type, outbuf, outcount, position, 
			 comm );

  TRACE_PRINTF( "Ending MPI_Pack" );

  return returnVal;
}

int   MPI_Pack_size( incount, datatype, comm, size )
int incount;
MPI_Datatype datatype;
MPI_Comm comm;
int * size;
{
  int   returnVal;
  int llrank;

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

  TRACE_PRINTF( "Starting MPI_Pack_size..." );  

  returnVal = PMPI_Pack_size( incount, datatype, comm, size );

  TRACE_PRINTF( "Ending MPI_Pack_size" );  

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Probe..." );    
  
  returnVal = PMPI_Probe( source, tag, comm, status );

  TRACE_PRINTF( "Ending MPI_Probe" );    

  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;
  int  llrank;
  char msg[100];

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

  sprintf( msg, "Starting MPI_Recv with count = %d, source = %d, tag = %d...", 
	   count, source, tag );
  TRACE_PRINTF( msg );
  
  returnVal = PMPI_Recv( buf, count, datatype, source, tag, comm, status );

  sprintf( msg, "Ending MPI_Recv from %d with tag %d", 
	   status->MPI_SOURCE, status->MPI_TAG ); 
  TRACE_PRINTF( msg );

  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;
  int  llrank;
  char msg[100];

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

  sprintf( msg, "Starting MPI_Rsend with count = %d, dest = %d, tag = %d...", 
	   count, dest, tag );
  TRACE_PRINTF( msg );
  
  returnVal = PMPI_Rsend( buf, count, datatype, dest, tag, comm );

  TRACE_PRINTF( "Ending MPI_Rsend" );

  return returnVal;
}

int  MPI_Rsend_init( 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;
  int  llrank;
  char msg[100];

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

  sprintf( msg, "Starting MPI_Rsend_init with count = %d, dest = %d, tag = %d...", count, dest, tag );
  TRACE_PRINTF( msg );
  
  returnVal = PMPI_Rsend_init( buf, count, datatype, dest, tag, comm, 
			       request );

  TRACE_PRINTF( "Ending MPI_Rsend_init" );

  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;
  int  llrank;
  char msg[100];

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

  sprintf( msg, "Starting MPI_Send with count = %d, dest = %d, tag = %d...", 
	   count, dest, tag );
  TRACE_PRINTF( msg );
  
  returnVal = PMPI_Send( buf, count, datatype, dest, tag, comm );

  TRACE_PRINTF( "Ending MPI_Send" );

  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;
  int  llrank;
  char msg[100];

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

  sprintf( msg, "Starting MPI_Sendrecv with sendtag %d, recvtag %d, dest %d, source %d ...", sendtag, recvtag, dest, source );
  TRACE_PRINTF( msg );

  returnVal = PMPI_Sendrecv( sendbuf, sendcount, sendtype, dest, sendtag, 
			     recvbuf, recvcount, recvtype, source, recvtag, 
			     comm, status );

  TRACE_PRINTF( "Ending MPI_Sendrecv" );

  return returnVal;
}

int  MPI_Sendrecv_replace( buf, count, datatype, dest, sendtag, source, recvtag, comm, status )
void * buf;
int count;
MPI_Datatype datatype;
int dest;
int sendtag;
int source;
int recvtag;
MPI_Comm comm;
MPI_Status * status;
{
  int  returnVal;
  int  llrank;
  char msg[100];

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

  sprintf( msg, "Starting MPI_Sendrecv_replace with sendtag %d, recvtag %d, dest %d, source %d ...", sendtag, recvtag, dest, source );
  TRACE_PRINTF( msg );
  
  returnVal = PMPI_Sendrecv_replace( buf, count, datatype, dest, sendtag, 
				     source, recvtag, comm, status );

  TRACE_PRINTF( "Ending MPI_Sendrecv_replace" );

  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;
  int  llrank;
  char msg[100];

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

  sprintf( msg, "Starting MPI_Ssend with count = %d, dest = %d, tag = %d...",
	   count, dest, tag );
  TRACE_PRINTF( msg );
  
  returnVal = PMPI_Ssend( buf, count, datatype, dest, tag, comm );

  TRACE_PRINTF( "Ending MPI_Ssend" );

  return returnVal;
}

int  MPI_Ssend_init( 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;
  int  llrank;
  char msg[100];

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

  sprintf( msg, "Starting MPI_Ssend_init with count = %d, dest = %d, tag = %d...", count, dest, tag );
  TRACE_PRINTF( msg );
  
  returnVal = PMPI_Ssend_init( buf, count, datatype, dest, tag, comm, 
			       request );

  TRACE_PRINTF( "Ending MPI_Ssend_init" );

  return returnVal;
}

int  MPI_Start( request )
MPI_Request * request;
{
  int  returnVal;
  int llrank;

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

  TRACE_PRINTF( "Starting MPI_Start..." );
  
  returnVal = PMPI_Start( request );

  TRACE_PRINTF( "Ending MPI_Start" );

  return returnVal;
}

int  MPI_Startall( count, array_of_requests )
int count;
MPI_Request * array_of_requests;
{
  int  returnVal;
  int llrank;

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

  TRACE_PRINTF( "Starting MPI_Startall..." );  
  
  returnVal = PMPI_Startall( count, array_of_requests );

  TRACE_PRINTF( "Ending MPI_Startall" );  

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Test..." );    
  
  returnVal = PMPI_Test( request, flag, status );

  TRACE_PRINTF( "Ending MPI_Test" );    

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

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

  TRACE_PRINTF( "Starting MPI_Testall..." );
  
  returnVal = PMPI_Testall( count, array_of_requests, flag, 
			    array_of_statuses );

  TRACE_PRINTF( "Ending MPI_Testall" );      

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

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

  TRACE_PRINTF( "Starting MPI_Testany..." );  
  
  returnVal = PMPI_Testany( count, array_of_requests, index, flag, status );

  TRACE_PRINTF( "Ending MPI_Testany" );  

  return returnVal;
}

int  MPI_Test_cancelled( status, flag )
MPI_Status * status;
int * flag;
{
  int  returnVal;
  int llrank;

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

  TRACE_PRINTF( "Starting MPI_Test_cancelled..." );    
  
  returnVal = PMPI_Test_cancelled( status, flag );

  TRACE_PRINTF( "Ending MPI_Test_cancelled" );    

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

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

  TRACE_PRINTF( "Starting MPI_Testsome..." );
  
  returnVal = PMPI_Testsome( incount, array_of_requests, outcount, 
			     array_of_indices, array_of_statuses );

  TRACE_PRINTF( "Ending MPI_Testsome" );      

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Type_commit..." );

  returnVal = PMPI_Type_commit( datatype );

  TRACE_PRINTF( "Ending MPI_Type_commit" );
    
  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Type_contiguous..." );

  returnVal = PMPI_Type_contiguous( count, old_type, newtype );
    
  TRACE_PRINTF( "Ending MPI_Type_contiguous" );

  return returnVal;

}

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

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

  TRACE_PRINTF( "Starting MPI_Type_extent..." );
  
  returnVal = PMPI_Type_extent( datatype, extent );

  TRACE_PRINTF( "Ending MPI_Type_extent" );  

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Type_free..." );
  
  returnVal = PMPI_Type_free( datatype );

  TRACE_PRINTF( "Ending MPI_Type_free" );  

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

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

  TRACE_PRINTF( "Starting MPI_Type_hindexed..." );
  
  returnVal = PMPI_Type_hindexed( count, blocklens, indices, old_type, 
				  newtype );

  TRACE_PRINTF( "Ending MPI_Type_hindexed" );  

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

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

  TRACE_PRINTF( "Starting MPI_Type_hvector..." );
  
  returnVal = PMPI_Type_hvector( count, blocklen, stride, old_type, newtype );

  TRACE_PRINTF( "Ending MPI_Type_hvector" );  

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

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

  TRACE_PRINTF( "Starting MPI_Type_indexed..." );
  
  returnVal = PMPI_Type_indexed( count, blocklens, indices, old_type, 
				 newtype );

  TRACE_PRINTF( "Ending MPI_Type_indexed" );