SourceCode für Dining Philosophers Problem in C

//Quelle: http://people.eecs.ku.edu/~mjantz/678labs/lab08/lab08.tar.gz
//Authoren:  Vergleiche (Source von Quelle wurde umgeschrieben) Michael Jantz und Prasad Kulkarni 
#include <stdio.h>
#include "C:\Documents and Settings\Administrator\My Documents\Visual Studio 2005\Projects\DiningPhilosophers\DiningPhilosophers\pthread.h" 
#include "pthread.h" 
#include <windows.h>
//#include <unistd.h>
#include <math.h>
#include <string.h>

#define NUM_PHILS 5
#define MAX_BUF 256
#define NUM_CHOPS NUM_PHILS

typedef struct {
  int can_grab_left;
  int can_grab_right;
  pthread_t thread;
  pthread_cond_t can_eat; 
  int prog;
  int prog_total;
  int id;
} philosopher;

static pthread_mutex_t chopstick[NUM_CHOPS];
static pthread_mutex_t waiter;
static philosopher diners[NUM_PHILS];
static int stop=0;

/*
 * Helper functions for grabbing chopsticks, referencing neighbors
 */
philosopher *left_phil (philosopher *p)
{
  return &diners[(p->id == 0 ? NUM_PHILS-1 : (p->id)-1)];
}

philosopher *right_phil (philosopher *p)
{
  return &diners[(p->id == NUM_PHILS ? 0 : (p->id)+1)];
}

pthread_mutex_t *left_chop (philosopher *p)
{
  return &chopstick[(p->id == 0 ? NUM_CHOPS-1 : (p->id)-1)];
}

pthread_mutex_t *right_chop (philosopher *p)
{
  return &chopstick[p->id];
}

/*
 * Philosopher code
 */
static void *dp_thread(void *arg)
{
      int iter=0, id = (int)arg;
  int think_rnd, eat_rnd, i;
  philosopher *me;

  me = (philosopher *) arg;

      while (!stop) {
    think_rnd = (rand() % 10000);
    eat_rnd = (rand() % 10000);

            /*
             * Think for some random time
             */         
            for (i = 0; i < think_rnd; i++){}

    /*
     * Grab both chopsticks
     */
    pthread_mutex_lock(left_chop(me));
    pthread_mutex_lock(right_chop(me));

    /*
     * Eat for some random time
     */
    for (i = 0; i < eat_rnd; i++){}

    /*
     * Release both chopsticks
     */
    pthread_mutex_unlock(left_chop(me));
    pthread_mutex_unlock(right_chop(me));

    /* Update my progress */
    me->prog++;
    me->prog_total++;
  }

  return NULL;
}

void init_diners()
{
  int i;
      for (i = 0; i < NUM_PHILS; i++) {
    diners[i].can_grab_left = 1;
    diners[i].can_grab_right = 1;
    diners[i].prog = 0;
    diners[i].prog_total = 0;
    diners[i].id = i;
  }

      for (i = 0; i < NUM_PHILS; i++) {
            pthread_create(&(diners[i].thread), NULL, dp_thread, &diners[i]);
  }
}

void print_progress()
{
  int i,j;
  char buf[MAX_BUF];

  for (i = 0; i < NUM_PHILS;) {
    for (j = 0; j < 5; j++) {
      if (i == NUM_PHILS) {
        printf("\n");  
        break;
      }
      sprintf(buf, "p%d=%d/%d", i, diners[i].prog,  
          diners[i].prog_total);
      if (strlen(buf) < 16)
        printf("%s\t\t", buf);  
      else 
        printf("%s\t", buf);  
      i++;
    }
    if (i == NUM_PHILS) {
      printf("\n");  
      break;
    }
    printf("p%d=%d/%d\n", i, diners[i].prog,  
        diners[i].prog_total); 
    i++;
  }

  printf("\n");  
}

int main(int argc, char **argv)
{
      int i, deadlock, iter=0;

  srand(time(NULL));

      for (i = 0; i < NUM_CHOPS; i++)
            pthread_mutex_init(&chopstick[i], NULL);

  pthread_mutex_init(&waiter, NULL);
  init_diners();
      
      do {
    /*
     * Reset the philosophers eating progress to 0. If the philosopher makes
     * progress, the philosopher will increment it.
     */
            for (i = 0; i < NUM_PHILS; i++)
                  diners[i].prog = 0;

    /*
     * Let the philosophers do some thinking and eating
     */
            Sleep(5);

    /*
     * Check for deadlock (i.e. none of the philosophers are making progress)
     */
            deadlock = 1;
            for (i = 0; i < NUM_PHILS; i++)
                  if (diners[i].prog)
                        deadlock = 0;

    /*
     * Print out the philosophers progress
     */
    print_progress();
      } while (!deadlock);

      stop = 1;
  printf ("Reached deadlock\n");  

  /*
   * Release all locks so philosophers can exit
   */
      for (i = 0; i < NUM_CHOPS; i++)
            pthread_mutex_unlock(&chopstick[i]);

  /*
   * Wait for philosophers to finish
   */
      for (i = 0; i < NUM_PHILS; i++)
            pthread_join(diners[i].thread, NULL);

      system("pause");  

      return 0;


}