trace_mpi_core.c

fortran并行计算包

  TRACE_PRINTF( "Starting MPI_Comm_group..." );  
  
  returnVal = PMPI_Comm_group( comm, group );

  TRACE_PRINTF( "Ending MPI_Comm_group" );  

  return returnVal;
}

int   MPI_Comm_rank( comm, rank )
MPI_Comm comm;
int * rank;
{
  int   returnVal;
  int llrank;

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

  TRACE_PRINTF( "Starting MPI_Comm_rank..." );
  
  returnVal = PMPI_Comm_rank( comm, rank );

  TRACE_PRINTF( "Ending MPI_Comm_rank" );    

  return returnVal;
}

int   MPI_Comm_remote_group( comm, group )
MPI_Comm comm;
MPI_Group * group;
{
  int   returnVal;
  int llrank;

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

  TRACE_PRINTF( "Starting MPI_Comm_remote_group..." );  
  
  returnVal = PMPI_Comm_remote_group( comm, group );

  TRACE_PRINTF( "Ending MPI_Comm_remote_group" );  

  return returnVal;
}

int   MPI_Comm_remote_size( comm, size )
MPI_Comm comm;
int * size;
{
  int   returnVal;
  int llrank;

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

  TRACE_PRINTF( "Starting MPI_Comm_remote_size..." );    
  
  returnVal = PMPI_Comm_remote_size( comm, size );

  TRACE_PRINTF( "Ending MPI_Comm_remote_size" );    

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Comm_size..." );      
  
  returnVal = PMPI_Comm_size( comm, size );

  TRACE_PRINTF( "Ending MPI_Comm_size" );      

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

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

  TRACE_PRINTF( "Starting MPI_Comm_split..." );        
  
  returnVal = PMPI_Comm_split( comm, color, key, comm_out );

  TRACE_PRINTF( "Ending MPI_Comm_split" );        

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Comm_test_inter..." );          
  
  returnVal = PMPI_Comm_test_inter( comm, flag );

  TRACE_PRINTF( "Ending MPI_Comm_test_inter" );          

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Group_compare..." );            
  
  returnVal = PMPI_Group_compare( group1, group2, result );

  TRACE_PRINTF( "Ending MPI_Group_compare" );            

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Group_difference..." );              
  
  returnVal = PMPI_Group_difference( group1, group2, group_out );

  TRACE_PRINTF( "Ending MPI_Group_difference" );              

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Group_excl..." );  
  
  returnVal = PMPI_Group_excl( group, n, ranks, newgroup );

  TRACE_PRINTF( "Ending MPI_Group_excl" );  

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Group_free..." );    
  
  returnVal = PMPI_Group_free( group );

  TRACE_PRINTF( "Ending MPI_Group_free" );    

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

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

  TRACE_PRINTF( "Starting MPI_Group_incl..." );      
  
  returnVal = PMPI_Group_incl( group, n, ranks, group_out );

  TRACE_PRINTF( "Ending MPI_Group_incl" );      

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Group_intersection..." );        
  
  returnVal = PMPI_Group_intersection( group1, group2, group_out );

  TRACE_PRINTF( "Ending MPI_Group_intersection" );        

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Group_rank..." );          
  
  returnVal = PMPI_Group_rank( group, rank );

  TRACE_PRINTF( "Ending MPI_Group_rank" );          

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

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

  TRACE_PRINTF( "Starting MPI_Group_range_excl..." );            
  
  returnVal = PMPI_Group_range_excl( group, n, ranges, newgroup );

  TRACE_PRINTF( "Ending MPI_Group_range_excl" );            

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

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

  TRACE_PRINTF( "Starting MPI_Group_range_incl..." );  
  
  returnVal = PMPI_Group_range_incl( group, n, ranges, newgroup );

  TRACE_PRINTF( "Ending MPI_Group_range_incl" );  

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Group_size..." );    
  
  returnVal = PMPI_Group_size( group, size );

  TRACE_PRINTF( "Ending MPI_Group_size" );    

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

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

  TRACE_PRINTF( "Starting MPI_Group_translate_ranks..." );      
  
  returnVal = PMPI_Group_translate_ranks( group_a, n, ranks_a, group_b, 
					  ranks_b );

  TRACE_PRINTF( "Ending MPI_Group_translate_ranks" );      

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Group_union..." );        
  
  returnVal = PMPI_Group_union( group1, group2, group_out );

  TRACE_PRINTF( "Ending MPI_Group_union" );        

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

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

  TRACE_PRINTF( "Starting MPI_Intercomm_create..." );          
  
  returnVal = PMPI_Intercomm_create( local_comm, local_leader, peer_comm, 
				     remote_leader, tag, comm_out );

  TRACE_PRINTF( "Ending MPI_Intercomm_create" );          

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Intercomm_merge..." );            
  
  returnVal = PMPI_Intercomm_merge( comm, high, comm_out );

  TRACE_PRINTF( "Ending MPI_Intercomm_merge" );            

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

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

  TRACE_PRINTF( "Starting MPI_Keyval_create..." );

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

  TRACE_PRINTF( "Ending MPI_Keyval_create" );

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Keyval_free..." );  
  
  returnVal = PMPI_Keyval_free( keyval );

  TRACE_PRINTF( "Ending MPI_Keyval_free" );  

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Abort..." );    
  
  returnVal = PMPI_Abort( comm, errorcode );

  TRACE_PRINTF( "Ending MPI_Abort" );    

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Error_class..." );      
  
  returnVal = PMPI_Error_class( errorcode, errorclass );

  TRACE_PRINTF( "Ending MPI_Error_class" );      

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Errhandler_create..." );        
  
  returnVal = PMPI_Errhandler_create( function, errhandler );

  TRACE_PRINTF( "Ending MPI_Errhandler_create" );        

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Errhandler_free..." );          
  
  returnVal = PMPI_Errhandler_free( errhandler );

  TRACE_PRINTF( "Ending MPI_Errhandler_free" );          

  return returnVal;
}

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

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

  TRACE_PRINTF( "Starting MPI_Errhandler_get..." );            
  
  returnVal = PMPI_Errhandler_get( comm, errhandler );

  TRACE_PRINTF( "Ending MPI_Errhandler_get" );            

  return returnVal;
}

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