sample.c

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

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

  return returnVal;
}

int   MPI_Comm_size( comm, size )
MPI_Comm comm;
int * size;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Comm_size( comm, size );


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

  return returnVal;
}

int   MPI_Comm_split( comm, color, key, comm_out )
MPI_Comm comm;
int color;
int key;
MPI_Comm * comm_out;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Comm_split( comm, color, key, comm_out );


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

  return returnVal;
}

int   MPI_Comm_test_inter( comm, flag )
MPI_Comm comm;
int * flag;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Comm_test_inter( comm, flag );


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

  return returnVal;
}

int   MPI_Group_compare( group1, group2, result )
MPI_Group group1;
MPI_Group group2;
int * result;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Group_compare( group1, group2, result );


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

  return returnVal;
}

int   MPI_Group_difference( group1, group2, group_out )
MPI_Group group1;
MPI_Group group2;
MPI_Group * group_out;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Group_difference( group1, group2, group_out );


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

  return returnVal;
}

int   MPI_Group_excl( group, n, ranks, newgroup )
MPI_Group group;
int n;
int * ranks;
MPI_Group * newgroup;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Group_excl( group, n, ranks, newgroup );


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

  return returnVal;
}

int   MPI_Group_free( group )
MPI_Group * group;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Group_free( group );


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

  return returnVal;
}

int   MPI_Group_incl( group, n, ranks, group_out )
MPI_Group group;
int n;
int * ranks;
MPI_Group * group_out;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Group_incl( group, n, ranks, group_out );


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

  return returnVal;
}

int   MPI_Group_intersection( group1, group2, group_out )
MPI_Group group1;
MPI_Group group2;
MPI_Group * group_out;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Group_intersection( group1, group2, group_out );


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

  return returnVal;
}

int   MPI_Group_rank( group, rank )
MPI_Group group;
int * rank;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Group_rank( group, rank );


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

  return returnVal;
}

int   MPI_Group_range_excl( group, n, ranges, newgroup )
MPI_Group group;
int n;
int ranges[][3];
MPI_Group * newgroup;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Group_range_excl( group, n, ranges, newgroup );


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

  return returnVal;
}

int   MPI_Group_range_incl( group, n, ranges, newgroup )
MPI_Group group;
int n;
int ranges[][3];
MPI_Group * newgroup;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Group_range_incl( group, n, ranges, newgroup );


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

  return returnVal;
}

int   MPI_Group_size( group, size )
MPI_Group group;
int * size;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Group_size( group, size );


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

  return returnVal;
}

int   MPI_Group_translate_ranks( group_a, n, ranks_a, group_b, ranks_b )
MPI_Group group_a;
int n;
int * ranks_a;
MPI_Group group_b;
int * ranks_b;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Group_translate_ranks( group_a, n, ranks_a, group_b, ranks_b );


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

  return returnVal;
}

int   MPI_Group_union( group1, group2, group_out )
MPI_Group group1;
MPI_Group group2;
MPI_Group * group_out;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Group_union( group1, group2, group_out );


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

  return returnVal;
}

int   MPI_Intercomm_create( local_comm, local_leader, peer_comm, remote_leader, tag, comm_out )
MPI_Comm local_comm;
int local_leader;
MPI_Comm peer_comm;
int remote_leader;
int tag;
MPI_Comm * comm_out;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Intercomm_create( local_comm, local_leader, peer_comm, remote_leader, tag, comm_out );


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

  return returnVal;
}

int   MPI_Intercomm_merge( comm, high, comm_out )
MPI_Comm comm;
int high;
MPI_Comm * comm_out;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Intercomm_merge( comm, high, comm_out );


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

  return returnVal;
}

int   MPI_Keyval_create( copy_fn, delete_fn, keyval, extra_state )
MPI_Copy_function * copy_fn;
MPI_Delete_function * delete_fn;
int * keyval;
void * extra_state;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Keyval_create( copy_fn, delete_fn, keyval, extra_state );


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

  return returnVal;
}

int   MPI_Keyval_free( keyval )
int * keyval;
{
  int   returnVal;
  int i;

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

  
  returnVal = PMPI_Keyval_free( keyval );


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

  return returnVal;
}

int  MPI_Abort( comm, errorcode )
MPI_Comm comm;
int errorcode;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Abort( comm, errorcode );


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

  return returnVal;
}

int  MPI_Error_class( errorcode, errorclass )
int errorcode;
int * errorclass;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Error_class( errorcode, errorclass );


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

  return returnVal;
}

int  MPI_Errhandler_create( function, errhandler )
MPI_Handler_function * function;
MPI_Errhandler * errhandler;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Errhandler_create( function, errhandler );


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

  return returnVal;
}

int  MPI_Errhandler_free( errhandler )
MPI_Errhandler * errhandler;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Errhandler_free( errhandler );


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

  return returnVal;
}

int  MPI_Errhandler_get( comm, errhandler )
MPI_Comm comm;
MPI_Errhandler * errhandler;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Errhandler_get( comm, errhandler );


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

  return returnVal;
}

int  MPI_Error_string( errorcode, string, resultlen )
int errorcode;
char * string;
int * resultlen;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Error_string( errorcode, string, resultlen );


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

  return returnVal;
}

int  MPI_Errhandler_set( comm, errhandler )
MPI_Comm comm;
MPI_Errhandler errhandler;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Errhandler_set( comm, errhandler );


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

  return returnVal;
}

int  MPI_Get_processor_name( name, resultlen )
char * name;
int * resultlen;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Get_processor_name( name, resultlen );


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

  return returnVal;
}

int  MPI_Init( argc, argv )
int * argc;
char *** argv;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Init( argc, argv );


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

  return returnVal;
}

int  MPI_Initialized( flag )
int * flag;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Initialized( flag );


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

  return returnVal;
}

double  MPI_Wtick(  )
{
  double  returnVal;
  int i;

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

  
  returnVal = PMPI_Wtick(  );


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

  return returnVal;
}

double  MPI_Wtime(  )
{
  double  returnVal;
  int i;

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

  
  returnVal = PMPI_Wtime(  );


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

  return returnVal;
}

int  MPI_Address( location, address )
void * location;
MPI_Aint * address;
{
  int  returnVal;
  int i;

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

  
  returnVal = PMPI_Address( location, address );


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

  return returnVal;
}

int  MPI_Bsend( 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_Bsend is being called.\n" );

  
  
  

  
  returnVal = PMPI_Bsend( 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_Bsend_nsends_0++;



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

  return returnVal;
}

int  MPI_Bsend_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_Bsend_init is being called.\n" );

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


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

  return returnVal;
}

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

  
  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;