starnakin/42_philosopher
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: starnakin:f51039c735a4926ff5f4f970f2d8295913545568
Branches Tags
starnakin:master
..
compare: starnakin:master
Branches Tags
starnakin:master

30 Commits
f51039c735 ... master

Author SHA1 Message Date
Camille Chauvet
6e383ed9d6 ok j'arrette de troll 2023-06-01 14:24:36 +02:00
Camille Chauvet
b0f5095569 ok g troll 2023-06-01 14:23:15 +02:00
Camille Chauvet
f88abe9631 dsfsd 2023-05-25 17:31:02 +02:00
Camille Chauvet
984f4c59bf norm 2023-05-25 15:24:35 +02:00
Camille Chauvet
61b599b9f2 opti 2023-05-25 15:24:17 +02:00
Camille Chauvet
f1927d349b fix: add stdbool remove useless memset 2023-05-25 14:57:43 +02:00
Camille Chauvet
1b3c96b38d fix: data race 2023-05-24 16:19:21 +02:00
Camille Chauvet
550851a5c8 Merge branch 'master' of git.chauvet.pro:starnakin/42_Philosopher 2023-05-24 13:55:43 +00:00
Camille Chauvet
0956af87ca fix: data race 2023-05-24 15:55:19 +02:00
Camille Chauvet
7e5d4af478 fix: support only > 0 number 2023-05-17 13:44:38 +02:00
Camille Chauvet
008b30e12c fix: add 0 to the print 2023-05-17 13:37:20 +02:00
Camille Chauvet
aefb6ceec0 bozosujet 2023-05-17 13:28:42 +02:00
Camille Chauvet
8371b01390 clean: remove compile file 2023-05-17 13:26:16 +02:00
Camille Chauvet
3e9f5e829f fix: replace write by printf 2023-05-17 13:25:34 +02:00
Camille Chauvet
958448ca4e finish2 2023-05-16 11:26:03 +00:00
Camille Chauvet
291c7b40b1 finish 2023-05-16 11:25:20 +00:00
Camille Chauvet
b940b46924 ?fix 2023-05-05 16:59:36 +00:00
Camille Chauvet
5c309f2f02 fix: sleeptime and eat time if time to die < time eat|sleep 2023-05-02 11:44:16 +00:00
Camille Chauvet
796e186c36 clean: norm 2023-04-27 12:05:14 +00:00
Camille Chauvet
7e7538aa40 fix: do not print message exit eating 2023-04-25 15:10:25 +00:00
Camille Chauvet
41bd1149d8 fix: time mix 2023-04-25 15:01:54 +00:00
Camille Chauvet
69e34424c1 fix: philo alone died now 2023-04-25 14:56:57 +00:00
Camille Chauvet
02a80af93b fix: stop when nb_meal is reached 2023-04-25 14:50:01 +00:00
Camille Chauvet
891431c1be fix: work with odd numbers of philos 2023-04-25 14:39:07 +00:00
Camille Chauvet
d6aee63600 fix 2023-04-25 14:33:35 +00:00
Camille Chauvet
07d4cd05c1 core: transition from bool[] to mutex[] for the fork tab 2023-04-25 14:32:42 +00:00
Camille Chauvet
4f138b78e3 clean: remove useless file 2023-04-25 14:31:12 +00:00
Camille Chauvet
6759520714 transition from printf to write 2023-04-25 14:30:21 +00:00
Camille Chauvet
531d3146e4 merge 2023-04-25 11:30:55 +00:00
Camille Chauvet
b553e5af97 fix: stop when philo has enough eat 2023-04-20 13:16:02 +00:00
35 changed files with 719 additions and 501 deletions
Expand all files Collapse all files

61
data.c
View File

@ -1,61 +0,0 @@
#include <pthread.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <unistd.h>
#include "./data.h"
#include "philo.h"
#include "philos.h"
#include "struct.h"
#include <string.h>
bool data_init(t_data *data)
{
data->forks = malloc(sizeof(bool) * data->nb_philos);
if (data->forks == NULL)
return (1);
memset(data->forks, 1, data->nb_philos);
data->philos = malloc(sizeof(t_philo) * data->nb_philos);
if (data->philos == NULL)
{
free(data->forks);
return (1);
}
data->threads = malloc(sizeof(pthread_t) * data->nb_philos);
if (data->forks == NULL)
{
free(data->philos);
free(data->forks);
return (1);
}
pthread_mutex_init(&data->forks_mutex, NULL);
pthread_mutex_init(&data->stop_mutex, NULL);
pthread_mutex_init(&data->print_mutex, NULL);
data->stop = 0;
return (0);
}
void data_destroyer(t_data *data)
{
size_t i;
t_philo *philo;
bool stop;
i = 0;
while (i < data->nb_philos)
{
philo = data->philos[i];
pthread_mutex_lock(&philo->stop_mutex);
stop = philo->stop;
pthread_mutex_unlock(&philo->stop_mutex);
if (stop)
i++;
usleep(1000);
}
pthread_mutex_destroy(&data->forks_mutex);
pthread_mutex_destroy(&data->stop_mutex);
pthread_mutex_destroy(&data->print_mutex);
free(data->threads);
free(data->forks);
philos_destroyer(data);
}

5
data.h
View File

@ -1,5 +0,0 @@
# include "./struct.h"
bool data_init(t_data *data);
void data_destroyer(t_data *data);

50
parsing.c
View File

@ -1,50 +0,0 @@
#include "utils/utils.h"
#include "./data.h"
#include <stdbool.h>
#include <stddef.h>
#include <unistd.h>
static bool check_amount_of_argument(size_t n)
{
return (n < 4 || n > 5);
}
static bool check_value(char **av, size_t n)
{
size_t i;
i = 0;
while (i < n)
{
if (ft_isnum(av[i]) == 0)
return (1);
i++;
}
return (0);
}
static void set_value(t_data *data, char **args, size_t n)
{
data->nb_philos = ft_atoi(args[0]);
data->life_expectency = ft_atoi(args[1]);
data->eat_time = ft_atoi(args[2]);
data->sleep_time = ft_atoi(args[3]);
if (n == 5)
data->nb_meals = ft_atoi(args[4]);
else
data->nb_meals = -1;
}
bool parsing(t_data *data, char **args, size_t n)
{
if (check_amount_of_argument(n)
|| check_value(args, n))
{
write(2, "Argument error !\n", 16);
return (1);
}
set_value(data, args, n);
if (data->nb_philos == 0)
write(2, "Argument error !\n", 16);
return (data->nb_philos == 0);
}

4
parsing.h
View File

@ -1,4 +0,0 @@
#include "./data.h"
bool parsing(t_data *data, char **args, size_t n);

157
philo.c
View File

@ -1,157 +0,0 @@
#include "philo.h"
#include "struct.h"
#include "time.h"
#include "data.h"
#include <pthread.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <unistd.h>
#include "./print.h"
void philo_destroyer(t_philo *philo)
{
pthread_mutex_destroy(&philo->nb_meal_mutex);
pthread_mutex_destroy(&philo->last_sleep_mutex);
pthread_mutex_destroy(&philo->last_eat_mutex);
free(philo);
}
bool check(t_philo *philo, t_data *data)
{
bool stop;
pthread_mutex_lock(&data->stop_mutex);
stop = data->stop;
pthread_mutex_unlock(&data->stop_mutex);
if (stop)
{
pthread_mutex_lock(&philo->stop_mutex);
philo->stop = 1;
pthread_mutex_unlock(&philo->stop_mutex);
}
return (stop);
}
void eat(t_philo *philo, t_data *data)
{
print_take_a_fork(philo);
print_take_a_fork(philo);
print_eating(philo);
pthread_mutex_lock(&philo->last_eat_mutex);
if (get_time() - philo->last_eat + data->eat_time > data->life_expectency)
{
pthread_mutex_unlock(&philo->last_eat_mutex);
usleep((data->life_expectency -
(get_time() - philo->last_eat)) * 1000);
return ;
}
else
usleep(data->eat_time * 1000);
pthread_mutex_unlock(&philo->last_eat_mutex);
pthread_mutex_lock(&philo->nb_meal_mutex);
philo->nb_meal++;
pthread_mutex_unlock(&philo->nb_meal_mutex);
pthread_mutex_lock(&data->forks_mutex);
data->forks[philo->id] = 1;
data->forks[(philo->id + 1) % data->nb_philos] = 1;
pthread_mutex_unlock(&data->forks_mutex);
}
bool philo_eat(t_philo *philo, t_data *data)
{
bool left_fork;
bool right_fork;
left_fork = 0;
right_fork = 0;
while (left_fork == 0 || right_fork == 0)
{
if (check(philo, data))
return (1);
pthread_mutex_lock(&data->forks_mutex);
left_fork = data->forks[philo->id];
if (((philo->id + 1) % data->nb_philos) != philo->id)
right_fork = data->forks[(philo->id + 1) % data->nb_philos];
if (right_fork && left_fork)
{
data->forks[philo->id] = 0;
data->forks[(philo->id + 1) % data->nb_philos] = 0;
}
pthread_mutex_unlock(&data->forks_mutex);
usleep(10);
}
eat(philo, data);
pthread_mutex_lock(&philo->last_eat_mutex);
philo->last_eat = get_time();
pthread_mutex_unlock(&philo->last_eat_mutex);
return (0);
}
void philo_sleep(t_data *data, t_philo *philo)
{
print_sleeping(philo);
pthread_mutex_lock(&philo->last_sleep_mutex);
// printf("time=%zu, last_sleep=%zu, sleep_time=%zu, life_expectency=%zu\n", get_time(), philo->last_sleep, data->sleep_time, data->life_expectency);
if (get_time() - philo->last_sleep + data->sleep_time > data->life_expectency)
{
pthread_mutex_unlock(&philo->last_sleep_mutex);
// printf("rompiche=%zu\n", (data->life_expectency -
// (get_time() - philo->last_sleep)));
usleep((data->life_expectency -
(get_time() - philo->last_sleep)) * 1000);
return ;
}
else
usleep(data->sleep_time * 1000);
philo->last_sleep = get_time();
pthread_mutex_unlock(&philo->last_sleep_mutex);
}
void *philo_routine(void *arg)
{
t_philo *philo;
t_data *data;
philo = arg;
data = philo->data;
print_thinking(philo);
usleep(philo->id * (data->life_expectency / data->nb_philos));
while (true)
{
if (check(philo, data))
return (NULL);
if (philo_eat(philo, data))
return (NULL);
if (check(philo, data))
return (NULL);
philo_sleep(data, philo);
if (check(philo, data))
return (NULL);
print_thinking(philo);
}
return (NULL);
}
t_philo *philo_init(t_data *data)
{
t_philo *philo;
static size_t id = 0;
philo = malloc(sizeof(t_philo));
if (philo == NULL)
return (NULL);
philo->id = id++;
philo->data = data;
philo->nb_meal = 0;
philo->stop = 0;
philo->last_eat = get_time();
philo->last_sleep = get_time();
pthread_mutex_init(&philo->nb_meal_mutex, NULL);
pthread_mutex_init(&philo->last_eat_mutex, NULL);
pthread_mutex_init(&philo->last_sleep_mutex, NULL);
pthread_mutex_init(&philo->stop_mutex, NULL);
return (philo);
}

2
Makefile → philo/Makefile
View File

@ -4,8 +4,10 @@ SRCS = parsing.c \
main.c \
time.c \
print.c \
print2.c \
data.c \
philo.c \
philo_routine.c \
philos.c \
threads.c

73
philo/data.c Normal file
View File

@ -0,0 +1,73 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* data.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:28:36 by cchauvet #+# #+# */
/* Updated: 2023/05/25 14:48:52 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./data.h"
#include "philo.h"
#include "philos.h"
#include <unistd.h>
#include <stdbool.h>
bool data_init(t_data *data)
{
ssize_t i;
data->stop = 0;
data->forks = malloc(sizeof(pthread_mutex_t) * data->nb_philos);
if (data->forks == NULL)
return (1);
data->philos = malloc(sizeof(t_philo) * data->nb_philos);
if (data->philos == NULL)
free(data->forks);
if (data->philos == NULL)
return (1);
data->threads = malloc(sizeof(pthread_t) * data->nb_philos);
if (data->forks == NULL)
{
free(data->philos);
free(data->forks);
return (1);
}
i = -1;
while (++i < (ssize_t) data->nb_philos)
pthread_mutex_init(&data->forks[i], NULL);
pthread_mutex_init(&data->stop_mutex, NULL);
pthread_mutex_init(&data->print_mutex, NULL);
return (0);
}
void data_destroyer(t_data *data)
{
ssize_t i;
t_philo *philo;
bool stop;
i = 0;
while (i < (ssize_t) data->nb_philos)
{
philo = data->philos[i];
pthread_mutex_lock(&philo->stop_mutex);
stop = philo->stop;
pthread_mutex_unlock(&philo->stop_mutex);
if (stop)
i++;
usleep(1000);
}
usleep(1000);
i = -1;
while (++i < (ssize_t) data->nb_philos)
pthread_mutex_destroy(&data->forks[i]);
pthread_mutex_destroy(&data->stop_mutex);
pthread_mutex_destroy(&data->print_mutex);
free(data->threads);
free(data->forks);
philos_destroyer(data);
}

37
philo/data.h Normal file
View File

@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* data.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:33:06 by cchauvet #+# #+# */
/* Updated: 2023/05/25 15:26:38 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef DATA_H
# define DATA_H
# include <pthread.h>
# include <sys/types.h>
# include <stdbool.h>
typedef struct s_data
{
size_t eat_time;
size_t sleep_time;
size_t life_expectency;
size_t nb_philos;
long nb_meals;
void **philos;
pthread_t *threads;
pthread_mutex_t *forks;
pthread_mutex_t stop_mutex;
bool stop;
pthread_mutex_t print_mutex;
} t_data;
bool data_init(t_data *data);
void data_destroyer(t_data *data);
size_t get_min_meal(t_data *data);
#endif

49
main.c → philo/main.c
View File

@ -1,3 +1,15 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* main.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:33:25 by cchauvet #+# #+# */
/* Updated: 2023/05/25 16:34:22 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include <pthread.h>
#include <stdbool.h>
#include <stddef.h>
@ -10,7 +22,7 @@
#include "./threads.h"
#include "./time.h"
#include "./print.h"
#include "./struct.h"
#include "./utils/utils.h"
size_t get_min_meal(t_data *data)
{
@ -44,20 +56,12 @@ void stop(t_data *data)
pthread_mutex_unlock(&data->stop_mutex);
}
void *check_routine(t_data *data)
int routine(t_data *data)
{
size_t i;
bool ok;
t_philo *philo;
while (true)
{
if ((ssize_t) get_min_meal(data) == data->nb_meals)
{
stop(data);
printf("g pu faim\n");
return (NULL);
}
i = 0;
while (i < data->nb_philos)
{
@ -67,24 +71,25 @@ void *check_routine(t_data *data)
pthread_mutex_unlock(&philo->last_eat_mutex);
if (ok == 1)
{
print_died(philo);
stop(data);
return (NULL);
}
pthread_mutex_lock(&philo->last_sleep_mutex);
// printf("time=%zu, last_sleep=%zu, life_expectency=%zu\n", get_time(), philo->last_sleep, data->life_expectency);
ok = !(philo->last_sleep + data->life_expectency > get_time());
pthread_mutex_unlock(&philo->last_sleep_mutex);
if (ok == 1)
{
print_died(philo);
stop(data);
return (NULL);
return (1);
}
i++;
usleep(10);
}
return (0);
}
void *check_routine(t_data *data)
{
while (data->stop == 0)
{
if (routine(data))
{
return (NULL);
}
}
return (NULL);
}
int main(int ac, char **av)

64
philo/parsing.c Normal file
View File

@ -0,0 +1,64 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parsing.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:34:57 by cchauvet #+# #+# */
/* Updated: 2023/05/17 13:43:29 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "utils/utils.h"
#include "./data.h"
#include <stdbool.h>
#include <stddef.h>
#include <unistd.h>
static bool check_amount_of_argument(size_t n)
{
return (n < 4 || n > 5);
}
static bool check_value(char **av, size_t n)
{
size_t i;
i = 0;
while (i < n)
{
if (ft_isnum(av[i]) == 0)
return (1);
if (!(ft_atoi(av[i]) > 0))
return (1);
i++;
}
return (0);
}
static void set_value(t_data *data, char **args, size_t n)
{
data->nb_philos = ft_atoi(args[0]);
data->life_expectency = ft_atoi(args[1]);
data->eat_time = ft_atoi(args[2]);
data->sleep_time = ft_atoi(args[3]);
if (n == 5)
data->nb_meals = ft_atoi(args[4]);
else
data->nb_meals = -1;
}
bool parsing(t_data *data, char **args, size_t n)
{
if (check_amount_of_argument(n)
|| check_value(args, n))
{
write(2, "Argument error !\n", 16);
return (1);
}
set_value(data, args, n);
if (data->nb_philos == 0)
write(2, "Argument error !\n", 16);
return (data->nb_philos == 0);
}

19
philo/parsing.h Normal file
View File

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parsing.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:39:55 by cchauvet #+# #+# */
/* Updated: 2023/04/27 11:40:42 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef PARSING_H
# define PARSING_H
# include "./data.h"
bool parsing(t_data *data, char **args, size_t n);
#endif

47
philo/philo.c Normal file
View File

@ -0,0 +1,47 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* philo.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:38:52 by cchauvet #+# #+# */
/* Updated: 2023/04/27 11:56:04 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include <pthread.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <unistd.h>
#include "./print.h"
#include "philo.h"
#include "time.h"
#include "data.h"
void philo_destroyer(t_philo *philo)
{
pthread_mutex_destroy(&philo->nb_meal_mutex);
pthread_mutex_destroy(&philo->last_eat_mutex);
free(philo);
}
t_philo *philo_init(t_data *data)
{
t_philo *philo;
static size_t id = 0;
philo = malloc(sizeof(t_philo));
if (philo == NULL)
return (NULL);
philo->id = id++;
philo->data = data;
philo->nb_meal = 0;
philo->stop = 0;
philo->last_eat = get_time();
pthread_mutex_init(&philo->nb_meal_mutex, NULL);
pthread_mutex_init(&philo->last_eat_mutex, NULL);
pthread_mutex_init(&philo->stop_mutex, NULL);
return (philo);
}

20
philo.h → philo/philo.h
View File

@ -6,17 +6,31 @@
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/08 14:38:14 by cchauvet #+# #+# */
/* Updated: 2023/04/13 12:58:09 by cchauvet ### ########.fr */
/* Updated: 2023/04/25 16:41:14 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include <pthread.h>
#ifndef PHILO_H
# define PHILO_H
# include <pthread.h>
# include <stdio.h>
# include <stdbool.h>
# include <stdlib.h>
# include "./data.h"
typedef struct s_philo
{
size_t id;
pthread_mutex_t nb_meal_mutex;
size_t nb_meal;
pthread_mutex_t last_eat_mutex;
size_t last_eat;
pthread_mutex_t stop_mutex;
bool stop;
t_data *data;
} t_philo;
t_philo *philo_init(t_data *data);
void philo_destroyer(t_philo *philo);
void *philo_routine(void *arg);
#endif

114
philo/philo_routine.c Normal file
View File

@ -0,0 +1,114 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* philo_routine.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:44:14 by cchauvet #+# #+# */
/* Updated: 2023/06/01 14:23:53 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
#include "./time.h"
#include "./philo.h"
#include "./print.h"
#include "data.h"
bool check(t_data *data)
{
bool stop;
if (data->nb_meals != -1 && get_min_meal(data) == (size_t) data->nb_meals)
{
pthread_mutex_lock(&data->stop_mutex);
data->stop = 1;
pthread_mutex_unlock(&data->stop_mutex);
}
pthread_mutex_lock(&data->stop_mutex);
stop = data->stop;
pthread_mutex_unlock(&data->stop_mutex);
return (stop);
}
int philo_take_forks(t_philo *philo, t_data *data)
{
pthread_mutex_lock(&data->forks[philo->id]);
print_take_a_fork(philo);
if (check(data))
{
pthread_mutex_unlock(&data->forks[philo->id]);
return (1);
}
while ((philo->id + 1) % data->nb_philos == philo->id)
{
if (check(data))
{
pthread_mutex_unlock(&data->forks[philo->id]);
return (1);
}
}
pthread_mutex_lock(&data->forks[(philo->id + 1) % data->nb_philos]);
print_take_a_fork(philo);
if (check(data))
{
pthread_mutex_unlock(&data->forks[(philo->id + 1) % data->nb_philos]);
pthread_mutex_unlock(&data->forks[philo->id]);
return (1);
}
return (0);
}
bool philo_eat(t_philo *philo, t_data *data)
{
if (philo_take_forks(philo, data))
return (1);
print_eating(philo);
pthread_mutex_lock(&philo->last_eat_mutex);
philo->last_eat = get_time();
pthread_mutex_unlock(&philo->last_eat_mutex);
usleep(get_time_eat(philo, data) * 1000);
pthread_mutex_unlock(&data->forks[philo->id]);
pthread_mutex_unlock(&data->forks[(philo->id + 1) % data->nb_philos]);
if (check(data))
return (1);
pthread_mutex_lock(&philo->nb_meal_mutex);
philo->nb_meal++;
pthread_mutex_unlock(&philo->nb_meal_mutex);
return (0);
}
int philo_sleep(t_data *data, t_philo *philo)
{
print_sleeping(philo);
usleep(get_time_sleep(philo, data) * 1000);
return (0);
}
void *philo_routine(void *arg)
{
t_philo *philo;
t_data *data;
philo = arg;
data = philo->data;
print_thinking(philo);
usleep((philo->id % 2) * (get_time_eat(philo, data)) * 1000);
while (true)
{
if (check(data)
|| philo_eat(philo, data)
|| check(data)
|| philo_sleep(data, philo)
|| check(data))
{
pthread_mutex_lock(&philo->stop_mutex);
philo->stop = 1;
pthread_mutex_unlock(&philo->stop_mutex);
return (NULL);
}
print_thinking(philo);
}
return (NULL);
}

50
philo/philos.c Normal file
View File

@ -0,0 +1,50 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* philos.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:30:32 by cchauvet #+# #+# */
/* Updated: 2023/04/27 11:30:33 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "./philo.h"
#include <stdbool.h>
#include <stddef.h>
int philos_init(t_data *data)
{
size_t i;
i = 0;
while (i < data->nb_philos)
{
data->philos[i] = philo_init(data);
if (data->philos[i] == NULL)
{
while (i > 0)
{
philo_destroyer(data->philos[i]);
i--;
}
return (1);
}
i++;
}
return (0);
}
void philos_destroyer(t_data *data)
{
size_t i;
i = 0;
while (i < data->nb_philos)
{
philo_destroyer(data->philos[i]);
i++;
}
free(data->philos);
}

21
philo/philos.h Normal file
View File

@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* philos.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:33:17 by cchauvet #+# #+# */
/* Updated: 2023/04/27 11:33:17 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef PHILOS_H
# define PHILOS_H
# include <stdbool.h>
# include "./data.h"
bool philos_init(t_data *data);
void philos_destroyer(t_data *data);
#endif

56
philo/print.c Normal file
View File

@ -0,0 +1,56 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* print.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:33:33 by cchauvet #+# #+# */
/* Updated: 2023/05/25 16:47:54 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "philo.h"
#include <bits/pthreadtypes.h>
#include <pthread.h>
#include <stdbool.h>
#include <stddef.h>
#include "./time.h"
#include "./utils/utils.h"
static void print(t_data *data, size_t id, char *str)
{
size_t time;
bool stop;
pthread_mutex_lock(&data->print_mutex);
pthread_mutex_lock(&data->stop_mutex);
stop = data->stop;
pthread_mutex_unlock(&data->stop_mutex);
if (stop == false)
{
time = get_time();
printf("%07zu %03zu %s\n", time, id + 1, str);
}
pthread_mutex_unlock(&data->print_mutex);
}
void print_take_a_fork(t_philo *philo)
{
print(philo->data, philo->id, "has taken a fork");
}
void print_eating(t_philo *philo)
{
print(philo->data, philo->id, "is eating");
}
void print_sleeping(t_philo *philo)
{
print(philo->data, philo->id, "is sleeping");
}
void print_thinking(t_philo *philo)
{
print(philo->data, philo->id, "is thinking");
}

23
philo/print.h Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* print.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:35:50 by cchauvet #+# #+# */
/* Updated: 2023/04/27 11:36:33 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef PRINT_H
# define PRINT_H
# include "./philo.h"
void print_eating(t_philo *philo);
void print_take_a_fork(t_philo *philo);
void print_sleeping(t_philo *philo);
void print_thinking(t_philo *philo);
void print_died(t_philo *philo);
#endif

27
philo/print2.c Normal file
View File

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* print2.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:41:14 by cchauvet #+# #+# */
/* Updated: 2023/05/17 13:33:33 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "philo.h"
#include "./time.h"
#include "./utils/utils.h"
void print_died(t_philo *philo)
{
t_data *data;
size_t time;
data = philo->data;
time = get_time();
pthread_mutex_lock(&data->print_mutex);
printf("%07zu %03zu %s\n", time, philo->id + 1, "died");
pthread_mutex_unlock(&data->print_mutex);
}

33
philo/threads.c Normal file
View File

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* threads.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:33:45 by cchauvet #+# #+# */
/* Updated: 2023/04/27 11:37:40 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include "philo.h"
#include <pthread.h>
#include <stdbool.h>
#include <unistd.h>
#include <stddef.h>
bool threads_init(t_data *data)
{
size_t i;
i = 0;
while (i < data->nb_philos)
{
if (pthread_create(&data->threads[i], NULL, philo_routine,
data->philos[i]))
return (true);
pthread_detach(data->threads[i]);
i++;
}
return (false);
}

20
philo/threads.h Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* threads.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:37:07 by cchauvet #+# #+# */
/* Updated: 2023/04/27 11:37:08 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef THREADS_H
# define THREADS_H
# include "./data.h"
# include <stdbool.h>
bool threads_init(t_data *data);
#endif

51
philo/time.c Normal file
View File

@ -0,0 +1,51 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* time.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:35:26 by cchauvet #+# #+# */
/* Updated: 2023/05/25 17:28:19 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#include <bits/types/struct_timeval.h>
#include <sys/time.h>
#include <stddef.h>
#include <pthread.h>
#include "./philo.h"
#include "data.h"
size_t get_time(void)
{
size_t time;
static size_t start_time = 0;
struct timeval tv;
gettimeofday(&tv, NULL);
time = tv.tv_sec * 1000000 + tv.tv_usec;
if (start_time == 0)
start_time = time;
return ((time - start_time) / 1000);
}
size_t get_time_eat(t_philo *philo, t_data *data)
{
size_t time;
time = get_time();
if (time + data->eat_time > data->life_expectency + philo->last_eat)
return (data->life_expectency + philo->last_eat - time);
return (data->eat_time);
}
size_t get_time_sleep(t_philo *philo, t_data *data)
{
size_t time;
time = get_time();
if (time + data->sleep_time > data->life_expectency + philo->last_eat)
return (data->life_expectency + philo->last_eat - time);
return (data->sleep_time);
}

23
philo/time.h Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* time.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/27 11:32:57 by cchauvet #+# #+# */
/* Updated: 2023/05/02 11:27:53 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef TIME_H
# define TIME_H
# include "philo.h"
# include "data.h"
# include <stddef.h>
size_t get_time(void);
size_t get_time_eat(t_philo *philo, t_data *data);
size_t get_time_sleep(t_philo *philo, t_data *data);
#endif

4
utils/ft_atoi.c → philo/utils/ft_atoi.c
View File

@ -6,7 +6,7 @@
/* By: cchauvet <cchauvet@student.42angoulem +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/09/27 16:14:34 by cchauvet #+# #+# */
/* Updated: 2023/04/12 11:12:49 by cchauvet ### ########.fr */
/* Updated: 2023/04/27 11:27:44 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
@ -21,7 +21,7 @@ int ft_atoi(const char *str)
sign = 1;
i = 0;
while (str[i] == '-' || str[i]== '+')
while (str[i] == '-' || str[i] == '+')
{
if (str[i] == '-')
sign = -1;

0
utils/ft_isnum.c → philo/utils/ft_isnum.c
View File

5
utils/utils.h → philo/utils/utils.h
View File

@ -6,7 +6,7 @@
/* By: cchauvet <cchauvet@student.42angouleme.fr +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/11 14:38:07 by cchauvet #+# #+# */
/* Updated: 2023/04/11 14:46:12 by cchauvet ### ########.fr */
/* Updated: 2023/04/25 14:09:53 by cchauvet ### ########.fr */
/* */
/* ************************************************************************** */
@ -17,5 +17,8 @@
bool ft_isnum(char str[]);
int ft_atoi(const char str[]);
void ft_putchar(char c);
void ft_putstr(char str[]);
void ft_putnum(size_t num, size_t padding);
#endif

39
philos.c
View File

@ -1,39 +0,0 @@
#include "./philo.h"
#include "struct.h"
#include <stdbool.h>
#include <stddef.h>
int philos_init(t_data *data)
{
size_t i;
i = 0;
while (i < data->nb_philos)
{
data->philos[i] = philo_init(data);
if (data->philos[i] == NULL)
{
while (i > 0)
{
philo_destroyer(data->philos[i]);
i--;
}
return (1);
}
i++;
}
return (0);
}
void philos_destroyer(t_data *data)
{
size_t i;
i = 0;
while (i < data->nb_philos)
{
philo_destroyer(data->philos[i]);
i++;
}
free(data->philos);
}

5
philos.h
View File

@ -1,5 +0,0 @@
# include <stdbool.h>
# include "./data.h"
bool philos_init(t_data *data);
void philos_destroyer(t_data *data);

48
print.c
View File

@ -1,48 +0,0 @@
#include "philo.h"
#include <bits/pthreadtypes.h>
#include <pthread.h>
#include <stddef.h>
#include "./time.h"
#include "struct.h"
static void print(t_data *data, size_t id, char *str)
{
size_t time;
pthread_mutex_lock(&data->stop_mutex);
if (data->stop)
{
pthread_mutex_unlock(&data->stop_mutex);
return ;
}
pthread_mutex_unlock(&data->stop_mutex);
time = get_time();
pthread_mutex_lock(&data->print_mutex);
printf("%07zu %03zu %s\n", time, id + 1, str);
pthread_mutex_unlock(&data->print_mutex);
}
void print_take_a_fork(t_philo *philo)
{
print(philo->data, philo->id, "has taken a fork");
}
void print_eating(t_philo *philo)
{
print(philo->data, philo->id, "is eating");
}
void print_sleeping(t_philo *philo)
{
print(philo->data, philo->id, "is sleeping");
}
void print_thinking(t_philo *philo)
{
print(philo->data, philo->id, "is thinking");
}
void print_died(t_philo *philo)
{
print(philo->data, philo->id, "died");
}

7
print.h
View File

@ -1,7 +0,0 @@
# include "./philo.h"
void print_eating(t_philo *philo);
void print_take_a_fork(t_philo *philo);
void print_sleeping(t_philo *philo);
void print_thinking(t_philo *philo);
void print_died(t_philo *philo);

41
struct.h
View File

@ -1,41 +0,0 @@
#ifndef STRUCT_H
# define STRUCT_H
# include <pthread.h>
# include <stddef.h>
# include <sys/types.h>
typedef struct s_data
{
size_t eat_time;
size_t sleep_time;
size_t life_expectency;
size_t nb_philos;
ssize_t nb_meals;
void **philos;
pthread_t *threads;
pthread_mutex_t forks_mutex;
bool *forks;
pthread_mutex_t stop_mutex;
bool stop;
pthread_mutex_t print_mutex;
} t_data;
typedef struct s_philo
{
size_t id;
pthread_mutex_t nb_meal_mutex;
size_t nb_meal;
pthread_mutex_t last_eat_mutex;
size_t last_eat;
pthread_mutex_t last_sleep_mutex;
size_t last_sleep;
pthread_mutex_t stop_mutex;
bool stop;
t_data *data;
} t_philo;
t_philo *philo_create(t_data *data);
t_philo *philo_destoyer(t_philo *philo);
void *philo_routine(void *arg);
#endif

21
threads.c
View File

@ -1,21 +0,0 @@
#include "philo.h"
#include "struct.h"
#include <pthread.h>
#include <stdbool.h>
#include <unistd.h>
#include <stddef.h>
bool threads_init(t_data *data)
{
size_t i;
i = 0;
while (i < data->nb_philos)
{
if (pthread_create(&data->threads[i], NULL, philo_routine, data->philos[i]))
return (true);
pthread_detach(data->threads[i]);
i++;
}
return (false);
}

6
threads.h
View File

@ -1,6 +0,0 @@
# include "./data.h"
#include "struct.h"
# include <stdbool.h>
bool threads_init(t_data *data);

17
time.c
View File

@ -1,17 +0,0 @@
#include <bits/types/struct_timeval.h>
#include <sys/time.h>
#include <stddef.h>
#include <pthread.h>
size_t get_time(void)
{
size_t time;
static size_t start_time = 0;
struct timeval tv;
gettimeofday(&tv, NULL);
time = tv.tv_sec * 1000000 + tv.tv_usec;
if (start_time == 0)
start_time = time;
return ((time - start_time) / 1000);
}

3
time.h
View File

@ -1,3 +0,0 @@
# include <stddef.h>
size_t get_time(void);