/* Distributed Shared Memory - Read Replication Model
 * Pravin Paratey (October 31, 2002)
 * DS Programming Assignment 2
*/
 
#include <stdio.h>
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
 
#define MEMSIZE 100
 
pthread_t thChild[5]; /* Stores the child descriptor returned by pthread_create */
char childStack[5]; /* Space for the child stack */
 
 
void *daChild (void *arg);
void SendWriteMessage(int id, int memorynum, int memory[]);
void SendReadMessage(int id, int memorynum, int memory[]);
void PurgeMemory (int id, int memorynum, int memory[]);
 
int main(int argc, char *argv[])
{
	int i;
	/* We have 5 nodes with memory addresses 0-499 statically distributed among them as
	 * node1 -> 0 - 99
	 * node2 -> 100 - 199
	 * node3 -> 200 -299
	 * node4 -> 300 - 399
	 * node5 -> 400 - 499
	*/
 
	for (i=1; i<=5; i++)
	{
		if(pthread_create(&thChild[i], NULL, daChild, (void *) i) != 0)
		{
			fprintf(stderr,"Error: Unable to create thread");
			return 1;
		}
	}
 
sleep(10);
 
	return 0;
}
 
// int daChild (int arg) SB
void *daChild (void *arg)
{
	int num;
	FILE *fp;
	char filename[10];
	int eof;
	char inbuf[15];
	int innum, i;
 
 
	/* This is the block of memory. I am storing other details here.
	 * Actually these details should be stored elsewhere, but wth
	 * The other details are who has the read block and who has write lock
	 * the first 8 bits tell the node(s) which have the lock
	 * the next 8 the type of lock,
	 * 	0 - read block
	 * 	1 - write block
	 */
	int memory[100];
//	struct sockaddr_in sa1, sa2;
//	int sock1, sock2; /* Listening and sending sockets */
 
	num = (int) arg;
	printf ("[%i] I am %i\n", pthread_self(), num);
	/* Generate the filename */
	sprintf(filename, "%i", num);
	printf("Opening %s\n", filename);
	/* Open the file which has instructions */
	fp = fopen (filename, "r");
	if (!fp)
	{
		perror("Terminating Thread");
		pthread_exit((void *)1);
	}
	/* Read instructions and execute them */
	while (1)
	{
		eof = fscanf(fp, "%5s%i%*c", &inbuf, &innum);
//		printf("DEBUG %s %i\n",inbuf, innum);
		if (eof == -1)
			break;
		if (strcmp(inbuf, "read(") == 0)
		{
			/* Determine which node to send message to
			 * The procedure is as follows -
			 * If the memory being addressed isn't ours,
			 * 	send message and wait for OK or NEG
			 * Otherwise you know what to do (look at report)
			 */
 
			printf("[-%i-] Reading block %i\n",num, innum);
 
			/* Send READ(innum) broadcast */
//			for (i=1;i<=5;i++)
//				SendReadMessage(i, innum, memory);
 
			/* If this is our node */
			if (innum % 100 == num-1)
			{
				/* Send READ(innum) message to self server */
//				printf("SELF\n");
				SendReadMessage(num, innum, memory);
			}
			else
			{
				/* if we don't have block in our cache */
				/* Send READ(innum) message to other server */
//				printf("OTHER\n");
				SendReadMessage(innum%100 + 1, innum, memory);
			}
			/* Get block and cache it */
			printf("[-%i-] Reading %i done\n",num, innum);
 
		}
		else if (strcmp(inbuf, "writ(") == 0)
		{
			printf("[-%i-] Writing block %i\n", num, innum);
			/* Send WRITE (innum) message to other nodes */
 
			for (i=1; i<=5; i++)
				SendWriteMessage(i,innum, memory);
 
			printf("[-%i-] Writing %i done\n", num, innum);
		}
	}
	/* Close file */
	fclose(fp);
 
//	sleep(10);
 
	pthread_exit(NULL);
}
 
void SendReadMessage(int id, int memorynum,int memory[])
{
	int thenum;
//	printf("DEBUG-READ id=%i memorynum=%i\n",id,memorynum);
 
	thenum = memorynum % id;
 
	if (memorynum % 100 == id-1)
	{
		/* If memory is not being written */
		if (memory[thenum] == 0 || memory[thenum] == 1)
		{
			/* Mark memory as being read */
			memory[memorynum % id] = 1;
 
			/* Send block back here */
			printf ("[%i] Sending block %i...\n", id, memorynum);
 
			/* Send message back to calling node SB DITCH*/
		}
		else
		{
			while (memory[thenum] == 2)
			{
				printf("[%i] sleeping\n", id);
				sleep(1);
			}
			/* Mark memory as being read */
			memory[memorynum % id] = 1;
 
			/* Send block back here */
			printf ("[%i] Sending block %i...\n", id, memorynum);
 
			/* Send message back to calling node SB DITCH*/
		}
	}
	else
	{
		/* Do nothing, not our node */
		return;
	}
}
 
void SendWriteMessage(int id, int memorynum, int memory[])
{
	int thenum;
	int i;
 
//	printf("DEBUG-WRITE id=%i memorynum=%i mod=%i\n",id,memorynum,memorynum%100);
 
	thenum = memorynum % id;
 
	if (memorynum % 100 == id-1)
	{
		/* If memory is not being written */
		if (memory[thenum] == 0 || memory[thenum] == 1)
		{
			/* Send to all nodes PurgeMemory(thenum) SB */
			for (i=1;i<=5;i++)
				PurgeMemory(i, thenum, memory);
			/* Set the writing flag */
			memory[thenum] = 2;
			/* Do actual writing */
			printf("[%i] Writing to location %i ...\n", id, memorynum);
//			sleep(4);
			printf("\t... done[%i] \n",id);
			/* Unset the writing flag */
			memory[thenum] = 0;
		}
		else
		{
			/* Wait till somebody finishes with the block */
			while (memory[thenum] == 2)
			{
				printf("[%i] sleeping\n", id);
				sleep(1);
			}
			/* Send to all nodes PurgeMemory(thenum) SB */
			for (i=1;i<=5;i++)
				PurgeMemory(i, thenum, memory);
 
			/* Set the writing flag */
			memory[thenum] = 2;
			/* Do actual writing */
			printf("[%i] Writing to location %i ...\n", id, memorynum);
//			sleep(1);
			printf("\t... done[%i] \n",id);
			/* Unset the writing flag */
			memory[thenum] = 0;
		}
	}
	else
	{
		/* Do nothing, not our node */
		return;
	}
 
}
 
void PurgeMemory (int id, int memorynum, int memory[])
{
	int thenum;
//	printf("DEBUG id=%i memorynum=%i\n",id,memorynum);
 
	thenum = memorynum % id;
 
	if (memorynum % 100 == id-1)
	{
		printf("[%i] Memory block %i purged ...\n", id, memorynum);
	}
	else
	{
		/* Do nothing, not our node */
		return;
	}
}