From c0b9c33cfa4821e1770ee6679ee9bebbf8eeae14 Mon Sep 17 00:00:00 2001 From: whaffman Date: Fri, 3 Jan 2025 15:06:33 +0100 Subject: [PATCH] first working simulation and breakup of code --- .vscode/tasks.json | 0 philo/inc/philo.h | 23 ++++++++++++++++++++--- philo/philo | Bin 16184 -> 17416 bytes philo/src/check_alive.c | 17 +++++++++++++++++ philo/src/create_mutexes.c | 14 +++++++++----- philo/src/create_philos.c | 2 ++ philo/src/create_threads.c | 20 ++++++++++++++++++++ philo/src/destroy_mutexes.c | 8 +++++--- philo/src/free_philos.c | 4 +++- philo/src/join_threads.c | 17 +++++++++++++++++ philo/src/main.c | 19 ++++++++++++++++--- philo/src/parse_arguments.c | 10 ++++++++++ philo/src/philo_routine.c | 36 ++++++++++++++++++++++++++++++++++++ philo/src/print_rules.c | 10 ++++++++++ philo/src/print_status.c | 8 ++++---- 15 files changed, 169 insertions(+), 19 deletions(-) create mode 100644 .vscode/tasks.json create mode 100644 philo/src/check_alive.c create mode 100644 philo/src/create_threads.c create mode 100644 philo/src/join_threads.c create mode 100644 philo/src/philo_routine.c create mode 100644 philo/src/print_rules.c diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000..e69de29 diff --git a/philo/inc/philo.h b/philo/inc/philo.h index 8668f6c..8ba38ff 100644 --- a/philo/inc/philo.h +++ b/philo/inc/philo.h @@ -16,6 +16,7 @@ "time_to_eat time_to_sleep [number_of_times_each_philosopher_must_eat]\n" # define ERROR_MUTEX "Can not create mutex" # define ERROR_MALLOC "Malloc Failure" +# define ERROR_THREADS "Can not create threads" typedef struct s_rules { @@ -24,10 +25,12 @@ typedef struct s_rules int time_to_eat; int time_to_sleep; int n_must_eat; - pthread_mutex_t *print; - pthread_mutex_t *death; + int death; + int start_time; + pthread_mutex_t *print_lock; + pthread_mutex_t *death_lock; pthread_mutex_t *forks; - t_philo *philos; + struct s_philo *philos; } t_rules; @@ -40,6 +43,7 @@ typedef struct s_philo int death; int last_meal; t_rules *rules; + int n_eat; } t_philo; // memset, printf, malloc, free, write, @@ -49,6 +53,19 @@ typedef struct s_philo // pthread_mutex_unlock int ph_atoi(const char *nptr, int *res); +int get_time(void); +void free_philos(t_rules *rules); +int destroy_mutexes(t_rules *rules); +int create_philos(t_rules *rules); +int parse_arguments(int argc,char *argv[], t_rules *rules); +int create_mutexes(t_rules *rules); +int create_threads(t_rules *rules); +void print_status(t_philo *philo, char *status); +void *philo_routine(void *philo); +int join_threads(t_rules *rules); +void print_rules(t_rules *rules); + + #endif \ No newline at end of file diff --git a/philo/philo b/philo/philo index 7c22300902c6d3eccd718301b3473c49f9f710d0..8fda598aca3fa70dc6f70ea4fc80a54af200269f 100755 GIT binary patch literal 17416 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 delta 2751 zcmZ`*eN0nV6u+hSu&M6rvWPl zIJ(T}mPyRw%(9d*6aLt;Ix}^NQ|B^6h*@w6OVK4`Zhx>v_jc}k_bQO>Chz_3`JLZA z_w(HMy1Rvu1AVFXkd-LKs{(nmw13G*mXJX;Lx%n_(K4x3tw}A|1+hw}QB977g%FUY z?IH!LKT#I{;vlg>%j+R?XINT z2QGeb^r|m;WbpC#$Hn^tw_~pJa7?>6*@(gTUgf_yr+Df4XT)H};3*QdmIDPB$ z(3=B8nj|=@Pk{`B3$`0Fbj!pQ1WuMMf?-2Jmq4^chXE)XE53CC)n;Z}Jj&%jgmWc;D!NGsd|1Sf$#6 z?t~t`GdhacUMlqT3@=>Mh@ljMS^& zNMYr4Fj)%gQ)vBgG-#H`6S6~8c$p#U^A!Dx91pCur)wre2-q{1Oo%Az%x{nmm48jE zQqM#%P70S_K_h0CWjWT0uPgd5MTpqlbv^qZNj;rYQcpwd(EdmIpcUVSpk;)1H91Dx zhZ|y2xOPf96g5d<40lKBxf<)kDIAV=GTmncc4TE(TW66+2%O5wXev`lqZ08!BZi7e zy*?a~64LoJWWp@raypLAJSMj?`QoSYaU2_tzzB^gX^q~V{nv3C(N-y}b1$Z&?x~$F zib}l=x1{j8Xt)-=H*na|e`FaOrQj;p<0+&wIrmtWN3d)1K(7oD=R4gh^5t{@U%vqS(jZGJ#l&mo-S+fAE%ki-yUkDR9xm~GP;|WED zN%#br!imUB23C&YBVgxdI?393)+3slcmw8ToY6$6{}X)fqklW%6ThZ~x)uL*q)Twn zO1`P>>*5VT#jgl{MZpUwaL)|z%2R(FcDxDwr)K&!eJB{Nayw`)oz|xDwB~6{2TMyC z>?z2$-Az=jG!;k$&K6_~BXFs}lk=WVC3#Yhvb)*BwC4%fMX@@<@|j(Tq>#Dk($T_m z-=Uhs$Kr9mPY-X4>x+DP)sH!}i`Mu!aRC+E%lv;aTMJd@mo(9Gyf9N>x5o;jo?FWz zGxrXIIPuZo4LLrCFJ`>c24jU{5x??~Rmwhm(`J0_7)|Ig6i70z(#oPm!l%$&5dNX!-U+3WNJ37|s5p%v zkW|9AfP3eGt=J*t!;sFAb`%%VNpOF?+^b@pqS*v{iXCZw)YvsP!cPNNwoy${hUJ~-cEZilT*xi+!lAN`#CCska94o%{jJTxW`9Spd2bMgRxb7U+jh2+ zmiD%m*Zs|VU+dh_wlmm)s#iNYR1u+(kf>i*JQki#K0ORplvw&$_F%I8Tv1}@ImodPLscFy@zjM4 zl@7RCX-oC7Md!%VND&ylw)iH-D2RVCiLkjc0qVTACx3f<-!^Mun^&~(BX&0t2EET} zLO3last_meal > philo->rules->time_to_die) + { + print_status(philo, "died"); + philo->death = 1; + pthread_mutex_lock(philo->rules->death_lock); + philo->rules->death = 1; + pthread_mutex_unlock(philo->rules->death_lock); + pthread_mutex_unlock(philo->l_fork); + pthread_mutex_unlock(philo->r_fork); + return (FAILURE); + } + return (SUCCESS); +} \ No newline at end of file diff --git a/philo/src/create_mutexes.c b/philo/src/create_mutexes.c index 3980631..edf94af 100644 --- a/philo/src/create_mutexes.c +++ b/philo/src/create_mutexes.c @@ -5,16 +5,20 @@ int create_mutexes(t_rules *rules) int i; i = 0; - if (!pthread_mutex_init(&rules->death, NULL)) - return(FAILURE); - if (!pthread_mutex_init(&rules->print, NULL)) - return(FAILURE); + printf("creating mutexes\n"); + if (pthread_mutex_init(rules->death_lock, NULL)) + return(printf("death mutex created"), FAILURE); + if (pthread_mutex_init(rules->print_lock, NULL)) + return(printf("print mutex created"), FAILURE); + printf("creating forks\n"); rules->forks = malloc(rules->n_philos * sizeof(pthread_mutex_t)); if (!rules->forks) return(FAILURE); while (i < rules->n_philos) { - if (!pthread_mutex_init(&rules->forks[i], NULL)) + if (pthread_mutex_init(&rules->forks[i], NULL)) return(FAILURE); + i++; } + return (SUCCESS); } \ No newline at end of file diff --git a/philo/src/create_philos.c b/philo/src/create_philos.c index 1d36985..c0cf919 100644 --- a/philo/src/create_philos.c +++ b/philo/src/create_philos.c @@ -18,6 +18,8 @@ int create_philos(t_rules *rules) philo->death = 0; philo->pid = 0; philo->rules = rules; + philo->last_meal = get_time(); i++; } + return (SUCCESS); } \ No newline at end of file diff --git a/philo/src/create_threads.c b/philo/src/create_threads.c new file mode 100644 index 0000000..1042a01 --- /dev/null +++ b/philo/src/create_threads.c @@ -0,0 +1,20 @@ +#include "philo.h" + +int create_threads(t_rules *rules) +{ + int i; + t_philo *philo; + + i = 0; + while (i < rules->n_philos) + { + philo = &rules->philos[i]; + philo->pid = malloc(sizeof(pthread_t)); + if (!philo->pid) + return (FAILURE); + if (pthread_create(philo->pid, NULL, &philo_routine, philo)) + return (FAILURE); + i++; + } + return (SUCCESS); +} \ No newline at end of file diff --git a/philo/src/destroy_mutexes.c b/philo/src/destroy_mutexes.c index f17c359..89a7a89 100644 --- a/philo/src/destroy_mutexes.c +++ b/philo/src/destroy_mutexes.c @@ -5,13 +5,15 @@ int destroy_mutexes(t_rules *rules) int i; i = 0; - if (!pthread_mutex_destroy(&rules->death)) + if (pthread_mutex_destroy(rules->death_lock)) return(FAILURE); - if (!pthread_mutex_destroy(&rules->print)) + if (pthread_mutex_destroy(rules->print_lock)) return(FAILURE); while (i < rules->n_philos) { - if (!pthread_mutex_destroy(&rules->forks[i])) + if (pthread_mutex_destroy(&rules->forks[i])) return(FAILURE); + i++; } + return (SUCCESS); } \ No newline at end of file diff --git a/philo/src/free_philos.c b/philo/src/free_philos.c index dc6afd4..1950c1d 100644 --- a/philo/src/free_philos.c +++ b/philo/src/free_philos.c @@ -1,7 +1,9 @@ #include "philo.h" -int free_philos(t_rules *rules) +void free_philos(t_rules *rules) { free(rules->philos); free(rules->forks); + free(rules->print_lock); + free(rules->death_lock); } \ No newline at end of file diff --git a/philo/src/join_threads.c b/philo/src/join_threads.c new file mode 100644 index 0000000..9a2baa8 --- /dev/null +++ b/philo/src/join_threads.c @@ -0,0 +1,17 @@ +#include "philo.h" + +int join_threads(t_rules *rules) +{ + int i; + t_philo *philo; + + i = 0; + while (i < rules->n_philos) + { + philo = &rules->philos[i]; + if (pthread_join(*philo->pid, NULL)) + return (FAILURE); + i++; + } + return (SUCCESS); +} \ No newline at end of file diff --git a/philo/src/main.c b/philo/src/main.c index 5082711..7aba7cc 100644 --- a/philo/src/main.c +++ b/philo/src/main.c @@ -4,12 +4,25 @@ int main(int argc, char *argv[]) { t_rules rules; - if (FAILURE == parse_arguments(argc, argv, &rules)) + if (FAILURE == parse_arguments(argc, argv, &rules)) return (printf(ERROR_USAGE), EXIT_FAILURE); + printf("arguments parsed\n"); if (FAILURE == create_philos(&rules)) - return (printf(ERROR_MALLOC)); + return (printf(ERROR_MALLOC), EXIT_FAILURE); + printf("philos created\n"); if (FAILURE == create_mutexes(&rules)) - return (printf(ERROR_MUTEX)); + return (printf(ERROR_MUTEX), EXIT_FAILURE); + printf("mutexes created\n"); + rules.start_time = get_time(); + if (FAILURE == create_threads(&rules)) + return (printf(ERROR_THREADS), EXIT_FAILURE); + printf("threads created\n"); + if (FAILURE == join_threads(&rules)) + return (printf(ERROR_THREADS), EXIT_FAILURE); + if (FAILURE == destroy_mutexes(&rules)) + return (printf(ERROR_MUTEX), EXIT_FAILURE); + printf("mutexes destroyed\n"); + free_philos(&rules); return(EXIT_SUCCESS); } diff --git a/philo/src/parse_arguments.c b/philo/src/parse_arguments.c index 92b1604..19131d7 100644 --- a/philo/src/parse_arguments.c +++ b/philo/src/parse_arguments.c @@ -2,6 +2,8 @@ int parse_arguments(int argc,char *argv[], t_rules *rules) { + rules->n_must_eat = -1; + printf("argc: %d\n", argc); if (argc != 5 && argc != 6) return (FAILURE); if (!ph_atoi(argv[1], &rules->n_philos)) @@ -14,5 +16,13 @@ int parse_arguments(int argc,char *argv[], t_rules *rules) return (FAILURE); if (argc == 6 && !ph_atoi(argv[5], &rules->n_must_eat)) return (FAILURE); + rules->print_lock = malloc(sizeof(pthread_mutex_t)); + rules->death_lock = malloc(sizeof(pthread_mutex_t)); + if (!rules->print_lock || !rules->death_lock) + return (FAILURE); + rules->forks = malloc(rules->n_philos * sizeof(pthread_mutex_t)); + if (!rules->forks) + return (FAILURE); + print_rules(rules); return (SUCCESS); } \ No newline at end of file diff --git a/philo/src/philo_routine.c b/philo/src/philo_routine.c new file mode 100644 index 0000000..79daba7 --- /dev/null +++ b/philo/src/philo_routine.c @@ -0,0 +1,36 @@ +#include "philo.h" + +void *philo_routine(void *arg) +{ + t_philo *philo; + + philo = (t_philo *)arg; + while (!philo->death && !philo->rules->death + && (philo->n_eat < philo->rules->n_must_eat || philo->rules->n_must_eat == -1)) + { + if (philo->id % 2 == 1) + { + pthread_mutex_lock(philo->r_fork); + print_status(philo, "has taken a fork"); + } + pthread_mutex_lock(philo->l_fork); + print_status(philo, "has taken a fork"); + if (philo->id % 2 == 0) + { + pthread_mutex_lock(philo->r_fork); + print_status(philo, "has taken a fork"); + } + if (!check_alive(philo)) + break ; + print_status(philo, "is eating"); + philo->last_meal = get_time(); + philo->n_eat++; + usleep(philo->rules->time_to_eat * 1000); + pthread_mutex_unlock(philo->l_fork); + pthread_mutex_unlock(philo->r_fork); + print_status(philo, "is sleeping"); + usleep(philo->rules->time_to_sleep * 1000); + print_status(philo, "is thinking"); + } + return (NULL); +} \ No newline at end of file diff --git a/philo/src/print_rules.c b/philo/src/print_rules.c new file mode 100644 index 0000000..5f00b7e --- /dev/null +++ b/philo/src/print_rules.c @@ -0,0 +1,10 @@ +#include "philo.h" + +void print_rules(t_rules *rules) +{ + printf("n_philos: %d\n", rules->n_philos); + printf("time_to_die: %d\n", rules->time_to_die); + printf("time_to_eat: %d\n", rules->time_to_eat); + printf("time_to_sleep: %d\n", rules->time_to_sleep); + printf("n_must_eat: %d\n", rules->n_must_eat); +} \ No newline at end of file diff --git a/philo/src/print_status.c b/philo/src/print_status.c index 5fbd108..28140c0 100644 --- a/philo/src/print_status.c +++ b/philo/src/print_status.c @@ -1,8 +1,8 @@ #include "philo.h" -int print_status(t_philo *philo, char *status) +void print_status(t_philo *philo, char *status) { - pthread_mutex_lock(philo->rules->print); - printf("%d %d %s\n", get_time(), philo->id, status); - pthread_mutex_unlock(philo->rules->print); + pthread_mutex_lock(philo->rules->print_lock); + printf("%d %d %s\n", get_time() - philo->rules->start_time, philo->id, status); + pthread_mutex_unlock(philo->rules->print_lock); } \ No newline at end of file