prof.c

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

  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_Finalize(  )
{
  int returnVal;
  int i;

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

  
  returnVal = PMPI_Finalize(  );


  MPI_Finalize_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, &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;