Dining philosophers problem in C

code/operating_system/src/DiningPhilosophersProblem/README.md

@@ -0,0 +1,11 @@
+# What is Dining Philosophers Problem in OS
+
+ Five philosophers are sitting around a circular table and their job is to think and eat alternatively. A bowl of noodles is placed at the center of the table along with five chopsticks for each of the philosophers. To eat a philosopher needs both their right and a left chopstick. A philosopher can only eat if both immediate left and right chopsticks of the philosopher is available. In case if both immediate left and right chopsticks of the philosopher are not available then the philosopher puts down their (either left or right) chopstick and starts thinking again.
+
+The dining philosopher demonstrates a large class of concurrency control problems hence it's a classic synchronization problem.
+
+# What are Semaphores?
+
+Semaphores are integer variables that are used to solve the critical section problem by using two atomic operations, wait and signal that are used for process synchronization.
+
+![Alt text](image.png)

code/operating_system/src/DiningPhilosophersProblem/diningphilosopher_semaphores.c

@@ -0,0 +1,87 @@
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdio.h>
+#include <wait.h>
+#include <unistd.h>
+#define N 5
+#define THINKING 2
+#define HUNGRY 1
+#define EATING 0
+#define LEFT (phnum + 4) % N
+#define RIGHT (phnum + 1) % N
+int state[N];
+int phil[N] = { 0, 1, 2, 3, 4 };
+sem_t mutex;
+sem_t S[N];
+void test(int phnum)
+{
+if (state[phnum] == HUNGRY
+&& state[LEFT] != EATING
+&& state[RIGHT] != EATING) {
+// state that eating
+state[phnum] = EATING;
+sleep(2);
+printf("Philosopher %d takes fork %d and %d\n",
+phnum + 1, LEFT + 1, phnum + 1);
+printf("Philosopher %d is Eating\n", phnum + 1);
+// sem_post(&S[phnum]) has no effect
+// during takefork
+// used to wake up hungry philosophers
+// during putfork
+sem_post(&S[phnum]);
+}
+}
+// take up chopsticks
+void take_fork(int phnum)
+{
+sem_wait(&mutex);
+// state that hungry
+state[phnum] = HUNGRY;
+printf("Philosopher %d is Hungry\n", phnum + 1);
+// eat if neighbours are not eating
+test(phnum);
+sem_post(&mutex);
+// if unable to eat wait to be signalled
+sem_wait(&S[phnum]);
+sleep(1);
+}
+// put down chopsticks
+void put_fork(int phnum)
+{
+sem_wait(&mutex);
+// state that thinking
+state[phnum] = THINKING;
+printf("Philosopher %d putting fork %d and %d down\n",
+phnum + 1, LEFT + 1, phnum + 1);
+printf("Philosopher %d is thinking\n", phnum + 1);
+test(LEFT);
+test(RIGHT);
+sem_post(&mutex);
+}
+void* philosopher(void* num)
+{
+while (1) {
+int* i = num;
+sleep(1);
+take_fork(*i);
+sleep(0);
+put_fork(*i);
+}
+}
+int main()
+{
+int i;
+pthread_t thread_id[N];
+// initialize the semaphores
+sem_init(&mutex, 0, 1);
+for (i = 0; i < N; i++)
+sem_init(&S[i], 0, 0);
+for (i = 0; i < N; i++) {
+// create philosopher processes
+pthread_create(&thread_id[i], NULL,
+philosopher, &phil[i]);
+printf("Philosopher %d is thinking\n", i + 1);
+}
+for (i = 0; i < N; i++)
+pthread_join(thread_id[i], NULL);
+}