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

protection segfault creation zero philosophs + deplacement fichiers dans philo + ajout exeption philo folder dans gitignore

Browse Source
This commit is contained in:
Hugo LAMY
2022-01-27 15:08:56 +01:00
parent e45ca1331f
commit 836c02f3f5
12 changed files with 4 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
philo/srcs/exec.c Normal file
View File

@@ -0,0 +1,73 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* exec.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: hulamy <hulamy@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/01/26 15:30:28 by hulamy #+# #+# */
/* Updated: 2022/01/26 18:51:44 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "philo.h"
static void action_delay(t_philo *philo, int action_time)
{
struct timeval stime;
int death_time;
gettimeofday(&stime, NULL);
death_time = philo->params->t_die - diff_time(&philo->t_last_meal, &stime);
if (death_time > action_time)
usleep(action_time * 1000);
else if (death_time > 0)
usleep(philo->params->t_die * 1000);
}
static int ret_err_unlock(t_philo *philo, int nbr_fork)
{
pthread_mutex_unlock(&philo->m_fork);
if (nbr_fork == 2)
pthread_mutex_unlock(&philo->next->m_fork);
return (1);
}
static int eat(t_philo *philo)
{
pthread_mutex_lock(&(philo->m_fork));
if (print_message(philo, WHITE, "has taken a fork"))
return (ret_err_unlock(philo, 1));
pthread_mutex_lock(&(philo->next->m_fork));
if (print_message(philo, WHITE, "has taken a fork"))
return (ret_err_unlock(philo, 2));
update_time(philo);
if (print_message(philo, B_YELLOW, "is eating"))
return (ret_err_unlock(philo, 2));
action_delay(philo, philo->params->t_eat);
philo->eat_count++;
pthread_mutex_unlock(&(philo->next->m_fork));
pthread_mutex_unlock(&(philo->m_fork));
return (0);
}
void *philo_exec(void *arg)
{
t_philo *philo;
philo = (t_philo *)arg;
init_time(philo);
if (philo->p_nbr % 2 == 0)
usleep(10 * 1000);
while (1)
{
if (eat(philo) != 0)
break ;
if (print_message(philo, B_BLUE, "is sleeping"))
break ;
action_delay(philo, philo->params->t_slp);
if (print_message(philo, B_GREEN, "is thinking"))
break ;
}
return (NULL);
}

60
philo/srcs/generic.c Normal file
View File

@@ -0,0 +1,60 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* generic.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: hulamy <hulamy@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/01/26 15:30:54 by hulamy #+# #+# */
/* Updated: 2022/01/26 16:29:10 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "philo.h"
void init_time(t_philo *philo)
{
struct timeval stime;
if (philo->global->t_start.ts == 0)
{
gettimeofday(&stime, NULL);
philo->global->t_start.ts = stime.tv_sec;
philo->global->t_start.tu = stime.tv_usec;
}
philo->t_last_meal.ts = philo->global->t_start.ts;
philo->t_last_meal.tu = philo->global->t_start.tu;
}
void update_time(t_philo *philo)
{
struct timeval stime;
gettimeofday(&stime, NULL);
philo->t_last_meal.ts = stime.tv_sec;
philo->t_last_meal.tu = stime.tv_usec;
}
int diff_time(t_time *old, struct timeval *new)
{
return ((new->tv_sec - old->ts) * 1000 + (new->tv_usec - old->tu) / 1000);
}
int print_message(t_philo *philo, char *clr, char *msg)
{
long int time_stamp;
struct timeval stime;
pthread_mutex_lock(&(philo->global->m_print));
if (philo->global->stop)
{
pthread_mutex_unlock(&(philo->global->m_print));
return (1);
}
gettimeofday(&stime, NULL);
time_stamp = (stime.tv_sec - philo->global->t_start.ts) * 1000;
time_stamp += (stime.tv_usec - philo->global->t_start.tu) / 1000;
printf("%s%li %i %s%s\n", clr, time_stamp, philo->p_nbr, msg, RESET);
pthread_mutex_unlock(&(philo->global->m_print));
return (0);
}

122
philo/srcs/init.c Normal file
View File

@@ -0,0 +1,122 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* init.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: hulamy <hulamy@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/01/26 15:30:34 by hulamy #+# #+# */
/* Updated: 2022/01/27 15:01:30 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "philo.h"
static t_philo *lst_add_philo(t_params *params, t_global *global, int i)
{
t_philo *new;
new = malloc(sizeof(t_philo) * 1);
if (new == NULL)
return (NULL);
new->params = params;
new->global = global;
new->p_nbr = i + 1;
if (pthread_mutex_init(&(new->m_fork), NULL) != 0)
return (NULL);
new->t_last_meal.ts = 0;
new->t_last_meal.tu = 0;
new->eat_count = 0;
new->next = NULL;
return (new);
}
static t_philo *init_chain_philo(t_params *params, t_global *global)
{
t_philo *philo;
t_philo *tmp;
t_philo *start;
int i;
i = 0;
philo = NULL;
while (i < params->n_phi)
{
tmp = lst_add_philo(params, global, i);
if (philo)
philo->next = tmp;
else
start = tmp;
philo = tmp;
i++;
}
if (philo)
philo->next = start;
return (philo);
}
static t_params *init_params(int ac, char **av)
{
t_params *params;
int i;
if (ac < 5 || ac > 6)
return (NULL);
if (!ft_isdigit_2d_arr(av + 1))
return (NULL);
i = 0;
while (av[i])
{
if (ft_int_overflow(av[i]))
return (NULL);
i++;
}
params = malloc(sizeof(t_params));
if (!params)
return (NULL);
params->n_phi = ft_atoi(av[1]);
params->t_die = ft_atoi(av[2]);
params->t_eat = ft_atoi(av[3]);
params->t_slp = ft_atoi(av[4]);
params->n_eat = -1;
if (ac == 6)
params->n_eat = ft_atoi(av[5]);
return (params);
}
static t_global *init_global(void)
{
t_global *global;
global = malloc(sizeof(t_global));
if (!global)
return (NULL);
global->stop = 0;
global->satiated_count = 0;
global->t_start.ts = 0;
global->t_start.tu = 0;
if (pthread_mutex_init(&(global->m_print), NULL) != 0)
return (NULL);
return (global);
}
t_philo *init(int ac, char **av, pthread_t **id)
{
t_philo *philo;
t_params *params;
t_global *global;
params = init_params(ac, av);
if (params == NULL)
return (NULL);
global = init_global();
if (params == NULL)
return (NULL);
*id = malloc(sizeof(pthread_t) * params->n_phi);
if (*id == NULL)
return (NULL);
philo = init_chain_philo(params, global);
if (philo == NULL)
return (NULL);
return (philo);
}

92
philo/srcs/launch.c Normal file
View File

@@ -0,0 +1,92 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* launch.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: hulamy <hulamy@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/01/26 15:30:49 by hulamy #+# #+# */
/* Updated: 2022/01/26 18:52:32 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "philo.h"
static int is_finished(t_philo *philo, struct timeval *stime)
{
long int time_stamp;
int time;
if (philo->global->satiated_count == philo->params->n_phi)
{
philo->global->stop = 1;
return (1);
}
time = diff_time(&philo->t_last_meal, stime);
if (time >= philo->params->t_die)
{
pthread_mutex_lock(&(philo->global->m_print));
philo->global->stop = 1;
time_stamp = (stime->tv_sec - philo->global->t_start.ts) * 1000;
time_stamp += (stime->tv_usec - philo->global->t_start.tu) / 1000;
printf("%s%li %i died%s\n", B_RED, time_stamp, philo->p_nbr, RESET);
pthread_mutex_unlock(&(philo->global->m_print));
return (1);
}
return (0);
}
int is_satiated(t_philo *philo)
{
if (philo->eat_count == philo->params->n_eat)
{
philo->global->satiated_count++;
return (1);
}
return (0);
}
static void pere_fouettard(t_philo *philo)
{
struct timeval stime;
int i;
int satiated;
while (philo->global->stop == 0)
{
i = 0;
satiated = 1;
gettimeofday(&stime, NULL);
while (i < philo->params->n_phi)
{
if (satiated == 1 && is_satiated(philo) == 0)
satiated = 0;
if (is_finished(philo, &stime))
break ;
philo = philo->next;
i++;
}
usleep(1 * 1000);
}
}
void launch(t_philo *philo, pthread_t *id)
{
int i;
i = 0;
while (i < philo->params->n_phi)
{
pthread_create(&id[i], NULL, &philo_exec, philo);
philo = philo->next;
i++;
}
pere_fouettard(philo);
i = 0;
while (i < philo->params->n_phi)
{
pthread_mutex_unlock(&(philo->m_fork));
philo = philo->next;
i++;
}
}

32
philo/srcs/main.c Normal file
View File

@@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* main.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: hulamy <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/01/26 15:30:40 by hulamy #+# #+# */
/* Updated: 2022/01/26 15:32:30 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "philo.h"
int main(int ac, char **av)
{
pthread_t *id;
t_philo *philo;
int i;
philo = init(ac, av, &id);
if (philo == NULL)
return (0);
launch(philo, id);
i = 0;
while (i < philo->params->n_phi)
{
pthread_join(id[i], NULL);
i++;
}
return (0);
}

103
philo/srcs/utils.c Normal file
View File

@@ -0,0 +1,103 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: hulamy <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/01/26 15:30:19 by hulamy #+# #+# */
/* Updated: 2022/01/26 18:04:08 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "philo.h"
int ft_isdigit_2d_arr(char **str)
{
int i;
int j;
i = 0;
while (str[i])
{
j = 0;
while (str[i][j])
{
if (str[i][j] < '0' || str[i][j] > '9')
return (0);
j++;
}
i++;
}
return (1);
}
size_t ft_strlen(char *str)
{
size_t i;
i = 0;
while (str[i])
i++;
return (i);
}
int ft_strncmp(char *s1, char *s2, size_t n)
{
size_t i;
int res;
i = 0;
res = 0;
while (s1[i] && s1[i] == s2[i] && i < n - 1)
i++;
if (n != 0)
res = (unsigned char)s1[i] - (unsigned char)s2[i];
return (res);
}
int ft_int_overflow(char *str)
{
size_t len;
char *int_xtrem;
int_xtrem = "2147483647";
if (str[0] == '-')
int_xtrem = "2147483648";
if (str[0] == '+' || str[0] == '-')
str++;
len = ft_strlen(str);
if (len < 10)
return (0);
else if (len > 10 || ft_strncmp(str, int_xtrem, len) > 0)
return (1);
return (0);
}
int ft_atoi(const char *str)
{
int i;
int result;
int is_negative;
is_negative = 0;
result = 0;
i = 0;
while (str[i] == ' ' || (str[i] >= 9 && str[i] <= 13))
i++;
if (str[i] == '+')
i++;
else if (str[i] == '-')
{
is_negative = 1;
i++;
}
while (str[i] >= '0' && str[i] <= '9')
{
result = (result * 10) + (str[i] - '0');
i++;
}
if (is_negative)
result = result * -1;
return (result);
}