Shared memory, and multiple philosophers eating - c

Question

I've got my code down for a dining philosopher problem, using shared memory. The issue I'm encountering is that 3 of 5 philosophers are eating which shouldn't be happening. Where am I going wrong in my code?
Updated: still not working right. Philosophers seem to not be going through one of the states
#include <stdio.h> // needed for printf, sprintf, ...
#include <stdlib.h> // needed for exit()
#include <unistd.h> // needed for sleep, fork, waitpid, _exit, ftruncate
#include <sys/wait.h> // needed for waitpid
#include <fcntl.h> // For O_* constants
#include <sys/mman.h> // needed for mmap, munmap and associated constants
#include <semaphore.h>
void philosopher(int i);
int parent(void);
void take_forks(int i);
void put_forks(int i);
void test (int i);
void think(int i);
void eat(int i);
#define N 5 /* number of philosophers */
#define THINKING 0 /* philosopher is thinking */
#define HUNGRY 1 /* philosopher is trying to get for ks */
#define EATING 2 /* philosopher is eating */
#define FINISH 3
#define LEFT (arga+4)%N
#define RIGHT (arga+1)%N
struct shared_memory {
int k;
int state[N];
sem_t s[N];
sem_t mutex;
};
struct shared_memory *shared;
int fd_shm, fd_log;
int main(void) {
if ((fd_shm = shm_open ("/test", O_RDWR | O_CREAT, 0660)) == -1)
printf("error");
if (ftruncate (fd_shm, sizeof (struct shared_memory)) == -1)
printf("error");
if ((shared = mmap (NULL, sizeof (struct shared_memory), PROT_READ | PROT_WRITE, MAP_SHARED,fd_shm, 0)) == MAP_FAILED)
printf("error");
// Initialize the shared memory
shared -> k = 0;
for (int i=0; i<N;i++){
shared -> state[i] = 0;
sem_init(&shared->s[i],0,1);
}
sem_init(&shared->mutex,1,1);
pid_t pids[N];
// At the beginning every philosopher is thinking
for (int l = 0; l < N; l++){
shared ->state[l]=THINKING;
}
printf("Start");
for(int j=0; j< N; j++){
if((pids[j] = fork()) < 0){
printf("failed");
perror("fork");
}else if (pids[j] == 0 ){
int pid = getpid();
printf("pids[%d] = %d\n",j,pid);
philosopher(j);
exit(0);
}
}
parent();
for (int m=0; m<N;m++){
waitpid(pids[m],NULL,0);
}
printf("This is final k %d\n",shared->k);
if (munmap(shared, sizeof(struct shared_memory)) == -1) {
printf("Function munmap() failed\n");
exit(-1);
}
if ((shm_unlink("/test")) == -1){
printf("Function shm_unlink() failed\n");
exit(-1);
}
return EXIT_SUCCESS;
}
void philosopher(int arga) {
//int count =0;
//while(count<5){
while(1){
//sleep(1);
//think(i);
take_forks(arga);
sleep(2);
//eat(i);
//sleep(1);
put_forks(arga);
//count++;
}
shared->state[arga] = FINISH;
}
void take_forks(int arga) /* i: philosopher number, from 0 to N−1 */
{
//printf("arga take_fork: %d\n", arga);
sem_wait(&shared->mutex); /* enter critical region, down mutex */
shared->state[arga] = HUNGRY; /* record fact that philosopher i is hungry */
//while (shared->state[i] == HUNGRY){
test(arga); /* try to acquire 2 forks */
sem_post(&shared->mutex); /* exit critical region, up mutex */
//sem_wait(&shared->s[arga]); /* block if forks were not acquired, down philosopher*/
//}
//sleep(1);
}
void put_forks(int arga) /* i: philosopher number, from 0 to N−1 */
{
//printf("arga put_fork: %d\n", arga);
sem_wait(&shared->mutex); /* enter critical region, down mutes */
//test(LEFT); /* see if left neighbor can now eat */
//test(RIGHT); /* see if right neighbor can now eat */
shared->state[arga] = THINKING; /* philosopher has finished eating */
sem_post(&shared->mutex); /* exit critical region, up mutex */
}
void test(int arga) /* i: philosopher number, from 0 to N−1 */
{
sem_wait(&shared->s[LEFT]);
sem_wait(&shared->s[RIGHT]);
shared->state[arga]= EATING;
sleep(1);
sem_post(&shared->s[RIGHT]);
sem_post(&shared->s[LEFT]);
//if (shared->state[arga] == HUNGRY && shared->state[LEFT] != EATING && shared->state[RIGHT] != EATING)
//{
//printf("Philosopher: %d (i+N-1)%N - %d", i, ((i+N-1)%N));
//shared->state[arga] = EATING;
//sleep(2);
//sem_post(&shared->s[arga]); //Up philosopher
//}
}
void think(int arga){
//printf("I am philosopher %d i am thinking\n", i);
sleep(2);
}
void eat(int arga){
//printf("I am philosopher %d i am eating\n", i);
sleep(3);
}
int parent(void){
puts("This is the Parent Process");
int philosopherState;
char* philprint;
int count=0;
int c;
while (1){
sleep(1);
//sem_wait(&shared->mutex);
for(int o = 0; o<N;o++ ){
/*philosopherState = shared->state[o];
if (philosopherState == 0) {
philprint = "Thinking";
}else if(philosopherState == 1){
philprint = "Eating";
}else if(philosopherState == 2){
philprint = "Hungry";
}else if(philosopherState == 3){
philprint = "Gone";
count++;
}*/
sem_getvalue(&shared->s[o], &c);
//printf("P%d %s \t",o, philprint);
if (c==0){
printf("P%d Thinking\t",o);
}
else if(c==1){
printf("P%d Eating\t",o);
}
else if (c==2){
printf("P%d Hungry\t",o);
}
else if (c==3){
printf("P%d Gone\t",o);
}
if (count >4){
break;
}
}
//sem_post(&shared->mutex);
printf("\n");
}
return 0;
}
//while(count<5){
while(1){
//sleep(1);
//think(i);
take_forks(arga);
sleep(2);
//eat(i);
//sleep(1);
put_forks(arga);
//count++;
}
shared->state[arga] = FINISH;
}
void take_forks(int arga) /* i: philosopher number, from 0 to N−1 */
{
//printf("arga take_fork: %d\n", arga);
sem_wait(&shared->mutex); /* enter critical region, down mutex */
shared->state[arga] = HUNGRY; /* record fact that philosopher i is hungry */
//while (shared->state[i] == HUNGRY){
test(arga); /* try to acquire 2 forks */
sem_post(&shared->mutex); /* exit critical region, up mutex */
//sem_wait(&shared->s[arga]); /* block if for ks were not acquired, down philosopher*/
//}
//sleep(1);
}
void put_forks(int arga) /* i: philosopher number, from 0 to N−1 */
{
//printf("arga put_fork: %d\n", arga);
sem_wait(&shared->mutex); /* enter critical region, down mutes */
//test(LEFT); /* see if left neighbor can now eat */
//test(RIGHT); /* see if right neighbor can now eat */
shared->state[arga] = THINKING; /* philosopher has finished eating */
sem_post(&shared->mutex); /* exit critical region, up mutex */
}
void test(int arga) /* i: philosopher number, from 0 to N−1 */
{
sem_wait(&shared->s[LEFT]);
sem_wait(&shared->s[RIGHT]);
shared->state[arga]= EATING;
sleep(1);
sem_post(&shared->s[RIGHT]);
sem_post(&shared->s[LEFT]);
//if (shared->state[arga] == HUNGRY && shared->state[LEFT] != EATING && shared->state[RIGHT] != EATING)
//{
//printf("Philosopher: %d (i+N-1)%N - %d", i, ((i+N-1)%N));
//shared->state[arga] = EATING;
//sleep(2);
//sem_post(&shared->s[arga]); //Up philosopher
//}
}
void think(int arga){
//printf("I am philosopher %d i am thinking\n", i);
sleep(2);
}
void eat(int arga){
//printf("I am philosopher %d i am eating\n", i);
sleep(3);
}
int parent(void){
puts("This is the Parent Process");
int philosopherState;
char* philprint;
int count=0;
//int c;
while (1){
sleep(1);
for(int o = 0; o<N;o++ ){
philosopherState = shared->state[o];
if (philosopherState == 0) {
philprint = "Thinking";
}else if(philosopherState == 1){
philprint = "Eating";
}else if(philosopherState == 2){
philprint = "Hungry";
}else if(philosopherState == 3){
philprint = "Gone";
count++;
}
//sem_getvalue(&shared->s[o], &c);
printf("P%d %s \t",o, philprint);
//printf("P%d %s\t",o, c == 0 ? "Eating" : "Hungry");
if (count >4){
break;
}
}
printf("\n");
}
return 0;
}