Exercise 9, task 3, solution by Roman
=====================================

/* Compile, for example: gcc ex9.c -lpthread -lcurses -oex9.o  */
#include <pthread.h>
#include <stdio.h>
#include <curses.h>

#define PHs 5  //number of Philosophers

/* variable sum is shared by the threads */
int sum=0,a; 

int resources[PHs];

int starv[PHs]={0,0,0,0,0};

char *state[] = {" think ","hungry","|eat|  "};

pthread_mutex_t Sem=PTHREAD_MUTEX_INITIALIZER; //Used while printing and sharing sum
pthread_mutex_t SemRes=PTHREAD_MUTEX_INITIALIZER; //used for accesing to resources

pthread_mutex_t SemRes1[5];

/* thread */
void *runner1();

/* First thread */
main(int argc, char *argv[])
{
  /* Thread identifier */
  pthread_t tid[PHs];
  
  /* Attributes for a thread (stack size, scheduling ...) */
  pthread_attr_t attr;
  
  /* Set attributes (default attributes are used) */
  pthread_attr_init(&attr);
  
  //initialization
  sum=0; 
   
  initscr();
  cbreak();noecho();
  clear();
  
  move(12,0);
  printw("Dining philosophers deadlock free demonstration, please note, the last chopstick is copy of the first one.");
  printw(" Philosopher always takes both chopsticks only if they both are free.\n");
  printw(" Use Ctrl-C to break.");
  
  
  for (a=0;a<PHs;a++) {move(0,a*7+11);
                       printw("PH %i",a+1);
		      } 
  move(1,0);printw("blocked:");		      
  move(2,0);printw("action:");
  move(4,0);printw("ch-stick:");
  
  for (a=0;a<PHs;a++) {resources[a]=1;} // 1 means free

  refresh();
  
  for (a=0;a<PHs;a++) pthread_mutex_init(&SemRes1[a],NULL);
 /*run philosophers */
  pthread_create(&tid[0],&attr,runner1,NULL);
  pthread_create(&tid[1],&attr,runner1,NULL);
  pthread_create(&tid[2],&attr,runner1,NULL);
  pthread_create(&tid[3],&attr,runner1,NULL);
  pthread_create(&tid[4],&attr,runner1,NULL); 
 
  /* main waits runner thread using pthread_join */  
  pthread_join(tid[4],NULL);
  pthread_join(tid[3],NULL);
  pthread_join(tid[2],NULL);
  pthread_join(tid[1],NULL);
  pthread_join(tid[0],NULL);
  
  endwin();
  
}
/* Second thread */
void *runner1()
{

 int myNumber=0, PHtime,PHtodo=0,i;
 unsigned int foo;
  pthread_mutex_lock(&Sem); //get myNumber from sum sequence
   myNumber=sum;
   sum++;
  pthread_mutex_unlock(&Sem);
  foo=myNumber; //random seed taken from philosopher number

  while(sum<PHs){sleep(1);} //wait for creating all threads
  
while(1) { //infinite loop

  PHtime=rand_r(&foo)&7;  //generate random number 'how long will next thinking/eating last'
  PHtime++;   //at least 1 sec
  
  switch(PHtodo){	//what was he doing in previous turn
               
   case 2: /*eating*/	pthread_mutex_lock(&SemRes);
                        resources[myNumber] =1;        //free resources
		        resources[(myNumber+1)%PHs]=1;
			pthread_mutex_unlock(&SemRes);
			PHtodo=0;	               //and go think!
			
//			pthread_mutex_unlock(&SemRes1[myNumber]);
//			pthread_mutex_unlock(&SemRes1[(myNumber+1)%PHs]);
                        break;
			
   case 1:    while ( (resources[myNumber] ==0) || (resources[(myNumber+1)%PHs]==0))
              {
               sleep(1);  //both sticks have to be free to pick up
	                  //while not free=>sleep a while
	       starv[myNumber]++;
	       };
      	        {
//		        pthread_mutex_lock(&SemRes1[myNumber]);
//			pthread_mutex_lock(&SemRes1[(myNumber+1)%PHs]);

			pthread_mutex_lock(&SemRes);
		        resources[myNumber] =0;
		        resources[(myNumber+1)%PHs]=0;
			pthread_mutex_unlock(&SemRes);
			PHtodo=2;   //go eat next time
		}
               break;
  
  case 0:    PHtodo=rand_r(&foo)&01; //what to do in the next turn
				//generates only 0 or 1 think again or be hungry
	    //0 -  think again, 1 - hungry 
	     break;
  }
  
  pthread_mutex_lock(&Sem);   //display state, must be atomic because of curses
   move(2,myNumber*7+10);
   printw("%s",state[PHtodo]);

   move(3,myNumber*7+12);
  if (PHtodo!=1)  printw("%i ", PHtime);
    else printw("  ");

   for (i=0;i<=PHs;i++) { //print all sticks, last is copy of the first
    move(4,(i+1)*7+2);
    if (resources[i %PHs]==1) 
	printw("|"); 
      else printw(" ") ;
    } //for
   
   for (i=0;i<PHs;i++) { //blocked info
     move(1,i*7+12);
     printw("%i  ",starv[i]) ;
   }
   refresh();
  pthread_mutex_unlock(&Sem);

  if (PHtodo!=1) sleep(PHtime); //don't sleep if you are hungry
  
}  
  /* runner thread completes here */   
  pthread_exit(0); 
}


Exercise 9, task 2, solution by David
=====================================

/* gcc phil.c -lpthread -o phil */

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>

#define N 5

pthread_mutex_t chopstick[N];

void* philosopher(void *param);

int main()
{
 pthread_t tid[N];
 int i;
       
 for (i = 0; i < N; i++)
   if (pthread_mutex_init(&chopstick[i], NULL) != 0) {
     perror("pthread_mutex_init()\n");
     exit(-1);
   }
        
 for (i = 0; i < N; i++)  
   if (pthread_create(&tid[i], NULL, philosopher, (void*) i) != 0) {
     perror("pthread_crate()\n");
     exit(-1);
   }
   
 pthread_exit(0);
}



void* philosopher(void *param)
{
 int id;
 unsigned int seed;
 int sec;

 id = (int)param;
 do {
	/* think */
   seed = id * time(NULL);   
   sec = rand_r(&seed) % 3 + 1;
   sleep(sec);
   printf("Philosopher %d: Did thinking %d seconds.\n", id, sec);
   printf("Philosopher %d: is hungry.\n", id);
	/* take a chopstick */
   if ((id % 2) == 0) {		/* even philosopher */
     if (pthread_mutex_trylock(&chopstick[id]) == 0) {
       printf("Philosopher %d: Takes chopstick %d.\n", id, id);
     }
     else {
       printf("Philosopher %d: Waits for chopstick %d.\n", id, id);
       sec = time(NULL);
       pthread_mutex_lock(&chopstick[id]);
       sec = time(NULL) - sec;
       printf("Philosopher %d: Waited %d seconds. Takes chopstick %d.\n", id, sec, id);
     }
     if (pthread_mutex_trylock(&chopstick[(id + 1) % N]) == 0) {
       printf("Philosopher %d: Takes chopstick %d.\n", id, (id + 1) % N);
     }
     else {
       printf("Philosopher %d: Waits for chopstick %d.\n", id, (id + 1) % N);
       sec = time(NULL);
       pthread_mutex_lock(&chopstick[(id + 1) % N]);
       sec = time(NULL) - sec;
       printf("Philosopher %d: Waited %d seconds. Takes chopstick %d.\n", id, sec, (id + 1) % N);
     }
   }
   else {			/* odd philosopher */
     if (pthread_mutex_trylock(&chopstick[(id + 1) % N]) == 0) {
       printf("Philosopher %d: Takes chopstick %d.\n", id, (id + 1) % N);
     }
     else {
       printf("Philosopher %d: Waits for chopstick %d.\n", id, (id + 1) % N);
       sec = time(NULL);
       pthread_mutex_lock(&chopstick[(id + 1) % N]);
       sec = time(NULL) - sec;
       printf("Philosopher %d: Waited %d seconds. Takes chopstick %d.\n", id, sec, (id +1) % N);
     }
     if (pthread_mutex_trylock(&chopstick[id]) == 0) {
       printf("Philosopher %d: Takes chopstick %d.\n", id, id);
     }
     else {
       printf("Philosopher %d: Waits for chopstick %d.\n", id, id);
       sec = time(NULL);
       pthread_mutex_lock(&chopstick[id]);
       sec = time(NULL) - sec;
       printf("Philosopher %d: Waited %d seconds. Takes chopstick %d.\n", id, sec, id);
     }
   }
	/* eat */
   seed = id * time(NULL);   
   sec = rand_r(&seed) % 3 + 1;
   sleep(sec);
   printf("Philosopher %d: Ate %d seconds.\n", id, sec);
	/* put chopstick */
   pthread_mutex_unlock(&chopstick[id]);
   printf("Philosopher %d: Puts chopstick %d.\n", id, id);
   pthread_mutex_unlock(&chopstick[(id + 1) % N]);
   printf("Philosopher %d: Puts chopstick %d.\n", id, (id + 1) % N);
 } while(1);

 pthread_exit(0);
}