---

total_order_channel.h

Go to the documentation of this file.

/**********************************************************************************************/
/*************************** TOTAL ORDER CHANNEL CLASS  *************************/
/**************************** Jean FANCHON. LAAS-CNRS*************************/
/**********************************************************************************************/


#include "no_prop_channel.h"

/********************************************************************/  
/********************************************************************/

struct member {
        
                int ident;
                
                int nodeid;
                
                int port;
                
        };
 
class group_admin {  

/********************************************************************/  

public: 
        group_admin() ; 
        
        int init_members_list(char * file) ;
        
        int add_member( int , int , int ) ;
        
        int del_member( int ) ;

        int host_number(int ) ;
        
        int port_number(int );  

        int groupsize;
                
        struct member  members_list[MAX_MEMBER];
                
#define MEMBSZ   sizeof(struct member)  

} ;
/********************************************************************/  
/********************************************************************/
 
class total_order_channel {  // : public channel, channeluser { 

/********************************************************************/  
/*interface*/ 

public: 
        total_order_channel(int , char *, char *); 

        int deliver ( char *, int);        // from network 
        
        int broadcast ( char *, int );  // from application
                
        void * phase_code(void *);      //Phase thread code


private:
        
        no_prop_channel * net;                  // the no-prop channel UDP
        
        pthread_t phase_thread;         //Phase thread structure        
        
/********************************************************************/  
/*local state*/ 

        int status ; /* initialisation, running or ending */
                
        int curphase;
        
        int grsize;
        
        int total_sent;
        
#define START   0       // waiting for channel information 
#define PRERUN  1       // initialising 
#define RUN     2       // running
/* #define      SYNC    3        resynchronising */
#define ERROR   4       // unexpected (!!) situation 
#define STOP    5       // waiting for group close confirmation 
#define END     6       // after group close confirmation  


/********************************************************************/  
/*******************   Group data *******************/  

        group_admin  *my_group; 
        
        char ipadd[15];
            
        int    my_ident;                //local member ident
                
/********************************************************************/  
/******************* messages data *******************/

        typedef struct {

                char *data;
                int size;
        
        } msgtype ;
                
        msgtype *current , *previous;   

/********************************************************************/  
/******************* message header structure*******************/ 
        
        typedef struct {

                int sender;             //ident of the sender 

                int num_phase;          //phase number

                int type;               //

                int size;               //

        } header; 

#define  HEADSZ sizeof(header)

/********** Definition of message types  ************************/

#define NEW     1       // new member demand, (one destination)
#define INIT    2       // channel parameters (ident, grsize etc ..)
#define MESS    3       // application message 
#define CMD     4       // JOIN, QUIT 
#define ACK     5       // empty message
#define NACK    6       // multicasted to late senders
#define FAULT   7       // list of faulty idents 

/********************************************************************/  
/******************* INIT message structure*******************/ 

        typedef struct {
        
                int ident;
                
                int groupsize;
                
                int phase; 
                
        } initheader;
        
#define INHEADSZ sizeof(initheader)

/******************* init message *******************/ 

        msgtype init_message;
        union  {        
                struct  {       
                        header head;
                        initheader ihead;
                } head;
                char buf[400];
                        
        } init_buf ;

/********************************************************************/  
/******************* CMD message structure ***********************/ 

        typedef struct {
        
                int type ;  // JOIN or QUIT 
                
                int ident;
                
                int nodeid;
                
                int port;
                
        } cmdheader;
        
#define CMHEADSZ sizeof(cmdheader)
                
/******************* cmd (join/quit) message *******************/ 

        msgtype cmd_message;
        union {
                struct {        
                        header head;
                        cmdheader chead;
                } head;
                char buf[100];                          
        } cmd_buf ;
        
#define JOIN 1
#define QUIT 2

/********************************************************************/  
/******************* ack message *******************/

        header empty_message_header;

/********************************************************************/  
/******************* fault message *******************/

        msgtype fault_message;                  
        union {
                        header head;
                        char buf[400];
                        
        } fault_buf; 


/********************************************************************/
/*******************  send buffer *******************/ 

#define TAILLE_MAX 100     

        msgtype send_buff[TAILLE_MAX];  
        
        int delt,               // next to delete ( unused )
            next,               // next to send   
            last,               // input index ( last to send +1)
            total;
            

/********************************************************************/  
/************** current phase data *********************/
        
        int n_received; // number of senders of the received messages at curphase
        
        int n_to_send;  // number of unsent buffered messages 
        
        int cmd_to_send; // a join (or quit) message has to be sent 
        
        int ack_flag;   // a message has to be acknowledged at curphase
        
        int new_flag;   // a new member is joining
        
        int fault_count; // number of missing messages/members 
        
        int init_flag; // in charge of a join process
        
/*************** timeout and iteration values ( dynamic and static) *****************/

        int max_iter;
        int timeout ; 
        
#define TIMEOUT1        1
#define TIMEOUT2        2
#define MAX_ITER        2
#define NEW_MAX_ITER    2 * MAX_ITER 
                
/********************************************************************/  
/******** per-phase structure with input message buffers *************/ 
        
        struct phase_buffer {
        
                int phase;
                
                int sendflag;   // type of message sent at curphase
        
                int grsize;     // number of members
        
                int mess_numb;  // number of senders for the received messages 
                
                int mess_flag ; // a MESS has been received at this phase
                
                int fault_flag; // a FAULT has been received at this phase
                
                int cmd_flag;   // a CMD has been received at this phase
                
                int status[MAX_MEMBER]; 
                        
                        //see values below
                        
                int fault_cnt[MAX_MEMBER];
                
                        // count of FAULT messages for that member ( previous phase )
                
                msgtype message[MAX_MEMBER];

                        // the messages received at this phase;
                
        } get_net_buffer[3];
        
        struct phase_buffer  *prev_get, *cur_get, *next_get;    
        
/********************************************************************/  
/********* (per-phase) status of members *********/     

#define UNDEF           -1      
#define WAITING         1
#define FAULTY          2
#define NEWMEM          4
#define GOT             32
#define GOTMESS         GOT + MESS
#define GOTCMD          GOT + CMD
#define GOTACK          GOT + ACK
#define GOTFAULT        GOT + FAULT
        
/********************************************************************/  
/********************************************************************/  
/*****************initialisation method *****************/

        int init_from_file(char *) ;
        
        int start_net_init(char *) ;
                
        int init_from_net(char * data, int size) ;      

        void init_data();

/*****************per-phase methods *****************/
                
        int timeout_handler( int );
        
        void fault_handler();
        
        void phase_update() ;
        
        void phase_actions();

        void send_buffer_advance();     
        
        void * get_first_to_send();
                
/******  initiate a JOIN process for a new member ***********/
        
        int start_join(char *data, int size ); 
        
/***** terminate a JOIN process ( send data to new member ) ***********/
        
        int new_member_init( int ident );       
        
/********************************************************************/  
/****************Synchronisation objects ****************/      

        pthread_cond_t all_received;    //waiting for the reception from all members
        
        pthread_mutex_t mp ;
        
        /*pthread_mutex_t net_mutex; */         //to access UDP 
        
        pthread_mutex_t phase_mutex;    //to start a new phase
        
        pthread_mutex_t send_mutex;     //mutual exclusion for send buffer              
        
        pthread_mutex_t recv_mutex;     //mutual exclusion for recv buffer
                        
        timestruc_t to;                 // time struct for timeouts 
                
  
};      



        
        
        
        
        
        
        
         

        

---