#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>
#include <sys/time.h>
 
#define TIMEOUT 50000 // context switch rate, in microseconds
#define WAIT_COUNT 0x10000 // busy wait count
#define EXIT_AFTER 1  // exit after 1 sec
 
 
// monitor
pthread_mutex_t mutex;
pthread_cond_t cond;
 
volatile int locked; // the `world' is locked or not
volatile int waiters; // number of waiting threads
volatile int signal_has_come; // 1 if context switch signal has come
 
// thread that fire periodic signal for context switch
void* thread_tick(void* arg) {
	while(1) {
		// fprintf(stdout, "tick\n"); fflush(stdout); 
		signal_has_come = 1;
		struct timespec to;
		to.tv_sec = 0;
		to.tv_nsec = TIMEOUT * 1000;
		nanosleep(&to, 0);
	}
}
 
// release the global lock
void unlock_world() {
	pthread_mutex_lock(&mutex);
	locked = 0;
	pthread_mutex_unlock(&mutex);
	// fprintf(stdout, "released global lock (%d)\n", (int)pthread_self()); fflush(stdout);
	pthread_cond_signal(&cond);
}
 
// obtain the global lock
void lock_world() {
	pthread_mutex_lock(&mutex);
	while(locked) {
		// fprintf(stdout, "locked. sleeping.. (%d)\n", (int)pthread_self()); fflush(stdout);
		waiters++;
		pthread_cond_wait(&cond, &mutex);
		waiters--;
	}
	locked = 1;
	pthread_mutex_unlock(&mutex);
	// fprintf(stdout,"got global lock. restart. (%d)\n", (int)pthread_self());
}
 
// yield to switch to the other thread
void yield() {
	if(0==waiters) return;
	unlock_world();
	sched_yield();
	lock_world();
}
 
void check_signal_and_yield() {
	if(signal_has_come) {
		signal_has_come=0;
		yield();
	}
}
 
int hit_count[2]; // count how many times the loop is executed, for each thread
int prev;
int switch_count;
 
void work(int i) {
	while(1) {
 
		// count
		hit_count[i]++;
		if(i!=prev) { prev=i; switch_count++;}
 
		// yield
		check_signal_and_yield();
 
		// fprintf(stdout,"working. %d\n", (int)pthread_self());
 
		// busy waiting
		int i;
		for(i=0; i<WAIT_COUNT; i++);
	}
}
 
 
void* thread_start(void* arg) {
	// fprintf(stdout, "new thread start. %d\n", (int)pthread_self()); fflush(stdout); 
	lock_world();
	work(1);
	return 0;
}
 
 
// exit after specified second.
void interrupt_handler(int sig) {
	fprintf(stdout, "SIGALRM. thread0: %d, thread1: %d, switch:%d\n", hit_count[0], hit_count[1], switch_count); fflush(stdout);
	exit(0);
}
 
// set up the stop watch
void set_stop_alarm() {
	void(*oldact)(int);
	oldact = signal(SIGALRM, interrupt_handler);
	assert(SIG_ERR!=oldact);
	struct itimerval itv;
	itv.it_value.tv_sec = EXIT_AFTER;
	itv.it_value.tv_usec = 0;
	itv.it_interval = itv.it_value;
	setitimer(ITIMER_REAL, &itv, 0);
}
 
int main(int argc, char** argv) {
 
	// set up the stop watch
	set_stop_alarm();
 
	// set up mutex and condition variable for monitor
	int r = pthread_mutex_init(&mutex, 0);
	assert(0==r);
	r = pthread_cond_init(&cond, 0);
	assert(0==r);
 
	// start the sub thread
	pthread_t th;
	pthread_create(&th, 0, thread_start, 0);
 
	// start the tick thread
	pthread_t th2;
	pthread_create(&th2, 0, thread_tick, 0);
 
	// start the main thread
	lock_world();
	work(0);
	return 0;
}