Add handling for times_must_eat

3 files changed, 41 insertions, 17 deletions

diff --git a/philo/include/philo.h b/philo/include/philo.h
index faf1bbf..b4db15b 100644
--- a/philo/include/philo.h
+++ b/philo/include/philo.h
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2025/01/17 10:23:19 by dkaiser           #+#    #+#             */
-/*   Updated: 2025/01/18 13:12:06 by dkaiser          ###   ########.fr       */
+/*   Updated: 2025/01/18 16:57:23 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -35,6 +35,8 @@ typedef struct s_phdata
     int time_to_eat;
     int time_to_sleep;
     int times_must_eat;
+    int philos_must_eat;
+    pthread_mutex_t pme_mutex;
     int simulation_running;
     t_fork *forks;
 } t_phdata;
@@ -43,7 +45,7 @@ typedef struct s_philo
 {
     int id;
     int last_time_eaten;
-    int times_eaten;
+    int times_must_eat;
     int is_alive;
     pthread_t thread;
     t_phdata *data;
diff --git a/philo/src/main.c b/philo/src/main.c
index 4e99d1c..be9e1b7 100644
--- a/philo/src/main.c
+++ b/philo/src/main.c
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2025/01/14 17:13:30 by dkaiser           #+#    #+#             */
-/*   Updated: 2025/01/18 13:06:09 by dkaiser          ###   ########.fr       */
+/*   Updated: 2025/01/18 16:59:24 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,7 +20,7 @@ int load_data(t_phdata *data, int argc, char *argv[])
     data->time_to_eat = ft_atoi(argv[3]);
     data->time_to_sleep = ft_atoi(argv[4]);
     if (argc == 6)
-        data->times_must_eat = ft_atoi(argv[2]);
+        data->times_must_eat = ft_atoi(argv[5]);
     else
         data->times_must_eat = -1;
     if (data->nbr_of_philos <= 0)
@@ -31,6 +31,7 @@ int load_data(t_phdata *data, int argc, char *argv[])
         return (ft_err("tte can't be negative"));
     if (data->time_to_sleep < 0)
         return (ft_err("tts can't be negative"));
+    data->philos_must_eat = data->nbr_of_philos;
     return (EXIT_SUCCESS);
 }
 
@@ -49,17 +50,28 @@ int init(t_philo **philos, t_phdata *data)
         return (ft_err(ERR_MALLOC));
     }
     i = 0;
+    result = pthread_mutex_init(&(data->forks[i].mutex), NULL);
+    if (result != 0)
+    {
+        free(*philos);
+        free(data->forks);
+        return (result);
+    }
     while (i < data->nbr_of_philos)
     {
         (*philos)[i].id = i + 1;
         (*philos)[i].is_alive = 1;
-        (*philos)[i].times_eaten = 0;
+        (*philos)[i].times_must_eat = data->times_must_eat;
         (*philos)[i].data = data;
         (*philos)[i].last_time_eaten = ft_cur_time_in_ms();
         data->forks[i].available = 1;
         result = pthread_mutex_init(&(data->forks[i].mutex), NULL);
         if (result != 0)
+        {
+            free(*philos);
+            free(data->forks);
             return (result);
+        }
         i++;
     }
     return (EXIT_SUCCESS);
diff --git a/philo/src/simulation.c b/philo/src/simulation.c
index 943d38c..75bbe12 100644
--- a/philo/src/simulation.c
+++ b/philo/src/simulation.c
@@ -6,17 +6,22 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2025/01/17 14:38:04 by dkaiser           #+#    #+#             */
-/*   Updated: 2025/01/18 16:37:14 by dkaiser          ###   ########.fr       */
+/*   Updated: 2025/01/18 17:02:27 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "philo.h"
 
-void philo_die(t_philo *philo)
+int philo_die(t_philo *philo)
 {
+    if (ft_cur_time_in_ms() > philo->last_time_eaten + philo->data->time_to_die)
+    {
             philo->is_alive = 0;
             ft_log(philo->id, "has died");
             philo->data->simulation_running = 0;
+            return (1);
+    }
+    return (0);
 }
 
 void philo_eat(t_philo *philo)
@@ -25,17 +30,15 @@ void philo_eat(t_philo *philo)
     t_fork *right_fork;
     int started_eating;
     int tte;
-    int ttd;
 
     left_fork = &philo->data->forks[philo->id - 1];
     right_fork = &philo->data->forks[philo->id % philo->data->nbr_of_philos];
-    ttd = philo->data->time_to_die;
     while (!left_fork->available || !right_fork->available)
     {
         if (!philo->data->simulation_running)
             return;
-        if (ft_cur_time_in_ms() > philo->last_time_eaten + ttd)
-            return (philo_die(philo));
+        if (philo_die(philo))
+            return ;
         usleep(1000);
     }
     pthread_mutex_lock(&left_fork->mutex);
@@ -50,11 +53,12 @@ void philo_eat(t_philo *philo)
         started_eating = ft_cur_time_in_ms();
         tte = philo->data->time_to_eat;
         philo->last_time_eaten = started_eating;
+        philo->times_must_eat -= 1;
         ft_log(philo->id, "is eating");
         while (ft_cur_time_in_ms() < started_eating + tte)
         {
-            if (ft_cur_time_in_ms() > philo->last_time_eaten + ttd)
-                return (philo_die(philo));
+            if (philo_die(philo))
+                return;
             usleep(1000);
         }
         left_fork->available = 1;
@@ -68,16 +72,14 @@ void philo_sleep(t_philo *philo)
 {
     int started_sleeping;
     int tts;
-    int ttd;
 
     started_sleeping = ft_cur_time_in_ms();
     tts = philo->data->time_to_sleep;
-    ttd = philo->data->time_to_die;
     ft_log(philo->id, "is sleeping");
     while (ft_cur_time_in_ms() < started_sleeping + tts)
     {
-        if (ft_cur_time_in_ms() > philo->last_time_eaten + ttd)
-            return (philo_die(philo));
+        if (philo_die(philo))
+            return;
         usleep(1000);
     }
 }
@@ -100,6 +102,14 @@ int *process_philo(void *arg)
     while (philo->data->simulation_running)
     {
         philo_eat(philo);
+        if (philo->times_must_eat == 0)
+        {
+            pthread_mutex_lock(&philo->data->pme_mutex);
+            philo->data->philos_must_eat -= 1;
+            if (philo->data->philos_must_eat <= 0)
+                philo->data->simulation_running = 0;
+            pthread_mutex_unlock(&philo->data->pme_mutex);
+        }
         if (!philo->data->simulation_running)
             break;
         philo_sleep(philo);