#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
#include<unistd.h>

#include<signal.h>

#define N_CHILD 4
#define N_ROUNDS 8

/*
 * implementing a rendez-vous.
 * a rendez-vous synchronizes threads proceeding at their own pace
 * at a barriers. once all threads arrive at the barrier (the rendez-vous)
 * they can continue into their next round of activity.
 *
 * because signals do not accumulate, the protocol has two stages. the
 * first stage the parent engages the child threads one by one in a 
 * cleared/acknowledged pair of HUP signals. Then the parent broadcasts 
 * an INT signal.
 *
 * the first stage: when the child is ready, it waits on a HUP from the
 * parent before responding to the parent with a HUP signal. this signal
 * declares to the parent that this child is ready. the child then 
 * approaches the barrier.
 *
 * the second stage: the parent has collected from all children the HUP
 * signals that they are ready, the parent sends the INT signal releasing
 * the children to cross the barrier.
 *
 * author: bjr
 * date: sep 2018
 * update:
 *
 */

int g_count_hups = 0  ;
int g_continues = 0 ;
int g_cleared = 0 ;
int g_acknowledged = 0 ;

void parent_sighandler(int sig) {
	g_acknowledged = 1 ;
	return ;
}

void child_sighandler(int sig) {
	g_cleared = 1 ;
	return ;
}

void child_int_sighandler(int sig) {
	g_continues = 1 ;
	return ;
}

void do_child(int child_id) {
	pid_t ppid = getppid() ;
	int rounds = 0 ;
	signal(SIGHUP,child_sighandler) ;
	signal(SIGINT,child_int_sighandler) ;
	
	while (rounds<N_ROUNDS ) {
		int t ;
		rounds++ ;

		t = 3 + (3 * rounds * (child_id+1))%5 ;
		printf("round %d child %d sleeps for %d seconds\n", 
			rounds, child_id, t) ;
		sleep(t) ;
		printf("round %d child %d ready\n",rounds, child_id ) ;

		while (!g_cleared) ;
		g_cleared = 0 ;
		kill(ppid,SIGHUP) ;
		printf("round %d child %d acknowledges parent\n",rounds, child_id ) ;

		while (!g_continues) ;
		g_continues = 0 ;

	}
	printf("child %d exits\n", child_id ) ;
	return ;
}

int main(int c, char * argv[]) {
	int i ;
	int rounds = 0 ;
	pid_t children[N_CHILD] ;
	int hups_target = 0 ;
	int exit_status ;

	signal(SIGHUP,parent_sighandler) ;

	for ( i = 0; i<N_CHILD; i++) {
		int child_pid = fork() ; 
		if (!child_pid) {
			do_child(i) ;
			return 0 ;
		}
		children[i] = child_pid ;
	}
	// only parent gets here.
	sleep(3) ;

	while (rounds<N_ROUNDS) {
		rounds++ ;

		for (i=0; i<N_CHILD; i++ ) {
			kill(children[i],SIGHUP) ;
			while (!g_acknowledged) ;
			g_acknowledged = 0 ;
		}

		printf("round %d parent releases barrier\n", rounds ) ;
		for (i=0; i<N_CHILD; i++ ) {
			kill(children[i],SIGINT) ;
		}
		
	}
	for (i=0;i<N_CHILD;i++) {
		wait(&exit_status) ;
	}
	printf("parent exits\n") ;
	return 0 ;

}