include/pch_intf.h

Go to the documentation of this file.

/************************************************************************
File pch_intf.h - interface of the parallel communication library

  pcr_init_parallel - to initialize parallel communication library
  pcr_print_master - to return the id of read/write master processor
  pcr_send_buffer_open - to open a buffer for sending data
  pcr_buffer_pack_int - to pack an array of integers to a buffer
  pcr_buffer_pack_double - to pack an array of doubles to a buffer
  pcr_buffer_pack_char - to pack an array of characters to a buffer
  pcr_buffer_send - to send a buffer to destination processor
  !pcr_buffer_start_send - to start sending a buffer to destination processor
  !pcr_buffer_finish_send - to finish sending a buffer to destination processor
  !pcr_pack_send_int - to pack and send an array of integers
  !pcr_receive_int - to receive an array of integers
  !pcr_pack_send_double - to pack and send an array of doubles 
  !pcr_receive_double - to receive an array of doubles 
  pcr_buffer_bcast - to broadcast the content of a buffer 
  pcr_buffer_receive - to receive a buffer 
  !pcr_buffer_start_receive - to start receiving a buffer
  !pcr_buffer_finish_receive - to finish receiving a buffer 
  pcr_buffer_unpack_int - to unpack an array of integers from a buffer
  pcr_buffer_unpack_double - to unpack an array of doubles from a buffer
  pcr_buffer_unpack_char - to unpack an array of characters from a buffer
  pcr_recv_buffer_close - to close a buffer for receiveing data
  pcr_bcast_double - to broadcast an array of doubles
  pcr_bcast_int - to broadcast an array of integers
  pcr_bcast_char - to broadcast an array of characyers
  pcr_allreduce_sum_int - to reduce (sum) and broadcast an array of integers 
  pcr_allreduce_sum_double - to reduce (sum) and broadcast an array of doubles
  pcr_exit_parallel - to exit parallel communication library
  pcr_barrier - to synchronise paralell execution
  pcr_is_parallel_initialized - to determine wheter parallelism is initialized or not
  pcr_my_proc_id - to get my proc id
  pcr_nr_proc - to get number of all processes
------------------------------              
History:        
10.2012 - Kazimierz Michalik
02.2002 - Krzysztof Banas, initial version      
*************************************************************************/

#ifndef _pch_intf_
#define _pch_intf_

#include "stdint.h"

#ifdef __cplusplus
extern "C"{
#endif

/*** CONSTANTS ***/
extern const int PCC_ANY_PROC; 
extern const int PCC_USE_CURRENT_BUFFER;
extern const int PCC_MASTER_PROC_ID; // We assume that this is the lowest process id.
extern const int PCC_OK; // return code indicating correct execution
extern const int PCC_DEFAULT_BUFFER_SIZE;
extern const int PCC_DEFAULT_COMM;
extern const int PCC_NEIGH_GROUP;
  

/*** GLOBAL VARIABLES ***/
extern int pcv_nr_proc;
extern int pcv_my_proc_id;


/*** FUNCTION DECLARATIONS - headers for external functions ***/

extern int pcr_init_parallel( 
  int* argc,       
  char** argv,     
  char* Work_dir,  
  char *interactive_output_name, 
  FILE **interactive_output_p, 
  int* Nr_pr,      
  int* My_id       
  );

extern int pcr_print_master(
);

extern int pcr_send_buffer_open( 
  int Message_id,  
  int Buffer_size  
  );

extern int pcr_buffer_pack_int( 
  const int Message_id,  
  const int Buffer_id,  
  const int Nr_num,     
  const int* Numbers    
  );

extern int pcr_buffer_pack_double( 
  const int Message_id,  
  const int Buffer_id,  
  const int Nr_num,     
  const double* Numbers 
  );

int pcr_buffer_pack_char( 
  const int Message_id,  
  const int Buffer_id,  
  const int Nr_num,     
  const char* Numbers 
  );

extern int pcr_buffer_send( 
  int Message_id,     
  int Buffer_id,  
  int Dest_proc   
  );


int pcr_buffer_bcast( 
  int Message_id, 
  int Buffer_id,  
  int Sender_proc 
  );

extern int pcr_buffer_receive( 
  int Message_id,   
  int Sender_proc,  
  int Buffer_size 
  );


extern int pcr_buffer_unpack_int( 
  int Message_id,  
  int Buffer_id,  
  int Nr_num,     
  int* Numbers    
  );

extern int pcr_buffer_unpack_double( 
  int Message_id,  
  int Buffer_id,  
  int Nr_num,     
  double* Numbers 
  );

int pcr_buffer_unpack_char( 
  int Message_id,  
  int Buffer_id,  
  int Nr_num,     
  char* Numbers 
  );

extern int pcr_recv_buffer_close( 
  int Message_id,  
  int Buffer_id  
  );

extern int pcr_send_int(
  const int Dest_proc_id, 
  const int Message_id,   
  const int Nr_num,       
  const int *Numbers      
  );

extern int pcr_send_double( 
  const int Dest_proc_id, 
  const int Message_id,   
  const int Nr_num,       
  const double* Numbers   
  );

extern int pcr_receive_int(
  int Sender_proc_id, 
  int Message_id,   
  int Nr_num,       
  int *Numbers      
  );

extern int pcr_receive_double( 
  int Sender_proc_id, 
  int Message_id,   
  int Nr_num,       
  double* Numbers   
  );

extern int pcr_bcast_double(int Sender_proc_id, 
  int Nr_num,       
  double *Numbers   
  );


extern int pcr_bcast_int(
  int Sender_proc_id, 
  int Nr_num,       
  int* Numbers      
  );


extern int pcr_bcast_char( 
  int Sender_proc_id, 
  int Nr_num,       
  char* Numbers      
  );

extern int pcr_allreduce_sum_int(
  const int Nr_num,          
  const int* Numbers,        
  int *Numbers_reduced 
  );



extern int pcr_allreduce_sum_double(
  const int Nr_num,          
  const double* Numbers,        
   double* Numbers_reduced 
  );

extern int pcr_allreduce_max_int(
  const int Nr_num,          
  const int* Numbers,        
  int* Numbers_reduced 
  );



extern int pcr_allreduce_max_double(
  int Nr_num,          
  double* Numbers,        
  double* Numbers_reduced 
  );

extern int pcr_exit_parallel( 
  void
  );

//------------------------------------------------------//
// pcr_barrier - to synchronise parallel execution
//------------------------------------------------------//
extern int pcr_barrier( // returns >=0 - success, <0- error code
  void
);

//------------------------------------------------------//
// pcr_is_parallel_initialized - to determine wheter parallelism is initialized or not
//------------------------------------------------------//
extern int pcr_is_parallel_initialized(  //returns 1 - is initialized, 0 - is NOT initialized
  void
);
  
//------------------------------------------------------//
// pcr_is_this_master - to determine wheter parallelism is initialized or not
//------------------------------------------------------//
extern int pcr_is_this_master( //returns 1 - is master, 0 - is NOT master
  void
);

//------------------------------------------------------//
// pcr_my_proc_id - to get id of current process
//------------------------------------------------------//
extern int pcr_my_proc_id( //returns id of current process
  void
);

//------------------------------------------------------//
// pcr_nr_proc - to get number of all processes  
//------------------------------------------------------//
extern int pcr_nr_proc( //returns number of all process
  void
);

//------------------------------------------------------//
// pcr_allgather_int - gathers together values from a group of processors and distributes to all
//------------------------------------------------------//
extern int pcr_allgather_int( //returns success code
                              const int send_values[],
                              const int n_send_values,
                              int gathered_values[],
                              int n_gathered_values

);

extern int pcr_send_bytes(
  const int Dest_proc_id, 
  const int Message_id,   
  const int Nr_bytes,       
  const uint8_t* Bytes   
  );

extern int pcr_receive_bytes(
  int Sender_proc_id, 
  int Message_id,   
  int Nr_bytes,       
  uint8_t* Bytes      
  );
 
int pcr_buffer_source_id(int Buffer);
 // end of group


#ifdef __cplusplus
}
#endif
  
#endif

---