dining philosophers problem

/*
About this program:
- Implementation of the Dining Philosophers problem,
  - Fig 6.12, Operating Systems, Stallings
 
- Example implementation using Posix threads and semaphores
 
- Each philosopher is assigned a philosopher identification number (pid)
  - pids range from 0 to N-1 (where N is the number of philosophers)
  - likewise forst range from 0 to M-1 where M is the number of forks, and in the
    classic dining philosophers problems M is always equal to N
 
- Each philosopher is implemented as a separate posix thread
 
- Each fork is associated with a Posix semaphore, and accessing a fork by a
  philosopher requires the philosopher to sem_wait() until the fork is available,
  and to sem_post() (e.g. signal) when they are done eating and have put the fork
  back on the table.
 
- Messages are displayed on standard output by the philosopher threads when the
  perform events such as picking up and putting down a fork, and when eating and
  thinking.
 
- This initial implementation has 2 philosophers and 2 forks.
 
 */
 
#include "philo.h"
 
// global arrays, hold the fork semaphores (using Posix sem_t semaphores)
// and the philosopher thread data structures (Posix pthread_t thread structures)
sem_t forks[NUM_FORKS];
pthread_t philosopherThread[NUM_PHILOSOPHERS];
 
 
/*
  Cause philosopher pid to think.  We pick some random amount of time from 0 to
  MAX_THINK_TIME and do a busy wait in this function to represent the philosopher
  thinking.
 
  Parameters:
    pid  An integer, the philosopher identification number of the philosopher who is
         to think.
 */
void think(int pid)
{
    fprintf(stdout, "Philosopher <%d> is thinking... (entered %d)\n", pid, thinkCount++);
 
    // do a spin wait
    int i;
    int thinktime = rand() % MAX_THINK_TIME;
    for (i=0; i<thinktime; i++);
}
 
 
/*
  Cause philosopher pid to eat.  We pick some random amount of time from 0 to
  MAX_EAT_TIME and do a busy wait in this function to represent the philosopher
  eating.  This function is identical to thinking, but we split apart to alow
  easier understanding of the different tasks of the philosopher, and to allow for
  different think/eat times to be easily set and experimented with.
 
  Parameters:
    pid  An integer, the philosopher identification number of the philosopher who is
         to eat.
 */
void eat(int pid)
{
    fprintf(stdout, "Philosopher <%d> is eating... (entered %d)\n", pid, eatCount++);
 
    // do a spin wait
    int i;
    int eattime = rand() % MAX_EAT_TIME;
    for (i=0; i<eattime; i++);
}
/*
  The main function run by a philosopher's thread.  This is an
  implementation from fig 6.12 of Stalling's Operating Systems
  textbook.  The philosopher simply performs an infinite loop of
  thinking, followed by eating, forever an ever (what a life!)  In
  order to eat, the philosopher needs 2 forks, so he/she first tries
  to pick up the fork to their right (where the forkd id is equal to
  the philosopher id), and then tries to get the fork to his/her left
  (fork id = philosopher id + 1).
 
  Parameters:
 
    arg A pointer to (potentially a while array) of arguments.  This
        is part of the defined Posix thread interface.  The main
        function of a Posix thread accepts a single void* arg
        parameter, through which we can pass parameters initially into
        the thread.  We pass the philosopher identification number
        (pid) which is the first thing that the thread extracts and
        saves away before the philosopher starts running.
 */
void *philosophosize(void *arg)
{
    int pid = *((int *)(arg)); // philosopher id
    int fork;
    fprintf(stdout, "Entered philosopher <%d>\n", pid);
 
    while (1)
    {
        think(pid);
 
        fork = pid;
        sem_wait(&forks[fork]);
        fprintf(stdout, "    philosopher <%d> pickedup fork <%d>\n", pid, fork);
        fork = (pid+1) % NUM_FORKS;
        sem_wait(&forks[fork]);
        fprintf(stdout, "    philosopher <%d> pickedup fork <%d>\n", pid, fork);
 
        eat(pid);
 
        fork = (pid+1) % NUM_FORKS;
        sem_post(&forks[fork]);
        fprintf(stdout, "    philosopher <%d> released fork <%d>\n", pid, fork);
        fork = pid;
        sem_post(&forks[fork]);
        fprintf(stdout, "    philosopher <%d> released fork <%d>\n", pid, fork);
 
    }
 
   return NULL;
}
 
/*
  Program main function.  We create the semaphores and threads to be
  run by the program, then perform joins to wait for all the threads
  to finish (not really relevant in this program, as the threads are
  programmed to run forever, so they never finsih, and the joins never
  return).
 
  One note: when creating the threads using pthread_create, note that
  we initialize the arg integer array with the the philosopher id
  number.  this arg is passed into the newly created thread, so that
  it knows what its pid is when it begins executing.
 
  Parameters:
    argc The number of command line arguments, unused in this program
    argv An array of strings containing the command line arguments, also unused
 
 */
int main(int argc, char **argv)
{
 
 
    // create the semaphores for the forks
    int i;
    for (i=0; i<NUM_FORKS; i++)
    {
        if (sem_init(&forks[i], 0, 1))
        {
            perror("Unable to initialize fork semaphore");
        }
    }
 
    // let's create our threads
    int arg[NUM_PHILOSOPHERS];
    for (i=0; i<NUM_PHILOSOPHERS; i++)
    {
        arg[i] = i;
        if (pthread_create(&philosopherThread[i], NULL, philosophosize, &arg[i]))
        {
            perror("Unable to create philosopher thread");
        }
    }
 
    // join threads, waits till all threads are done
    for (i=0; i<NUM_PHILOSOPHERS; i++)
    {
        pthread_join(philosopherThread[i], NULL);
    }
 
    // everything is finished, print out the number of operations performed
    fprintf(stdout, "Philosophsizing is done\n");
    return EXIT_SUCCESS;
}