From 74edb6eb7e481165b583ece2aa0c659dd561d637 Mon Sep 17 00:00:00 2001 From: Willem Haffmans Date: Mon, 23 Dec 2024 10:16:11 +0100 Subject: [PATCH] bonus and mandatory folders, readme init --- README.md | 107 +++++++++++++++++++++++++++++++++++++ Makefile => philo/Makefile | 0 {inc => philo/inc}/philo.h | 0 {src => philo/src}/main.c | 0 4 files changed, 107 insertions(+) rename Makefile => philo/Makefile (100%) rename {inc => philo/inc}/philo.h (100%) rename {src => philo/src}/main.c (100%) diff --git a/README.md b/README.md index 2a91f24..78f89de 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,109 @@ # philosophers +## Overview +Here are the things you need to know if you want to succeed this assignment: +•One or more philosophers sit at a round table. +There is a large bowl of spaghetti in the middle of the table. +•The philosophers alternatively eat, think, or sleep. +While they are eating, they are not thinking nor sleeping; +while thinking, they are not eating nor sleeping; +and, of course, while sleeping, they are not eating nor thinking. +•There are also forks on the table. There are as many forks as philosophers. +•Because serving and eating spaghetti with only one fork is very inconvenient, a +philosopher takes their right and their left forks to eat, one in each hand. +•When a philosopher has finished eating, they put their forks back on the table and +start sleeping. Once awake, they start thinking again. The simulation stops when +a philosopher dies of starvation. +•Every philosopher needs to eat and should never starve. +•Philosophers don’t speak with each other. +•Philosophers don’t know if another philosopher is about to die. +•No need to say that philosophers should avoid dying! + +## Global rules +You have to write a program for the mandatory part and another one for the bonus part +(if you decide to do the bonus part). They both have to comply with the following rules: +•Global variables are forbidden! +•Your(s) program(s) should take the following arguments: +number_of_philosophers time_to_die time_to_eat time_to_sleep +[number_of_times_each_philosopher_must_eat] +◦number_of_philosophers: The number of philosophers and also the number +of forks. +◦time_to_die (in milliseconds): If a philosopher didn’t start eating time_to_die +milliseconds since the beginning of their last meal or the beginning of the sim- +ulation, they die. +◦time_to_eat (in milliseconds): The time it takes for a philosopher to eat. +During that time, they will need to hold two forks. +◦time_to_sleep (in milliseconds): The time a philosopher will spend sleeping. +◦number_of_times_each_philosopher_must_eat (optional argument): If all +philosophers have eaten at least number_of_times_each_philosopher_must_eat +times, the simulation stops. If not specified, the simulation stops when a +philosopher dies. +•Each philosopher has a number ranging from 1 to number_of_philosophers. +•Philosopher number 1 sits next to philosopher number number_of_philosophers. +Any other philosopher number N sits between philosopher number N - 1 and philoso- +pher number N + 1. + +Philosophers I never thought philosophy would be so deadly +About the logs of your program: +•Any state change of a philosopher must be formatted as follows: +◦timestamp_in_ms X has taken a fork +◦timestamp_in_ms X is eating +◦timestamp_in_ms X is sleeping +◦timestamp_in_ms X is thinking +◦timestamp_in_ms X died +Replace timestamp_in_ms with the current timestamp in milliseconds +and X with the philosopher number. +•A displayed state message should not be mixed up with another message. +•A message announcing a philosopher died should be displayed no more than 10 ms +after the actual death of the philosopher. +•Again, philosophers should avoid dying! +Your program must not have any data races. + + +## Mandatory part +Program name philo +Turn in files Makefile, *.h, *.c, in directory philo/ +Makefile NAME, all, clean, fclean, re +Arguments number_of_philosophers time_to_die time_to_eat +time_to_sleep +[number_of_times_each_philosopher_must_eat] +External functs. memset, printf, malloc, free, write, +usleep, gettimeofday, pthread_create, +pthread_detach, pthread_join, pthread_mutex_init, +pthread_mutex_destroy, pthread_mutex_lock, +pthread_mutex_unlock +Libft authorized No +Description Philosophers with threads and mutexes +The specific rules for the mandatory part are: +•Each philosopher should be a thread. +•There is one fork between each pair of philosophers. Therefore, if there are several +philosophers, each philosopher has a fork on their left side and a fork on their right +side. If there is only one philosopher, there should be only one fork on the table. +•To prevent philosophers from duplicating forks, you should protect the forks state +with a mutex for each of them. + +## Bonus part +Program name philo_bonus +Turn in files Makefile, *.h, *.c, in directory philo_bonus/ +Makefile NAME, all, clean, fclean, re +Arguments number_of_philosophers time_to_die time_to_eat +time_to_sleep +[number_of_times_each_philosopher_must_eat] +External functs. memset, printf, malloc, free, write, fork, kill, +exit, pthread_create, pthread_detach, pthread_join, +usleep, gettimeofday, waitpid, sem_open, sem_close, +sem_post, sem_wait, sem_unlink +Libft authorized No +Description Philosophers with processes and semaphores +The program of the bonus part takes the same arguments as the mandatory program. +It has to comply with the requirements of the Global rules chapter. +The specific rules for the bonus part are: +•All the forks are put in the middle of the table. +•They have no states in memory but the number of available forks is represented by +a semaphore. +•Each philosopher should be a process. But the main process should not be a +philosopher. +The bonus part will only be assessed if the mandatory part is +PERFECT. Perfect means the mandatory part has been integrally done +and works without malfunctioning. If you have not passed ALL the +mandatory requirements, your bonus part will not be evaluated at all. \ No newline at end of file diff --git a/Makefile b/philo/Makefile similarity index 100% rename from Makefile rename to philo/Makefile diff --git a/inc/philo.h b/philo/inc/philo.h similarity index 100% rename from inc/philo.h rename to philo/inc/philo.h diff --git a/src/main.c b/philo/src/main.c similarity index 100% rename from src/main.c rename to philo/src/main.c