/****************************************************************/
/*  mcast.may:   multicast using different multicast trees      */
/*  written by  Lihao Xu, EE, Caltech                           */
/*               May 1995                                       */
/****************************************************************/



#include "mcast.h"

/* Given a group (an ordered position set with length g_len) and
   my id, find my parent id  and children id on the n-ary tree
   Return: parent id, -1 if I am not in the group 
*/

int tree(group,g_len,sender,me,n,children,num_children)
int group[],children[];
int g_len,me,sender,n,*num_children;
{
int my_position,subgrp_len;
int low,high,i;
int subgroup,parent;

/* Find my position in the group using binary search */
low=0;high=g_len-1;
while(1){
	if(group[low]==me){ my_position=low; break; }
	if(group[high]==me) { my_position=high; break; }
	my_position=(low+high)/2;
	if(low>=high) break;
	if(group[my_position]==me) 	break;
	else if(group[my_position]>me) 	high=my_position-1;
	else 				low=my_position+1;
} /* end while */

if(group[my_position] != me) return(-1); /* I am not in the group */

/*if(n==1){
	if(my_position==0)
		parent=sender;
	else
		parent=group[my_position-1];
	if(my_position==g_len-1) *num_children=0;
	else{
		*num_children=1;
		children[0]=group[my_position+1];
	}
	return(parent);
} *//* Special Case: Tree degrades into a line */

parent=sender;
subgrp_len=(g_len+n-1)/n; /* Is this an Optimal Tree? */
subgroup=my_position/subgrp_len;
low=subgroup*subgrp_len; high=low+subgrp_len-1;	
high=min(g_len-1,low+subgrp_len-1);  /* last subgroup */
if(my_position==low){
	subgrp_len=(high-low+n-1)/n;
	i=low+1; *num_children=0;
	while(i<=high){
		children[*num_children]=group[i];
		(*num_children)++;
		i += subgrp_len;
	}
}
else{
	parent=group[low];
	while( high-low>n ){
		parent=group[low]; low++;
		subgrp_len=(high-low+n)/n;
		subgroup=(my_position-low)/subgrp_len;
		low += (subgroup*subgrp_len);
		high=min(high,low+subgrp_len-1);
		if(my_position==low) break;
	}/* end while */
	if(my_position==low){
		subgrp_len=(high-low+n-1)/n; 
		i=low+1; *num_children=0;
		while(i<=high){
			children[*num_children]=group[i];
			(*num_children)++;
			i += subgrp_len;
		} /* end while */
	}
	else{
		parent=group[low];
		*num_children=0;
                /*for(i=low+1;i<=high;i++)
                        children[i-low-1]=group[i];
                *num_children=high-low;*/
	}
}/* end else */
return(parent);
}



/* Find children of the sender in the ACK-collect tree */
/* Return: Number of the children */
int get_children(group,g_len,n,children)
int group[], children[];
int g_len,n;
{
int i,j, subgrp_len;

subgrp_len=(g_len+n-1)/n;
i=0;j=0;
while(i<=g_len-1){
	children[j]=group[i];
	j++;
	i += subgrp_len;
}
return(j);
}

/* Find the child's position in the children array */
int children_position(child,children,children_num)
int child,children[],children_num;
{

for(i=0;i<children_num;i++)
	if(children[i]==child) return(i);
return(-1);
}



/* Uniform Random Function */
int uniform_random(low,high)
int low,high;
{
return low+random()%(high-low+1);
}


/* Get next packet's sequence number */
int next_packet(current_packet)
int current_packet;
{
current_packet++;
return(current_packet%BUFFER);
}



/* Get current packet's position in th window */
int win_pos(current_packet,win_start)
int current_packet;
{
current_packet -= win_start;
if(current_packet<0) current_packet += BUFFER;
return(current_packet);
}



/* Check if current packet is in the window */
boolean packet_in_window(current_packet,win_start)
{
if(win_start<=current_packet) return(true);
else if(current_packet<(win_start+WINDOW)%BUFFER)  return(true);
else return(false);
}

/* Check if all children ACKed the packet after acker acked it*/
boolean all_children_acked(acker,child_ack,children_num)
int acker,child_ack[],children_num;
{
int i;

children_ack[acker]=true;
for(i=0;i<children_num;i++) 
	if(children_ack[i]==false) return(false);
return(true);
}


/* get the status of the channel */
int current_time = -1;
int threshold;
boolean channel_status(send_time)
int send_time;
{
int decision;

if(send_time>current_time){
	current_time=send_time;
	decision=random()%PRECISION;
	if(decision<threshold)
		return(true);
}
return(false);
}


PROCESS timer{}
{
PROCESS_ID host;
int msg_source,msg_num,pkt_num;
int delay;

WAIT UNTIL RECEIVE(initiate_timer);  /* initiated by its host */
host=RECEIVED.initiate_timer.host;

while(true){
        WAIT UNTIL RECEIVE(time_out_request);
        msg_source=RECEIVED.time_out_request.msg_source;
        msg_num=RECEIVED.time_out_request.msg_num;
        pkt_num=RECEIVED.time_out_request.pkt_num;
        delay=RECEIVED.time_out_request.delay;
        SEND_TO host THE_MESSAGE time_out{msg_source,msg_num,pkt_num}
                  WITH_DELAY delay;
}
}


PROCESS sender{}
{
int msg_source,msg_num,my_num;
char *msg;
int msg_size,win_size;
int *group,group_size;
int pkt_num,pkt_win; 
int win_start;
int i,j,num_acked,acker;
boolean get_ack[WINDOW+1];
int delay[WINDOW];
int children[SPLIT],children_num;
boolean child_ack[WINDOW][SPLIT];
PROCESS_ID host;
PROCESS_ID *receiver;
PROCESS_ID my_id;
PROCESS_ID timer;
int num_node;
char data;


WAIT UNTIL RECEIVE(initiate_sender);
my_id=RECEIVED.initiate_sender.my_id;
my_num=RECEIVED.initiate_sender.my_num;
host=RECEIVED.initiate_sender.host;
num_node=RECEIVED.initiate_sender.num_node;
receiver=(PROCESS_ID *) malloc(sizeof(PROCESS_ID)*num_node);
for(i=0;i<num_node;i++)
	 receiver[i]=RECEIVED.initiate_sender.receiver[i];

timer = NEW timer{};
SEND_TO timer THE_MESSAGE initiate_timer{my_id};
/* End of Initialization */

msg_num=0; msg_source=my_num;
while(true){
WAIT UNTIL RECEIVE(usr_msg);
group_size=RECEIVED.usr_msg.group_size;
group=(int *)malloc(sizeof(int)*group_size);
for(i=0;i<group_size;i++) group[i]=RECEIVED.usr_msg.group[i];
msg_size=RECEIVED.msg_size;
msg=malloc(msg_size);	
for(i=0;i<msg_size;i++) msg[i]=RECEIVED.usr_msg.msg[i];

/* Get all the children */
children_num=get_children(group,group_size,children);

for(i=0;i<win_size;i++) delay[i]=INI_DELAY;

for(i=0;i<win_size;i++) for(j=0;j<children_num;j++) child_ack[i][j]=false;

/* Send out the packet_head */
for(i=0;i<group_size;i++){
	if(channel_status)
	  SEND_TO receiver[group[i]] THE_MESSAGE packet_head{msg_source,msg_num,msg_size,group,group_size} WITH_DELAY CHANNEL_DELAY;
}

SEND_TO timer THE_MESSAGE time_out_request{msg_source,msg_num,pkt_num,TIME+delay[0]};
DELAY(TS); get_ack[0]=false;
while(get_ack[0]==false){  
WAIT UNTIL{ 
	RECEIVE(ack) st (RECEIVED.ack.msg_num==msg_num && RECEIVED.ack.pkt_num == -1){
	       	   acker=RECEIVED.ack.acker;
		   acker=children_position(acker,children,children_num);
		   if(all_children_acked(acker,child_ack[0],children_num)) get_ack[0]=true;
	}  /*end ack */
	OR 
	RECEIVE(time_out){
		if(get_ack[0]==false){
			for(i=0;i<group_size;i++)
        			if(channel_status)
SEND_TO receiver[group[i]] THE_MESSAGE packet_head{msg_source,msg_num, msg_size,group,group_size} WITH_DELAY CHANNEL_DELAY;

SEND_TO timer THE_MESSAGE time_out_request{msg_source,msg_num,-1,TIME+delay[0]};
			DELAY(TS);
		}
	}/* end time_out */
} /* end while: the packet head acked */

for(i=0;i<children_num;i++) child_ack[0][i]=false;
 
/* Send out all the packets in the window */
num_sending=msg_num; num_sent=min(win_size,num_sending); msg_ptr=0;
for(i=0;i<num_sent;i++){
	pkt_num=i;
	data=msg[msg_ptr]; 
	msg_ptr++;
	DELAY(TS);   
	for(j=0;j<group_size;j++)
		if(channel_status)
SEND_TO receiver[group[j]] THE_MESSAGE packet{msg_source,msg_num,pkt_num,data};

SEND_TO timer THE_MESSAGE time_out_request{msg_source,msg_num,pkt_num,TIME+delay[i]};

}
win_start=0;

num_acked=0; num_sending -= num_sent;
for(i=0;i<=win_size;i++) get_ack[i]=false;  /* All packets in window have not been ACKed */
/* Use get_ack[win_size]=0 as a boundary symbol */

while(num_acked<msg_size){
	WAIT UNTIL{
		RECEIVE(ack) st (RECEIVED.ack.msg_num==msg_num){
			   pkt_num=RECEIVED.ack.pkt_num;
			   acker=RECEIVED.ack.acker;
			   if(packet_in_window(pkt_num,win_start)){ /* if 2 */
				pkt_win=win_pos(pkt_num,win-start);
				acker=children_position(acker,children,children_num);
				if(all_children_acked(acker,child_ack[pkt_win],children_num)) get_ack[pkt_win]=true;
				if(get_ack[0]){ /* if 3*/
					i=1;
					while(get_ack[i]) i++;
					num_ack += i;  /* i more packets ACKed*/
					i=min(i,num_sending);
					num_sending -= i;
					pkt_num=next_packet((win_start+WINDOW-1)%BUFFER);

			/*Move the window forward by i steps*/	
					win_start += i; win_start %= BUFFER;
					for(j=0;j<win_size-i;j++){
						get_ack[j]=get_ack[j+i]; 
						/*delay[j]=delay[j+i]; */
						for(k=0;k<children_num;k++)
							child_ack[j][k]=child_ack[j+i][k];
					}
					for(j=win_size-i;j<win_size;j++){
						get_ack[j]=false;
				/*		delay[j]=INI_DELAY; */
						for(k=0;k<children_num;k++)
							child_ack[j][k]=false;
					} 

					for(j=0;j<i;j++){
					  data=msg[msg_ptr];
					  msg_ptr++; 
					  DELAY(TS);
					  for(k=0;k<group_size;k++)
						if(channel_status)
SEND_TO receiver[group[k]] THE_MESSAGE packet{msg_source,msg_num,pkt_num,data}  WITH_DELAY CHANNEL_DELAY;
					  pkt_win=win_pos(pkt_num,win_start);
SEND_TO timer THE_MESSAGE time_out_request{msg_source,msg_num,pkt_num,TIME+delay[pkt_win]};   /* start_timer(pkt_num,TIME,delay[pkt_win]); */
					  pkt_num=next_packet(pkt_num); 
					}
				} /* end if 3 */  
			  } /* end if 2*/
		} /* end ack */
		OR RECEIVE(nack) st (RECEIVED.nack.msg_num==msg){
			   pkt_num=RECEIVED.nack.pkt_num;
			   pkt_win=win_pos(pkt_num,win_start);
			   if(packet_in_window(pkt_num) && !get_ack[pkt_win]){ /* if 2 */
				data=msg[msg_ptr-(win_size-pkt_win)];
				DELAY(TS);
				for(i=0;i<group;i++)
					if(channel_status)
SEND_TO receiver[group[i]] THE_MESSAGE packet{msg_source,msg_num,pkt_num,data}  
WITH_DELAY CHANNEL_DELAY;
				/* delay[pkt_win] *= 2;  ?   */
SEND_TO timer THE_MESSAGE time_out_request{msg_source,msg_num,pkt_num,TIME+delay[pkt_win]};
			   } /* end if 2 */
		} /* end nack */
		OR RECEIVE(time_out) st (RECEIVED.time_out.msg_num==msg){
                           pkt_num=RECEIVED.time_out.pkt_num;
                           pkt_win=win_pos(pkt_num,win_start);
                           if(packet_in_window(pkt_num) && !get_ack[pkt_win]){ /* if 2 */
                                data=msg[msg_ptr-(win_size-pkt_win)];
                                DELAY(TS);
                                for(i=0;i<group;i++)
                                        if(channel_status)
SEND_TO receiver[group[i]] THE_MESSAGE packet{msg_source,msg_num,pkt_num,data}  
WITH_DELAY CHANNEL_DELAY;
                                /* delay[pkt_win] *= 2;  ?   */
SEND_TO timer THE_MESSAGE time_out_request{msg_source,msg_num,pkt_num,TIME+delay
[pkt_win]};   /* start_timer(pkt_num,TIME,delay[pkt_win]); */
                           } /* end if 2 */
		}/* end time_out, same as nack */
	} /* end WAIT */
}/* end while: window finished */
msg_num++;

SEND_TO host THE_MESSAGE usr_ack;
} /* end loop */
}
}



PROCESS receiver{}
{
int win_start,msg_num,msg_source,msg_ptr;
int me,parent,children[SPLIT],children_num;
int num_to_rcv,num_rcvd;
boolean get_packet[WINDOW],get_ack[WINDOW+1];
char msg[MSG];
int win_size,num_win_to_move;
PROCESS_ID host;
PROCESS_ID my_id;
PROCESS_ID timer;
PROCESS_ID *receiver;
PROCESS_ID *sender;

WAIT UNTIL RECEIVE(initiate_receiver);
my_id=RECEIVED.initiate_receiver.my_id;
my_num=RECEIVED.initiate_receiver.my_num;
host=RECEIVED.initiate_receiver.host;
num_node=RECEIVED.initiate_receiver.num_node;
receiver=(PROCESS_ID *) malloc(sizeof(PROCESS_ID)*num_node);
for(i=0;i<num_node;i++)
         receiver[i]=RECEIVED.initiate_receiver.receiver[i];
sender=(PROCESS_ID *) malloc(sizeof(PROCESS_ID)*num_node);
for(i=0;i<num_node;i++)
	sender[i]=RECEIVED.initiate_receiver.sender[i];

timer = NEW timer{};
SEND_TO timer THE_MESSAGE initiate_timer{my_id};
/* End of Initialization */

msg_num=0;
while(true){
	WAIT UNTIL RECEIVE(packet_head) st (RECEIVED.packet_head.msg_num>=msg_num);
	msg_source=RECEIVED.packet_head.source;
	num_to_rcv=RECEIVED.packet_head.msg_size;
	msg_num=RECEIVED.packet_head.msg_num;
	parent=tree(RECEIVED.packet_head.group,RECEIVED.packet_head.group_size,me,split,children,&num_children);
	for(i=0;i<children_num;i++) child_ack[0][i]=false; 
	for(i=0;i<win_size+1;i++)   get_ack[i]=false;  /* This is for children  */

	while(get_ack[0]==false){
		WAIT UNTIL RECEIVE(ack) st ((RECEIVED.ack.msg_num==msg_num) && (RECEIVED.ack.pkt_num == -1));
		acker=RECEIVED.ack.acker;
		acker=children_position(acker,children,children_num);
		if(all_children_acked(acker,child_ack[0],children_num)) get_ack[0]=true;
	}/* end while: all children acked */ 
/* Here we don't use time_out scheme to collect the ACKs, just let the sender retransmit 
   the header again
*/
	for(i=0;i<win_size;i++)  get_packet[i]=false;
	if(children_num==0) for(i=0;i<win_size;i++) get_ack[i]=true;
	else 		    for(i=0;i<win_size;i++) get_ack[i]=false;
	for(i=0;i<win_size;i++)
		for(j=0;j<children_num;j++)
			child_ack[i][j]=false;
	pkt_num = -1;
	win_start=0; msg_ptr=0;
	DELAY(TR);
if(parent==msg_source)
	SEND_TO sender[parent] THE_MESSAGE ack{msg_source,msg_num,pkt_num,my_num}; 
else 
	SEND_TO receiver[parent] THE_MESSAGE ack{msg_source,msg_num,pkt_num,my_num}; 
 /*  send_ack(parent,msg_num,pkt_num,me); */

	num_rcvd=0; num_win_to_move=max(0,num_to_rcv-win_size);
	while(num_rcvd<num_to_rcv){
		WAIT UNTIL{ 
		     RECEIVE(packet_head) st ((RECEIVED.packet_head.msg_source==msg_source) && (RECEIVED.packet_head.msg_num<=msg_num)){
			pkt_num = -1;
			DELAY(TR1);
if(parent==msg_source)
        SEND_TO sender[parent] THE_MESSAGE ack{msg_source,msg_num,pkt_num,my_num
}; 
else 
        SEND_TO receiver[parent] THE_MESSAGE ack{msg_source,msg_num,pkt_num,my_num}; 
 /*  send_ack(parent,msg_num,pkt_num,me); */

		     } /* end packet_head */
		     OR   
		     RECEIVE(packet) st ((RECEIVED.packet.msg_source==msg_source) && (RECEIVED.packet.msg_num<=msg_num)){
			pkt_num=RECEIVED.packet.pkt_num;
			if(packet_in_window(pkt_num,win_start)){
				pkt_win=win_pos(pkt_num,win_start);
				if(get_packet[pkt_win]==false){
						get_packet[pkt_win]=true;
/* msg_ptr always points to the win_start */	msg[msg_ptr+pkt_win]=RECEIVED.packet.data;
						num_rcvd++;
				}  /* end if: new packet */      
				if(get_ack[pkt_win]){ /* if children acked */
if(parent==msg_source)
        SEND_TO sender[parent] THE_MESSAGE ack{msg_source,msg_num,pkt_num,my_num
}; 
else 
        SEND_TO receiver[parent] THE_MESSAGE ack{msg_source,msg_num,pkt_num,my_num}; 
 /*  send_ack(parent,msg_num,pkt_num,me); */

				 if(pkt_win==0){ /* if pkt_win */
				  i=0;
				  while(get_ack[i] && get_packet[i]) i++;
				  i=min(i,num_win_to_move);
				  num_win_to_move -= i;
				  for(j=i;j<win_size;j++) {
					/* delay[j-i]=delay[j]; */
					get_ack[j-i]=get_ack[j];
					get_packet[j-i]=get_packet[j];
					for(k=0;k<children_num;k++)
						 child_ack[j-i][k]=child_ack[j][k];
				  }
				  for(j=win_size-i;j<win_size;j++){
		/*			delay[j]=INI_DELAY; */
					get_ack[j]=false;
					get_packet[j]=false;
					for(k=0;k<children_num;k++)
						child_ack[j][k]=false;
				  }
				  if(children_num==0) 
					for(j=0;j<win_size;j++) get_ack[j]=true;
				  win_start += i; win_start %= BUFFER; 
				  msg_ptr += i;
				 } /* end if: Moving Window forward i steps */
				}  /* end if: children acked */
				else
SEND_TO timer THE_MESSAGE time_out{msg_source,msg_num,pkt_num,TIME+delay[pkt_win]};  /*start_timer(pkt_num,TIME,delay[pkt_win]; */
			} /* end if : packet in window */
			else
if(parent==msg_source)
        SEND_TO sender[parent] THE_MESSAGE ack{msg_source,msg_num,pkt_num,my_num
}; 
else 
        SEND_TO receiver[parent] THE_MESSAGE ack{msg_source,msg_num,pkt_num,my_num}; 
 /*  send_ack(parent,msg_num,pkt_num,me); */
		     } /* end packet */
		     OR
		     RECEIVE(ack) st ((RECEIVED.ack.msg_num==msg_num) && (RECEIVED.ack.msg_source==msg_source)){
			pkt_num=RECEIVED.ack.pkt_num;
			if(packet_in_window(pkt_num,win_start)){
				pkt_win=win_pos(pkt_num,win_start);
				acker=RECEIVED.ack.acker;
				acker=children_position(acker,children,children_num);
				if(all_children_acked(acker,child_ack[pkt_win],children))
					get_ack[pkt_win]=true;
				if(get_packet[pkt_win]==false)
SEND_TO sender[msg_source] THE_MESSAGE nack{msg_source,msg_num,pkt_num}; 
/* send_nack(msg_source,RECEIVED.msg_num,pkt_num); */

				if(get_packet[pkt_win] && get_ack[pkt_win]){
if(parent==msg_source)
        SEND_TO sender[parent] THE_MESSAGE ack{msg_source,msg_num,pkt_num,my_num
}; 
else 
        SEND_TO receiver[parent] THE_MESSAGE ack{msg_source,msg_num,pkt_num,my_num}; 
 /*  send_ack(parent,msg_num,pkt_num,me); */

                                 if(pkt_win==0){ /* if pkt_win */
                                  i=0;
                                  while(get_ack[i] && get_packet[i]) i++;
                                  i=min(i,num_win_to_move);
                                  num_win_to_move -= i;
                                  for(j=i;j<win_size;j++) {
                                  /*      delay[j-i]=delay[j]; */
                                        get_ack[j-i]=get_ack[j];
                                        get_packet[j-i]=get_packet[j];
                                        for(k=0;k<children_num;k++)
                                                 child_ack[j-i][k]=child_ack[j][k];
                                  }
                                  for(j=win_size-i;j<win_size;j++){
                                /*        delay[j]=INI_DELAY; */
                                        get_ack[j]=false;
                                        get_packet[j]=false;
                                        for(k=0;k<children_num;k++)
                                                child_ack[j][k]=false;
                                  }
                                  if(children_num==0)
                                        for(j=0;j<win_size;j++) get_ack[j]=true;
                                  win_start += i; win_start %= BUFFER;
                                  msg_ptr += i;
                                 } /* end if: Moving Window forward i steps */
				} /* end if: ack this packet */
			  } / * end if: packet in window */
			}   /*end ack */
			OR
			RECEIVE(time_out) st ((RECEIVED.time_out.msg_source==msg_source) && (RECEIVED.time_out.msg_num==msg_num)){
				pkt_num=RECEIVED.time_out.pkt_num;
				if(packet_in_window(pkt_num,win_start)){
					pkt_win=win_pos(pkt_num,win_start);
					if(!get_ack[pkt_win])){
SEND_TO sender[msg_source] THE_MESSAGE nack{msg_source,msg_num,pkt_num};
/*	send_nack(msg_source,msg_num,pkt_num); */
	/*		delay[pkt_win] *= 2; */
SEND_TO timer THE_MESSAGE time_out_request{msg_source,msg_num,pkt_num,TIME+delay[pkt_win]}; /*start_timer(pkt_win,TIME,delay[pkt_win]); */
					} /* packet not acked */
				} / * end if: packet in window */
			} /* end time_out */
		} /* end wait */
	} /* end while: all packets received */

SEND_TO host THE_MESSAGE delivered_msg{msg_source,msg_size,msg,group,group_size};
} /* end while: loop */

}