rparodi/philosophers
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: rparodi:e6f8fc4c16c4ce7d93e9ad606297e7b47b52bc46
Branches Tags
rparodi:main
..
compare: rparodi:af63bafed034ff45cc06cff4f2cf1511879f056b
Branches Tags
rparodi:main

No commits in common. "e6f8fc4c16c4ce7d93e9ad606297e7b47b52bc46" and "af63bafed034ff45cc06cff4f2cf1511879f056b" have entirely different histories.
e6f8fc4c16 ... af63bafed0

8 changed files with 147 additions and 120 deletions
Download patch file Download diff file Expand all files Collapse all files

5
philo/.clangd
View file

@ -1,5 +0,0 @@
CompilerFlags:
Add:
- "-xc"
- "-I/usr/include"
- "-I/home/rparodi/Documents/philo-perso/philo/includes"

5
philo/Makefile
View file

@ -6,7 +6,7 @@
# By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2023/11/12 11:05:05 by rparodi #+# #+# #
# Updated: 2024/07/24 14:12:44 by rparodi ### ########.fr #
# Updated: 2024/07/04 15:20:22 by rparodi ### ########.fr #
# #
# **************************************************************************** #
@ -23,9 +23,6 @@ RM = rm -rf
# Flags
CFLAGS = -Werror -Wextra -Wall -Wno-unused-command-line-argument -g3 -MMD
# CFLAGS += -fsanitize=address
# CFLAGS += -fsanitize=thread
INCLUDES = ./includes/philo.h \
./includes/types.h

8
philo/includes/philo.h
View file

@ -6,7 +6,7 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/04 11:34:04 by rparodi #+# #+# */
/* Updated: 2024/07/23 21:04:56 by rparodi ### ########.fr */
/* Updated: 2024/07/04 14:11:50 by rparodi ### ########.fr */
/* */
/* ************************************************************************** */
@ -42,11 +42,11 @@ typedef struct s_philo
t_usize t_eat;
t_usize t_death;
t_usize t_sleep;
t_usize nb_eat;
t_i32 nb_eat;
pthread_t thread;
t_i32 id;
t_i32 eating;
t_usize eating_count;
t_i32 eating_count;
t_usize t_last_eat;
t_usize start_time;
t_bool dead_check;
@ -87,7 +87,7 @@ t_error ft_ending_eating(t_philo *philo);
void ft_putchar_fd(t_i32 fd, t_str str);
void ft_logs(t_str msg, t_philo *philo);
t_error ft_atou(const char *nptr, t_usize *value);
t_error ft_init_fork(t_mutex *fork, t_usize nb_fork);
t_error ft_init_fork(t_philo *philo, t_mutex *fork);
void counting_launch(t_philo *philo, t_u8 *counter);
t_error ft_init_thread(t_program *prog, t_mutex *forks);
t_error ft_parsing_args(t_i32 argc, t_str *argv, t_philo *philo);

33
philo/sources/ft_actions.c
View file

@ -6,30 +6,20 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/10 00:23:09 by rparodi #+# #+# */
/* Updated: 2024/07/24 16:09:21 by rparodi ### ########.fr */
/* Updated: 2024/07/04 11:48:33 by rparodi ### ########.fr */
/* */
/* ************************************************************************** */
#include "../includes/philo.h"
#include <unistd.h>
void ft_logs(t_str msg, t_philo *philo)
{
t_usize time;
const t_usize time = ft_time() - philo->start_time;
pthread_mutex_lock(philo->dead_lock);
if (philo->dead_check == true)
return ((void) pthread_mutex_unlock(philo->dead_lock));
pthread_mutex_unlock(philo->dead_lock);
pthread_mutex_lock(philo->print_lock);
time = ft_time() - philo->start_time;
if (msg != NULL)
{
printf("%s%zu %s%i %s%s%s", BLUE, time, GOLD, philo->id, \
GREEN, msg, END);
}
pthread_mutex_unlock(philo->print_lock);
}
t_error ft_thinking(t_philo *philo)
{
@ -39,26 +29,19 @@ t_error ft_thinking(t_philo *philo)
t_error ft_start_eating(t_philo *philo)
{
if (philo->nb_philo == 1)
if (philo->id % 2 == 0)
{
ft_logs("has taken a fork\n", philo);
while (!dead_loop(philo))
usleep(50);
return (NO_ERROR);
}
if (philo->id % 2 == 1)
{
pthread_mutex_lock(philo->r_fork);
ft_logs("has taken a fork\n", philo);
pthread_mutex_lock(philo->l_fork);
ft_logs("has taken a fork\n", philo);
pthread_mutex_lock(philo->r_fork);
ft_logs("has taken a fork\n", philo);
}
else
{
pthread_mutex_lock(philo->l_fork);
ft_logs("has taken a fork\n", philo);
pthread_mutex_lock(philo->r_fork);
ft_logs("has taken a fork\n", philo);
pthread_mutex_lock(philo->l_fork);
ft_logs("has taken a fork\n", philo);
}
return (ft_ending_eating(philo));
}
@ -69,9 +52,7 @@ t_error ft_ending_eating(t_philo *philo)
philo->eating = true;
ft_logs("is eating\n", philo);
pthread_mutex_lock(philo->meal_lock);
philo->t_last_eat = time;
pthread_mutex_unlock(philo->meal_lock);
pthread_mutex_lock(philo->check_eating_count);
philo->eating_count++;
pthread_mutex_unlock(philo->check_eating_count);

35
philo/sources/main.c
View file

@ -6,7 +6,7 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/04 11:30:25 by rparodi #+# #+# */
/* Updated: 2024/07/24 20:22:29 by rparodi ### ########.fr */
/* Updated: 2024/07/04 15:27:12 by rparodi ### ########.fr */
/* */
/* ************************************************************************** */
@ -15,25 +15,14 @@
void *ft_routine(void *ptr)
{
t_philo *philo;
t_usize nb_group;
nb_group = 2;
philo = (t_philo *) ptr;
if (philo == NULL)
return (NULL);
if (philo->nb_philo % 2)
nb_group = 3;
while (philo->start_time > ft_time())
usleep(500);
if (philo->id % nb_group)
usleep(philo->t_eat * 800);
while (!dead_loop(philo))
{
if (dead_loop(philo) == false)
ft_start_eating(philo);
if (dead_loop(philo) == false)
ft_sleeping(philo);
if (dead_loop(philo) == false)
ft_thinking(philo);
}
return (philo);
@ -41,11 +30,11 @@ void *ft_routine(void *ptr)
t_error ft_init_thread(t_program *prog, t_mutex *forks)
{
t_thread watch_dogs;
t_thread o_block;
t_usize i;
i = 0;
if (pthread_create(&watch_dogs, NULL, &ft_watch_dogs, prog->philos))
if (pthread_create(&o_block, NULL, &ft_watch_dogs, prog->philos))
ft_destroy_exit("Allocation of watch_dogs failed\n", \
ERROR, prog, forks);
while (i < prog->philos[0].nb_philo)
@ -56,9 +45,9 @@ t_error ft_init_thread(t_program *prog, t_mutex *forks)
ERROR, prog, forks);
i++;
}
while (i-- > 0)
while (--i > 0)
pthread_join(prog->philos[i].thread, NULL);
pthread_join(watch_dogs, NULL);
pthread_join(o_block, NULL);
return (NO_ERROR);
}
@ -75,23 +64,9 @@ t_i32 main(t_i32 argc, t_str *argv)
{
t_philo philo[MAXSUPPORT];
t_program prog;
t_i32 i;
t_i32 j;
j = 1;
if (argc != 6 && argc != 5)
ft_exit(ARGS, 1);
while (j < argc)
{
i = 0;
while (argv[j][i] != '\0')
{
if (argv[j][i] < '0' || argv[j][i] > '9')
ft_exit("I have to take only numeric arguments !\n", 1);
i++;
}
j++;
}
if (ft_atou_return(argv[1]) > MAXSUPPORT)
ft_exit("Please update the max support !\n", 1);
if (ft_init(argc, argv, &prog, philo))

42
philo/sources/parsing_args.c
View file

@ -6,32 +6,26 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/04 11:42:37 by rparodi #+# #+# */
/* Updated: 2024/07/24 20:23:09 by rparodi ### ########.fr */
/* Updated: 2024/07/04 11:52:27 by rparodi ### ########.fr */
/* */
/* ************************************************************************** */
#include "../includes/philo.h"
#include <pthread.h>
t_error ft_parsing_args(t_i32 argc, t_str *argv, t_philo *philo)
{
t_usize tmp;
tmp = 0;
philo->eating = 0;
philo->eating_count = 0;
ft_atou(argv[1], &tmp);
if (tmp == 0)
return (ERROR);
philo->nb_philo = tmp;
philo->nb_eat = ~0u;
if (argc == 6)
{
ft_atou(argv[5], &tmp);
if (tmp == 0)
return (ERROR);
philo->nb_eat = tmp;
}
else
philo->t_eat = -1;
ft_atou(argv[1], &tmp);
philo->nb_philo = tmp;
ft_atou(argv[2], &tmp);
philo->t_death = tmp;
ft_atou(argv[3], &tmp);
@ -41,14 +35,14 @@ t_error ft_parsing_args(t_i32 argc, t_str *argv, t_philo *philo)
return (NO_ERROR);
}
t_error ft_init_fork(t_mutex *fork, t_usize nb_fork)
t_error ft_init_fork(t_philo *philo, t_mutex *fork)
{
t_usize i;
i = 0;
while (i < nb_fork)
while (i < philo->nb_philo)
{
fork[i] = (t_mutex)PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_init(&fork[i], NULL);
i++;
}
return (NO_ERROR);
@ -65,42 +59,42 @@ void ft_pause(size_t milliseconds)
t_error ft_init_philo(t_i32 argc, t_str *argv, t_program *prog, t_mutex *forks)
{
t_usize i;
t_usize start_time;
start_time = ft_time() + 500;
i = 0;
while (i < ft_atou_return(argv[1]))
{
prog->philos[i].id = i + 1;
prog->philos[i].eating = 0;
ft_parsing_args(argc, argv, &prog->philos[i]);
prog->philos[i].start_time = start_time;
prog->philos[i].start_time = ft_time();
prog->philos[i].t_last_eat = 0;
prog->philos[i].print_lock = &prog->print_lock;
prog->philos[i].dead_lock = &prog->dead_lock;
prog->philos[i].meal_lock = &prog->meal_lock;
prog->philos[i].dead_check = false;
prog->philos[i].check_eating_count = &prog->check_eating_count;
prog->philos[i].l_fork = &forks[i];
if (i == 0)
prog->philos[i].r_fork = &forks[prog->philos[i].nb_philo - 1];
else
prog->philos[i].r_fork = &forks[i - 1];
prog->philos[i].l_fork = &forks[i];
i++;
}
return (ft_parsing_args(argc, argv, prog->philos));
if (ft_parsing_args(argc, argv, prog->philos))
return (ERROR);
return (NO_ERROR);
}
t_error ft_init(t_i32 argc, t_str *argv, t_program *prog, t_philo *philo)
{
static t_mutex forks[MAXSUPPORT] = {0};
prog->print_lock = (t_mutex)PTHREAD_MUTEX_INITIALIZER;
prog->dead_lock = (t_mutex)PTHREAD_MUTEX_INITIALIZER;
prog->meal_lock = (t_mutex)PTHREAD_MUTEX_INITIALIZER;
prog->check_eating_count = (t_mutex)PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_init(&prog->print_lock, NULL);
pthread_mutex_init(&prog->dead_lock, NULL);
pthread_mutex_init(&prog->meal_lock, NULL);
pthread_mutex_init(&prog->check_eating_count, NULL);
prog->philos = philo;
prog->dead_flag = false;
ft_init_fork(forks, ft_atou_return(argv[1]));
if (ft_init_philo(argc, argv, prog, forks))
return (ERROR);
if (philo->nb_philo != 0 && philo->nb_philo > MAXSUPPORT)

41
philo/sources/routine.c
View file

@ -6,17 +6,16 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/11 11:42:31 by rparodi #+# #+# */
/* Updated: 2024/07/24 14:07:27 by rparodi ### ########.fr */
/* Updated: 2024/07/04 13:29:39 by rparodi ### ########.fr */
/* */
/* ************************************************************************** */
#include "../includes/philo.h"
#include <stdio.h>
t_bool dead_loop(t_philo *philo)
{
pthread_mutex_lock(philo->dead_lock);
if (philo->dead_check == true)
if (philo[0].dead_check == true)
return (pthread_mutex_unlock(philo->dead_lock), true);
pthread_mutex_unlock(philo->dead_lock);
return (false);
@ -30,18 +29,15 @@ t_bool check_dead(t_philo *philo)
i = 0;
while (i < philo[0].nb_philo)
{
pthread_mutex_lock(philo->meal_lock);
timecheck = ft_time() - philo[i].start_time - philo[i].t_last_eat;
if (timecheck >= philo[i].t_death)
if (philo[i].t_last_eat != 0 && timecheck >= philo[i].t_death)
{
pthread_mutex_unlock(philo->meal_lock);
ft_logs("died\n", &philo[i]);
pthread_mutex_lock(philo[i].dead_lock);
philo[i].dead_check = true;
pthread_mutex_unlock(philo[i].dead_lock);
ft_logs("died\n", &philo[i]);
philo[i].dead_check = true;
pthread_mutex_lock(philo[i].dead_lock);
return (true);
}
pthread_mutex_unlock(philo->meal_lock);
i++;
}
return (false);
@ -64,26 +60,37 @@ void counting_launch(t_philo *philo, t_u8 *counter)
t_bool check_eat(t_philo *philo)
{
t_usize i;
t_u8 check;
i = 0;
check = 0;
if (philo[0].nb_eat == -1)
return (false);
counting_launch(philo, &check);
if (check == philo[0].nb_philo)
{
pthread_mutex_lock(philo[0].dead_lock);
while (i < philo[0].nb_philo)
{
pthread_mutex_unlock(philo[i].dead_lock);
philo[i].dead_check = true;
pthread_mutex_lock(philo[i].dead_lock);
i++;
}
pthread_mutex_unlock(philo[0].dead_lock);
return (true);
}
return (false);
}
void *ft_watch_dogs(void *ptr)
{
t_philo *philo;
t_usize i;
philo = (t_philo *) ptr;
if (philo == NULL)
return (NULL);
while (philo[0].start_time > ft_time())
usleep(500);
i = philo[0].nb_philo;
while (true)
{
if (check_eat(philo) == true)
@ -91,11 +98,5 @@ void *ft_watch_dogs(void *ptr)
if (check_dead(philo) == true)
break ;
}
while (i-- != 0)
{
pthread_mutex_lock(philo[i].dead_lock);
philo[i].dead_check = true;
pthread_mutex_unlock(philo[i].dead_lock);
}
return (philo);
}

84
philo/test.c Normal file
View file

@ -0,0 +1,84 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* test.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/09 15:08:23 by rparodi #+# #+# */
/* Updated: 2024/06/17 12:24:16 by rparodi ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/_types/_null.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h>
// printf derriere un mutex pour le printf
// zero printf apres une mort
// mort shared avec un mutex
// compte le nombre de ois manger par philo, et chec via un thread si tous a manger X fois
pthread_t philosopher[15];
pthread_mutex_t chopstick[15];
int ft_sleep(size_t milliseconds)
{
struct timeval start;
struct timeval tempo;
gettimeofday(&tempo, NULL);
gettimeofday(&start, NULL);
while ((tempo - start) < milliseconds)
{
usleep(500);
gettimeofday(&tempo, NULL);
}
return (0);
}
void *func(void *arg) {
int n = *((int *)arg);
printf("Philosopher %d is thinking\n", n);
pthread_mutex_lock(&chopstick[n]);
pthread_mutex_lock(&chopstick[(n + 1) % 15]);
printf("Philosopher %d is eating\n", n);
ft_sleep(3000000); // sleep for 3 seconds to simulate eating
pthread_mutex_unlock(&chopstick[n]);
pthread_mutex_unlock(&chopstick[(n + 1) % 15]);
printf("Philosopher %d finished eating\n", n);
free(arg); // Free the allocated memory
return NULL;
}
int main() {
int i;
for (i = 0; i < 15; i++)
pthread_mutex_init(&chopstick[i], NULL);
for (i = 0; i < 15; i++) {
int *arg = malloc(sizeof(*arg));
if (arg == NULL) {
fprintf(stderr, "Couldn't allocate memory for thread arg.\n");
exit(EXIT_FAILURE);
}
*arg = i;
pthread_create(&philosopher[i], NULL, func, arg);
}
for (i = 0; i < 15; i++)
pthread_join(philosopher[i], NULL);
for (i = 0; i < 15; i++)
pthread_mutex_destroy(&chopstick[i]);
return 0;
}