sample.c

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

}

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, (MPI_Aint *)&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, (MPI_Aint *)&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" );

  
  returnVal = PMPI_Testsome( incount, array_of_requests, outcount, array_of_indices, array_of_statuses );


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