From 95ebe2b00bd6026cd0b67f84fd75fbf8885ee7c7 Mon Sep 17 00:00:00 2001
From: whaffman <whaffman@student.codam.nl>
Date: Tue, 28 Jan 2025 17:24:01 +0100
Subject: [PATCH] working and norminette

---
 philo/Makefile                 |  1 -
 philo/inc/philo.h              |  5 ++---
 philo/src/check_philos.c       |  6 ++----
 philo/src/create_mutexes.c     |  2 +-
 philo/src/create_philos.c      |  2 +-
 philo/src/destroy_mutexes.c    | 19 ++++++------------
 philo/src/free_philos.c        |  3 ++-
 philo/src/ft_min.c             |  2 +-
 philo/src/get_death.c          |  2 +-
 philo/src/join_threads.c       |  1 +
 philo/src/main.c               | 15 ++++++++++-----
 philo/src/monitor_routine.c    |  2 --
 philo/src/parse_arguments.c    |  2 +-
 philo/src/philo_die.c          |  2 --
 philo/src/philo_eat.c          | 29 +++++++++++++++++-----------
 philo/src/philo_routine.c      | 35 ++++++++++++++++++++++++++++------
 philo/src/set_death.c          |  3 +--
 philo/src/synchronize_philos.c |  5 +++++
 philo/src/utils/print_status.c | 19 ++++++++++--------
 19 files changed, 92 insertions(+), 63 deletions(-)

diff --git a/philo/Makefile b/philo/Makefile
index 9c2511e..12c482a 100644
--- a/philo/Makefile
+++ b/philo/Makefile
@@ -26,7 +26,6 @@ RM = rm -rf
 
 INCLUDES = -I./$(INC_PATH)
 CFLAGS = -Wall -Wextra -Werror -MMD -g 
-
 UNAME_S	:= $(shell uname -s)
 ifeq ($(UNAME_S),Linux)
 	LDLIBS	:= -pthread
diff --git a/philo/inc/philo.h b/philo/inc/philo.h
index 512919c..081f825 100644
--- a/philo/inc/philo.h
+++ b/philo/inc/philo.h
@@ -26,8 +26,6 @@
 
 # define START_DELAY 0
 
-# define ERROR_USAGE "Usage: ./philo number_of_philosophers time_to_die " \
-					"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"
@@ -91,6 +89,7 @@ void	set_finished(t_rules *rules);
 int		get_finished(t_rules *rules);
 void	synchronize_philos(t_philo *philo);
 int		philo_sleep(t_philo *philo, int time);
-
+void	unlock_forks(t_philo *philo);
+void	take_forks(t_philo *philo);
 
 #endif
diff --git a/philo/src/check_philos.c b/philo/src/check_philos.c
index 7595ebc..f5ffc1a 100644
--- a/philo/src/check_philos.c
+++ b/philo/src/check_philos.c
@@ -29,15 +29,13 @@ int	check_philos(t_rules *rules)
 		{
 			philo_die(&rules->philos[i]);
 			set_finished(rules);
+			pthread_mutex_unlock(rules->philos[i].last_meal_lock);
 			return (FAILURE);
 		}
 		pthread_mutex_unlock(rules->philos[i].last_meal_lock);
 		i++;
 	}
 	if (min_n_eat >= rules->n_must_eat)
-	{
-		set_finished(rules);
-		return (FAILURE);
-	}
+		return (set_finished(rules), FAILURE);
 	return (SUCCESS);
 }
diff --git a/philo/src/create_mutexes.c b/philo/src/create_mutexes.c
index fbcb2b1..2cc172d 100644
--- a/philo/src/create_mutexes.c
+++ b/philo/src/create_mutexes.c
@@ -12,7 +12,7 @@
 
 #include "philo.h"
 
-int create_philo_mutexes(t_philo *philo)
+int	create_philo_mutexes(t_philo *philo)
 {
 	philo->death_lock = malloc(sizeof(pthread_mutex_t));
 	philo->last_meal_lock = malloc(sizeof(pthread_mutex_t));
diff --git a/philo/src/create_philos.c b/philo/src/create_philos.c
index 0826722..73b1528 100644
--- a/philo/src/create_philos.c
+++ b/philo/src/create_philos.c
@@ -15,7 +15,7 @@
 int	create_philos(t_rules *rules)
 {
 	int		i;
-	t_philo *philo;
+	t_philo	*philo;
 
 	i = 0;
 	rules->philos = malloc(rules->n_philos * sizeof(t_philo));
diff --git a/philo/src/destroy_mutexes.c b/philo/src/destroy_mutexes.c
index 73cb9fe..be523d9 100644
--- a/philo/src/destroy_mutexes.c
+++ b/philo/src/destroy_mutexes.c
@@ -17,21 +17,14 @@ int	destroy_mutexes(t_rules *rules)
 	int	i;
 
 	i = 0;
-	if (pthread_mutex_destroy(rules->finished_lock))
-		return (FAILURE);
-	if (pthread_mutex_destroy(rules->print_lock))
-		return (FAILURE);
+	pthread_mutex_destroy(rules->finished_lock);
+	pthread_mutex_destroy(rules->print_lock);
 	while (i < rules->n_philos)
 	{
-		if (pthread_mutex_destroy(&rules->forks[i]))
-			return (printf("1"), FAILURE);
-		if (pthread_mutex_destroy(rules->philos[i].death_lock))
-			return (printf("2"), FAILURE);
-		// pthread_mutex_lock(rules->philos[i].last_meal_lock);
-		if (pthread_mutex_destroy(rules->philos[i].last_meal_lock))
-			return (printf("3: %d\n", i), perror("Error"), FAILURE);
-		if (pthread_mutex_destroy(rules->philos[i].n_eat_lock))
-			return (printf("4"), FAILURE);
+		pthread_mutex_destroy(&rules->forks[i]);
+		pthread_mutex_destroy(rules->philos[i].death_lock);
+		pthread_mutex_destroy(rules->philos[i].last_meal_lock);
+		pthread_mutex_destroy(rules->philos[i].n_eat_lock);
 		i++;
 	}
 	return (SUCCESS);
diff --git a/philo/src/free_philos.c b/philo/src/free_philos.c
index 84bbf6b..a5de9a7 100644
--- a/philo/src/free_philos.c
+++ b/philo/src/free_philos.c
@@ -12,9 +12,10 @@
 
 #include "philo.h"
 
-void free_philos(t_rules *rules)
+void	free_philos(t_rules *rules)
 {
 	int	i;
+
 	i = 0;
 	while (i < rules->n_philos)
 	{
diff --git a/philo/src/ft_min.c b/philo/src/ft_min.c
index 8d0cef7..e2d9908 100644
--- a/philo/src/ft_min.c
+++ b/philo/src/ft_min.c
@@ -10,7 +10,7 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-int ft_min(int a, int b)
+int	ft_min(int a, int b)
 {
 	if (a < b)
 		return (a);
diff --git a/philo/src/get_death.c b/philo/src/get_death.c
index ba97962..96bf1a3 100644
--- a/philo/src/get_death.c
+++ b/philo/src/get_death.c
@@ -12,7 +12,7 @@
 
 #include "philo.h"
 
-int get_death(t_philo *philo)
+int	get_death(t_philo *philo)
 {
 	int	death;
 
diff --git a/philo/src/join_threads.c b/philo/src/join_threads.c
index cf6175e..fbac5f3 100644
--- a/philo/src/join_threads.c
+++ b/philo/src/join_threads.c
@@ -27,5 +27,6 @@ int	join_threads(t_rules *rules)
 	}
 	if (pthread_join(*rules->monitor, NULL))
 		return (FAILURE);
+	usleep(14000);
 	return (SUCCESS);
 }
diff --git a/philo/src/main.c b/philo/src/main.c
index b69fde8..32d43e3 100644
--- a/philo/src/main.c
+++ b/philo/src/main.c
@@ -12,12 +12,18 @@
 
 #include "philo.h"
 
-int main(int argc, char *argv[])
+void	print_usage(void)
 {
-    t_rules rules;
+	printf("Usage: ./philo n_philos time_to_die"
+		"time_to_eat time_to_sleep [n_must_eat]\n");
+}
+
+int	main(int argc, char *argv[])
+{
+	t_rules	rules;
 
 	if (FAILURE == parse_arguments(argc, argv, &rules))
-		return (printf(ERROR_USAGE), EXIT_FAILURE);
+		return (print_usage(), EXIT_FAILURE);
 	if (FAILURE == create_philos(&rules))
 		return (printf(ERROR_MALLOC), EXIT_FAILURE);
 	if (FAILURE == create_mutexes(&rules))
@@ -29,9 +35,8 @@ int main(int argc, char *argv[])
 	pthread_mutex_unlock(rules.finished_lock);
 	if (FAILURE == join_threads(&rules))
 		return (printf(ERROR_THREADS), EXIT_FAILURE);
-
 	if (FAILURE == destroy_mutexes(&rules))
 		return (printf(ERROR_MUTEX), EXIT_FAILURE);
 	free_philos(&rules);
-    return (EXIT_SUCCESS);
+	return (EXIT_SUCCESS);
 }
diff --git a/philo/src/monitor_routine.c b/philo/src/monitor_routine.c
index c9d6f4b..61a144f 100644
--- a/philo/src/monitor_routine.c
+++ b/philo/src/monitor_routine.c
@@ -12,7 +12,6 @@
 
 #include "philo.h"
 
-
 void	*monitor_routine(void *arg)
 {
 	t_rules	*rules;
@@ -20,7 +19,6 @@ void	*monitor_routine(void *arg)
 	rules = (t_rules *)arg;
 	while (1)
 	{
-
 		if (!check_philos(rules))
 		{
 			break ;
diff --git a/philo/src/parse_arguments.c b/philo/src/parse_arguments.c
index 51b94ad..021656a 100644
--- a/philo/src/parse_arguments.c
+++ b/philo/src/parse_arguments.c
@@ -12,7 +12,7 @@
 
 #include "philo.h"
 
-int parse_arguments(int argc, char *argv[], t_rules *rules)
+int	parse_arguments(int argc, char *argv[], t_rules *rules)
 {
 	rules->n_must_eat = -1;
 	if (argc != 5 && argc != 6)
diff --git a/philo/src/philo_die.c b/philo/src/philo_die.c
index 01888ed..17687ca 100644
--- a/philo/src/philo_die.c
+++ b/philo/src/philo_die.c
@@ -19,6 +19,4 @@ void	philo_die(t_philo *philo)
 	philo->death = 1;
 	pthread_mutex_unlock(philo->death_lock);
 	set_finished(philo->rules);
-	pthread_mutex_unlock(philo->l_fork);
-	pthread_mutex_unlock(philo->r_fork);
 }
diff --git a/philo/src/philo_eat.c b/philo/src/philo_eat.c
index d2034a5..d7458ea 100644
--- a/philo/src/philo_eat.c
+++ b/philo/src/philo_eat.c
@@ -12,7 +12,7 @@
 
 #include "philo.h"
 
-int	philo_eat(t_philo *philo)
+void	take_forks(t_philo *philo)
 {
 	if (philo->id % 2 == 1)
 	{
@@ -26,14 +26,21 @@ int	philo_eat(t_philo *philo)
 		pthread_mutex_lock(philo->r_fork);
 		print_status(philo, "has taken a fork");
 	}
-	if (get_finished(philo->rules))
-		return (FAILURE);
-	print_status(philo, "is eating");
-	pthread_mutex_lock(philo->last_meal_lock);
-	philo->last_meal = get_time();
-	pthread_mutex_unlock(philo->last_meal_lock);
-	pthread_mutex_lock(philo->n_eat_lock);
-	philo->n_eat++;
-	pthread_mutex_unlock(philo->n_eat_lock);
-	return (SUCCESS);
+}
+
+int	philo_eat(t_philo *philo)
+{
+	take_forks(philo);
+	if (get_finished(philo->rules))
+		return (unlock_forks(philo), FAILURE);
+	pthread_mutex_lock(philo->last_meal_lock);
+	pthread_mutex_lock(philo->n_eat_lock);
+	print_status(philo, "is eating");
+	philo->last_meal = get_time();
+	philo->n_eat++;
+	pthread_mutex_unlock(philo->last_meal_lock);
+	pthread_mutex_unlock(philo->n_eat_lock);
+	if (!philo_sleep(philo, philo->rules->time_to_eat))
+		return (unlock_forks(philo), FAILURE);
+	return (unlock_forks(philo), SUCCESS);
 }
diff --git a/philo/src/philo_routine.c b/philo/src/philo_routine.c
index 541688b..fdb24ea 100644
--- a/philo/src/philo_routine.c
+++ b/philo/src/philo_routine.c
@@ -12,27 +12,50 @@
 
 #include "philo.h"
 
+void	unlock_forks(t_philo *philo)
+{
+	pthread_mutex_unlock(philo->l_fork);
+	pthread_mutex_unlock(philo->r_fork);
+}
+
+int	think_time(t_rules *rules)
+{
+	int	res;
+
+	res = (rules->time_to_die - rules->time_to_eat - rules->time_to_sleep) / 5;
+	return (res);
+}
+
+void	one_philo(t_philo *philo)
+{
+	pthread_mutex_lock(philo->l_fork);
+	print_status(philo, "has taken a fork");
+	pthread_mutex_unlock(philo->l_fork);
+	philo_sleep(philo, philo->rules->time_to_die);
+}
+
 void	*philo_routine(void *arg)
 {
 	t_philo	*philo;
 
 	philo = (t_philo *)arg;
 	synchronize_philos(philo);
+	if (philo->rules->n_philos == 1)
+	{
+		one_philo(philo);
+		return (NULL);
+	}
 	while (!philo->death && !get_finished(philo->rules))
 	{
 		if (!philo_eat(philo))
 			break ;
-		if (!philo_sleep(philo, philo->rules->time_to_eat))
-			break ;
-		pthread_mutex_unlock(philo->l_fork);
-		pthread_mutex_unlock(philo->r_fork);
 		if (!philo->death && !get_finished(philo->rules))
 			print_status(philo, "is sleeping");
 		if (!philo_sleep(philo, philo->rules->time_to_sleep))
 			break ;
-		if(!philo->death && !get_finished(philo->rules))
+		if (!philo->death && !get_finished(philo->rules))
 			print_status(philo, "is thinking");
-		if (!philo_sleep(philo, (philo->rules->time_to_die - philo->rules->time_to_eat - philo->rules->time_to_sleep) / 3))
+		if (!philo_sleep(philo, think_time(philo->rules)))
 			break ;
 	}
 	return (NULL);
diff --git a/philo/src/set_death.c b/philo/src/set_death.c
index d9d6ec0..a206a2a 100644
--- a/philo/src/set_death.c
+++ b/philo/src/set_death.c
@@ -12,8 +12,7 @@
 
 #include "philo.h"
 
-
-void set_death(t_philo *philo)
+void	set_death(t_philo *philo)
 {
 	pthread_mutex_lock(philo->death_lock);
 	philo->death = 1;
diff --git a/philo/src/synchronize_philos.c b/philo/src/synchronize_philos.c
index c7c76c9..d9d5f25 100644
--- a/philo/src/synchronize_philos.c
+++ b/philo/src/synchronize_philos.c
@@ -24,4 +24,9 @@ void	synchronize_philos(t_philo *philo)
 		print_status(philo, "is thinking");
 		usleep(philo->rules->time_to_eat * 10);
 	}
+	else if (philo->id == philo->rules->n_philos && philo->rules->n_philos > 1)
+	{
+		print_status(philo, "is thinking");
+		usleep(philo->rules->time_to_eat * 10);
+	}
 }
diff --git a/philo/src/utils/print_status.c b/philo/src/utils/print_status.c
index 286b56f..7a10913 100644
--- a/philo/src/utils/print_status.c
+++ b/philo/src/utils/print_status.c
@@ -14,12 +14,15 @@
 
 void	print_status(t_philo *philo, char *status)
 {
-	if (philo->death)
-		return ;
-	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);
+	pthread_mutex_lock(philo->death_lock);
+	if (!philo->death)
+	{
+		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);
+	}
+	pthread_mutex_unlock(philo->death_lock);
 }