/*
 * dinphil - The Dining Philosophers Problem
 *
 * By: Theo Van Dinter <felicity@kluge.net> - 96/10/07
 *
 *
 * This program was written to test a few different methods of solving the
 * dining philosopher's problem.  Due to various work related problems
 * (ie: I have too much work to do ...), I have made no attempts to
 * complete the additional work for this project.  This will become
 * obvious as you go through the code. (Notice that the variable 'type'
 * can only be true or false (hier or lr respectfully).  Most things are
 * based upon this.  It's a kluge, and had I had more time, it would be
 * implemented in a much nicer fashion, but as I've come to say: It
 * works.
 *
 * BTW: I added in a SPONCOM (Spontaneous Combustion) State for the
 * philosophers...  It's only used if there's a problem getting or
 * putting down a chopstick (ie: semaphore error).  Basically, the
 * philosopher goes 'poof', and takes any chopsticks they're holding
 * with them...
 *
 * BTW2: The code worked earlier, but I found out that the way I was handling
 * the pickup/number status codes was wrong.  I figured that the status would
 * be the number if the phil. was trying to pickup his first stick, and then
 * it would be 'P' after the first was picked up and before the second one.
 * I then found out that the status should be a number whenever the philosopher
 * is trying to pickup a chopstick, and only 'P' for the brief 1/10th second
 * pause in between getting the sticks.  This set of code now properly prints
 * that out.
 * 
 * BTW3: Per Prof. Wills word, I am passing in this assignment late.
 *
 * BTW4: Due to the above bit, the deadlock detection broke (since it was only
 * looking for the "PICKUP" state.  It works now.
 *
 */

#include <sys/time.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>

#define MAXPHIL 5
#define EAT 'E'
#define THINK 'T'
#define PICKUP 'P'
#define RELEASE 'R'
#define SPONCOM 'S'
#define FREE -1
#define SOLVPROB sleep(1)
#define CHOWDOWN sleep(1)

char *rgPhil, *rgStick;
int *Sticks[MAXPHIL];

int cntPhil, philpids[MAXPHIL], type;

int CreateProcess(void (*pFunc)(),int dvalue);
int InitStuff(void);
int CleanupStuff(void);
int lchop(int);
int rchop(int);
void Philosopher(int);
int GetResource(int);
int ReleaseResource(int);
extern int shmcreate(int);

void main(int argc, char *argv[])
{
  struct timeval curtime;
  struct timezone tzone;
  char statusdisp[3][3]={"  ","->","<-"};
  int loop, loo, deadchk;

  if (argc!=3) /* Not correct! */
    {
      printf("\nNot enough/too many parameters!\n\nUsage: %s [# of Phils] [Swapping Way]\n\n",argv[0]);
      printf("[# of Phils]   Range between 2 and %d Philosophers.\n",MAXPHIL);
      printf("[Swapping Way] How to deal with the chopsticks... 'lr' for left-right,\n");
      printf("               and 'hier' for hierarchical are the only ones supported.\n");
      printf("\n");
      exit(1);
    }

  cntPhil=atoi(argv[1]);

  if (cntPhil>MAXPHIL || cntPhil<2)
    {
      printf("\n# of Philosophers is invalid!  Valid is 2-%d!\n",MAXPHIL);
      exit(1);
    }

  if (!strcasecmp(argv[2],"lr")) /* lr */
    type=0;
  else if (!strcasecmp(argv[2],"hier")) /* hier */
    type=1;
  else /* blah ... */
    {
      printf("\nYou entered an unsupported mode.  Sorry.\n");
      exit(1);
    }

  /* Set the timezone structure for the gettimeofday() call below ... */
  tzone.tz_minuteswest=300;
  tzone.tz_dsttime=DST_USA;

  if (InitStuff()==-1) /* Error! */
    {
      printf("Error with InitStuff()!\n");
      exit(1);
    }

  for (loop=0;loop<10*cntPhil;loop++)
    {
      gettimeofday(&curtime,&tzone); /* I assume no errors... grrr... */

      printf("%9lu.%-6lu ",curtime.tv_sec,curtime.tv_usec);

      deadchk=0;

      for (loo=0;loo<cntPhil;loo++)
	{
	  if (rgPhil[loo]==PICKUP) /* If a philosopher has a stick, and wants*/
	    deadchk++;             /* a stick, add to the deadchk counter. */
	  else if (rgPhil[loo]>='0'&&rgPhil[loo]<='4')
          {
           if (!type&&rgPhil[loo]==rchop(loo)+'0') /* lr */
             deadchk++;
           else if (type) /* hier */
	    if ((rgPhil[loo]==rchop(loo)+'0'&&rchop(loo)>lchop(loo))||
		(rgPhil[loo]==lchop(loo)+'0'&&lchop(loo)>rchop(loo)))
             deadchk++;
          }

	  /* These printing functions aren't the 'nicest' in existance, but
	     they work... */

	  if (rgPhil[loo]==EAT)
	    printf("%s%c%s",statusdisp[1],rgPhil[loo],statusdisp[2]);
	  else if (rgPhil[loo]==THINK)
	    printf("%s%c%s",statusdisp[0],rgPhil[loo],statusdisp[0]);
	  else if (rgPhil[loo]==SPONCOM)
	    printf("%s%c%s",statusdisp[0],rgPhil[loo],statusdisp[0]);
	  else if (!type) /* lr */
	    {
	      if (rgPhil[loo]==PICKUP)
		printf("%s%c%s",statusdisp[1],rgPhil[loo],statusdisp[0]);
	      else if (rgPhil[loo]>='0' && rgPhil[loo]<='4')
              {
  		if (rgPhil[loo]==lchop(loo))
 		 printf("%s%c%s",statusdisp[2],rgPhil[loo],statusdisp[0]);
		else
 		 printf("%s%c%s",statusdisp[1],rgPhil[loo],statusdisp[1]);
              }
	      else if (rgPhil[loo]==RELEASE)
		printf("%s%c%s",statusdisp[0],rgPhil[loo],statusdisp[2]);
	    }
	  else if (type) /* hier */
	    {
	      if (rgPhil[loo]==PICKUP)
		printf("%s%c%s",lchop(loo)<rchop(loo)?statusdisp[1]:statusdisp[0],
		       rgPhil[loo],lchop(loo)<rchop(loo)?statusdisp[0]:statusdisp[2]);
	      else if (rgPhil[loo]<='4'&&rgPhil[loo]>='0')
		{
		 if (lchop(loo)<rchop(loo) && lchop(loo)==rgPhil[loo])
		  printf("%s%c%s",statusdisp[2],rgPhil[loo],statusdisp[0]);
		 else if (lchop(loo)<rchop(loo)) /* right one */
		  printf("%s%c%s",statusdisp[1],rgPhil[loo],statusdisp[1]);
		 else if (lchop(loo)>rchop(loo) && rchop(loo)==rgPhil[loo])
		  printf("%s%c%s",statusdisp[0],rgPhil[loo],statusdisp[1]);
		 else if (lchop(loo)>rchop(loo)) /* left one */
		  printf("%s%c%s",statusdisp[2],rgPhil[loo],statusdisp[2]);
		}
	      else if (rgPhil[loo]==RELEASE)
		printf("%s%c%s",lchop(loo)<rchop(loo)?statusdisp[1]:statusdisp[2],
		       rgPhil[loo],lchop(loo)<rchop(loo)?statusdisp[1]:statusdisp[2]);
	    }

	  if (loo<cntPhil-1) /* Print the spacer unless it's the last
				phil. */
	    printf("|");
	}
	  
      printf("\n");
      if (deadchk>=cntPhil) /* Deadlock! */
	{
	  printf("\nDeadlock!\n");
	  break;
	}
      sleepms(500); /* Pause 1/2 second. */
    }

  if (CleanupStuff()==-1) /* Cleanup Philosophers/Shared
			     Memory/etc... */
    {
      printf("Error with CleanupStuff()!\n");
      exit(1);
    }

  exit(0); /* Exit, error status 0 - Everything OK! */
}

/*
 * CreateProcess - 96/09/09
 *
 * CreateProcess will now take two parameters, and pass the second to the
 * forked child. - Originally written for OS-1 Project #2.
 *
 */
int CreateProcess(void (*pFunc)(),int dvalue)
{
    int pid;

    if ((pid = fork()) == 0) /* We're the child */
      {
        (*pFunc)(dvalue); /* Call function with value */
        exit(0); /* If function doesn't quit, we'll die implicitly */
      }
    return(pid); /* Return fork() value to the parent (-1 for error, PID
		    otherwise) */
}

int InitStuff()
{
  int loop;

  rgPhil = (char *)shmcreate(cntPhil);
  rgStick= (char *)shmcreate(cntPhil);

  if (rgPhil==(char *)-1 || rgStick==(char *)-1) /* Error! */
    return(-1);

  for(loop=0;loop<MAXPHIL;loop++) /* Create needed semaphores and mailboxes*/
    {
      Sticks[loop] = (int *)shmcreate(sizeof(int));
      if (Sticks[loop]==(int *)-1) /* Error! */
	return(-1);
      *Sticks[loop] = screate(1);
      if (*Sticks[loop]==-1) /* Failure! */
	return(-1);
    }
  for(loop=0;loop<cntPhil;loop++)
  {
   rgPhil[loop]=THINK;
   rgStick[loop]=FREE;
   philpids[loop]=CreateProcess(Philosopher,loop);
   if (philpids[loop]==-1) /* Error! */
     return(-1);
  }
  return(0);
}

int CleanupStuff()
{
  int loop;

  for(loop=0;loop<cntPhil;loop++)
    {
      if (kill(philpids[loop],2)==-1)
	return(-1);
    }

  for(loop=0;loop<MAXPHIL;loop++)
    {
      if (sdelete(*Sticks[loop])==-1)
        /* Delete semaphores if possible */
        return(-1);
      if (shmdelete((int *)Sticks[loop])==-1) /* Failure */
	/* Delete shared memory */
	return(-1);
    }
    if (shmdelete((char *)rgPhil)==-1) /* Failure */
    /* Delete shared memory */
      return(-1);
    if (shmdelete((char *)rgStick)==-1) /* Failure */
    /* Delete shared memory */
      return(-1);
  return(0);
}

int lchop(int phil) /* Return the number of the left chopstick */
{
  /* Basically: if the left chopstick is the highest numbered, the
     simpler "(phil-1)%cntPhil" value STILL returns a -1, which isn't
     good ...  So the following is a quick kluge.  But it works. ;) */

  int temp=phil-1;
  if (temp<0)
    temp+=cntPhil;
  return(temp);
}

int rchop(int phil) /* Return the number of the right chopstick */
{
  return(phil);
}

void Philosopher(int which) /* The Philosopher - while(1) {blah} loop */
{
  int FChopstick, SChopstick; /* First/Second Chopstick #'s */

  if (!type) /* lr */
    {
      FChopstick=lchop(which);
      SChopstick=rchop(which);
    }
  else /* hier */
    {
      FChopstick=lchop(which)<rchop(which)?lchop(which):rchop(which);
      SChopstick=lchop(which)<rchop(which)?rchop(which):lchop(which);
    }

  while(1)
    {
      rgPhil[which]=THINK;
      SOLVPROB; /* Wait 1 second ... */
      rgPhil[which]=FChopstick+'0';
      if (GetResource(FChopstick)==-1) /* Try to get the first
					  Chopstick */
	{
	  rgPhil[which]=SPONCOM; /* If there's an error, the
				    philosopher spontaneously
				    combusts, taking any chopsticks
				    he was holding with him... */
	  exit(1);
	}
      rgPhil[which]=PICKUP;
      rgStick[FChopstick]=which+'0';
      sleepms(100);
      rgPhil[which]=SChopstick+'0';
      if (GetResource(SChopstick)==-1)
	{
	  rgPhil[which]=SPONCOM;
	  exit(1);
	}
      rgStick[SChopstick]=which+'0';
      rgPhil[which]=EAT;
      CHOWDOWN; /* Eat for 1 second ... */
      if (ReleaseResource(!type?FChopstick:SChopstick)==-1)
	{
	  rgPhil[which]=SPONCOM;
	  exit(1);
	}
      rgPhil[which]=RELEASE;
      rgStick[!type?FChopstick:SChopstick]=FREE;
      sleepms(100);
      if (ReleaseResource(!type?SChopstick:FChopstick)==-1)
	{
	  rgPhil[which]=SPONCOM;
	  exit(1);
	}
      rgStick[!type?SChopstick:FChopstick]=FREE;
    }
}

int GetResource(int which)
{
  if (swait(*Sticks[which])==-1)
    return(-1);
  return(0);
}

int ReleaseResource(int which)
{
  if (ssignal(*Sticks[which])==-1)
    return(-1);
  return(0);
}