136 lines
2.9 KiB
C
136 lines
2.9 KiB
C
#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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
bool philo_eat(t_philo *philo, t_data *data)
|
|
{
|
|
size_t time;
|
|
|
|
pthread_mutex_lock(&data->forks[philo->id]);
|
|
print_take_a_fork(philo);
|
|
if (check(philo, 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(philo, data))
|
|
{
|
|
pthread_mutex_unlock(&data->forks[(philo->id + 1) % data->nb_philos]);
|
|
pthread_mutex_unlock(&data->forks[philo->id]);
|
|
return (1);
|
|
}
|
|
print_eating(philo);
|
|
time = get_time();
|
|
if (time - philo->last_eat + data->eat_time > data->life_expectency)
|
|
usleep((time - philo->last_eat + data->eat_time) * 1000);
|
|
else
|
|
usleep(data->eat_time * 1000);
|
|
pthread_mutex_unlock(&data->forks[philo->id]);
|
|
pthread_mutex_unlock(&data->forks[(philo->id + 1) % data->nb_philos]);
|
|
if (check(philo, data))
|
|
return (1);
|
|
pthread_mutex_lock(&philo->last_eat_mutex);
|
|
philo->last_eat = get_time();
|
|
pthread_mutex_unlock(&philo->last_eat_mutex);
|
|
pthread_mutex_lock(&philo->nb_meal_mutex);
|
|
philo->nb_meal++;
|
|
pthread_mutex_unlock(&philo->nb_meal_mutex);
|
|
return (0);
|
|
}
|
|
|
|
void philo_sleep(t_data *data, t_philo *philo)
|
|
{
|
|
size_t time;
|
|
|
|
print_sleeping(philo);
|
|
time = get_time();
|
|
if (time - philo->last_eat + data->eat_time > data->life_expectency)
|
|
usleep((time - philo->last_eat + data->eat_time) * 1000);
|
|
else
|
|
usleep(data->eat_time * 1000);
|
|
}
|
|
|
|
|
|
void *philo_routine(void *arg)
|
|
{
|
|
t_philo *philo;
|
|
t_data *data;
|
|
|
|
philo = arg;
|
|
data = philo->data;
|
|
print_thinking(philo);
|
|
usleep((philo->id % 2) * (data->eat_time) * 1000);
|
|
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();
|
|
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);
|
|
}
|