prof.c

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

  
  printf( "MPI_Buffer_attach is being called.\n" );

  
  returnVal = PMPI_Buffer_attach( buffer, size );


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

  return returnVal;
}

int MPI_Buffer_detach( buffer, size )
void ** buffer ;
int * size ;
{
  int returnVal;
  int i;

  
  printf( "MPI_Buffer_detach is being called.\n" );

  
  returnVal = PMPI_Buffer_detach( buffer, size );


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

  return returnVal;
}

int MPI_Cancel( request )
MPI_Request * request ;
{
  int returnVal;
  int i;

  
  printf( "MPI_Cancel is being called.\n" );

  
  returnVal = PMPI_Cancel( request );


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

  return returnVal;
}

int MPI_Request_free( request )
MPI_Request * request ;
{
  int returnVal;
  int i;

  
  printf( "MPI_Request_free is being called.\n" );

  
  returnVal = PMPI_Request_free( request );


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

  return returnVal;
}

int MPI_Recv_init( buf, count, datatype, source, tag, comm, request )
void * buf ;
int count ;
MPI_Datatype datatype ;
int source ;
int tag ;
MPI_Comm comm ;
MPI_Request * request ;
{
  int returnVal;
  int i;

  
  printf( "MPI_Recv_init is being called.\n" );

  
  returnVal = PMPI_Recv_init( buf, count, datatype, source, tag, comm, request );


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

  return returnVal;
}

int MPI_Send_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 i;

  
  printf( "MPI_Send_init is being called.\n" );

  
  returnVal = PMPI_Send_init( buf, count, datatype, dest, tag, comm, request );


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

  return returnVal;
}

int MPI_Get_elements( status, datatype, elements )
MPI_Status * status ;
MPI_Datatype datatype ;
int * elements ;
{
  int returnVal;
  int i;

  
  printf( "MPI_Get_elements is being called.\n" );

  
  returnVal = PMPI_Get_elements( status, datatype, elements );


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

  return returnVal;
}

int MPI_Get_count( status, datatype, count )
MPI_Status * status ;
MPI_Datatype datatype ;
int * count ;
{
  int returnVal;
  int i;

  
  printf( "MPI_Get_count is being called.\n" );

  
  returnVal = PMPI_Get_count( status, datatype, count );


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

  return returnVal;
}

int MPI_Ibsend( 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 i;

  
  printf( "MPI_Ibsend is being called.\n" );

  
  returnVal = PMPI_Ibsend( buf, count, datatype, dest, tag, comm, request );


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

  return returnVal;
}

int MPI_Iprobe( source, tag, comm, flag, status )
int source ;
int tag ;
MPI_Comm comm ;
int * flag ;
MPI_Status * status ;
{
  int returnVal;
  int i;

  
  printf( "MPI_Iprobe is being called.\n" );

  
  returnVal = PMPI_Iprobe( source, tag, comm, flag, status );


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

  return returnVal;
}

int MPI_Irecv( buf, count, datatype, source, tag, comm, request )
void * buf ;
int count ;
MPI_Datatype datatype ;
int source ;
int tag ;
MPI_Comm comm ;
MPI_Request * request ;
{
  int returnVal;
  int i;

  
  printf( "MPI_Irecv is being called.\n" );

  
  returnVal = PMPI_Irecv( buf, count, datatype, source, tag, comm, request );


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

  return returnVal;
}

int MPI_Irsend( 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 i;

  
  printf( "MPI_Irsend is being called.\n" );

  
  returnVal = PMPI_Irsend( buf, count, datatype, dest, tag, comm, request );


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

  return returnVal;
}

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;
  int i;
  double i1;
  int typesize;

  
  printf( "MPI_Isend is being called.\n" );

  
  
  

  
  returnVal = PMPI_Isend( buf, count, datatype, dest, tag, comm, request );


  MPI_Type_size( datatype, &typesize );
  MPE_Log_send( dest, tag, typesize*count );
  printf( "first argument is buf and i1 went unused (%lf)\n", i1 );
  MPI_Isend_nsends_0++;



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

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

  
  printf( "MPI_Issend is being called.\n" );

  
  returnVal = PMPI_Issend( buf, count, datatype, dest, tag, comm, request );


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

  return returnVal;
}

int MPI_Pack( inbuf, incount, type, outbuf, outcount, position, comm )
void * inbuf ;
int incount ;
MPI_Datatype type ;
void * outbuf ;
int outcount ;
int * position ;
MPI_Comm comm ;
{
  int returnVal;
  int i;

  
  printf( "MPI_Pack is being called.\n" );

  
  returnVal = PMPI_Pack( inbuf, incount, type, outbuf, outcount, position, comm );


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

  return returnVal;
}

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

  
  printf( "MPI_Pack_size is being called.\n" );

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


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

  return returnVal;
}

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

  
  printf( "MPI_Probe is being called.\n" );

  
  returnVal = PMPI_Probe( source, tag, comm, status );


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

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

  
  printf( "MPI_Recv is being called.\n" );

  
  returnVal = PMPI_Recv( buf, count, datatype, source, tag, comm, status );


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

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

  
  printf( "MPI_Rsend is being called.\n" );

  
  returnVal = PMPI_Rsend( buf, count, datatype, dest, tag, comm );


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

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

  
  printf( "MPI_Rsend_init is being called.\n" );

  
  returnVal = PMPI_Rsend_init( buf, count, datatype, dest, tag, comm, request );


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

  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 i;
  double i1;
  int typesize;

  
  printf( "MPI_Send is being called.\n" );

  
  
  

  
  returnVal = PMPI_Send( buf, count, datatype, dest, tag, comm );


  MPI_Type_size( datatype, &typesize );
  MPE_Log_send( dest, tag, typesize*count );
  printf( "first argument is buf and i1 went unused (%lf)\n", i1 );
  MPI_Send_nsends_0++;



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

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

  
  printf( "MPI_Sendrecv is being called.\n" );

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


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

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

  
  printf( "MPI_Sendrecv_replace is being called.\n" );

  
  returnVal = PMPI_Sendrecv_replace( buf, count, datatype, dest, sendtag, source, recvtag, comm, status );


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

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

  
  printf( "MPI_Ssend is being called.\n" );

  
  returnVal = PMPI_Ssend( buf, count, datatype, dest, tag, comm );


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

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

  
  printf( "MPI_Ssend_init is being called.\n" );

  
  returnVal = PMPI_Ssend_init( buf, count, datatype, dest, tag, comm, request );


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

  return returnVal;
}

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

  
  printf( "MPI_Start is being called.\n" );

  
  returnVal = PMPI_Start( request );


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

  return returnVal;
}

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

  
  printf( "MPI_Startall is being called.\n" );

  
  returnVal = PMPI_Startall( count, array_of_requests );


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

  return returnVal;
}

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

  
  printf( "MPI_Test is being called.\n" );

  
  returnVal = PMPI_Test( request, flag, status );


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

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

  
  printf( "MPI_Testall is being called.\n" );

  
  returnVal = PMPI_Testall( count, array_of_requests, flag, array_of_statuses );


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

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

  
  printf( "MPI_Testany is being called.\n" );

  
  returnVal = PMPI_Testany( count, array_of_requests, index, flag, status );


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

  return returnVal;
}

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

  
  printf( "MPI_Test_cancelled is being called.\n" );

  
  returnVal = PMPI_Test_cancelled( status, flag );


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

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

  
  printf( "MPI_Testsome is being called.\n" );