175 lines
4.3 KiB
C
175 lines
4.3 KiB
C
#include "philo.h"
|
|
|
|
int get_time(t_params *params)
|
|
{
|
|
struct timeval tp;
|
|
long time;
|
|
|
|
if (gettimeofday(&tp, NULL) < 0)
|
|
{
|
|
return (-1);
|
|
}
|
|
time = tp.tv_sec * 1000 + tp.tv_usec / 1000;
|
|
if (!params->start_time)
|
|
{
|
|
params->start_time = time;
|
|
return (0);
|
|
}
|
|
time -= params->start_time;
|
|
return (time);
|
|
}
|
|
|
|
/*
|
|
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, &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)
|
|
{
|
|
if (nbr_fork == 2)
|
|
pthread_mutex_unlock(&philo->next->m_fork);
|
|
pthread_mutex_unlock(&philo->m_fork);
|
|
return (1);
|
|
}
|
|
*/
|
|
|
|
static int ret_err_unlock(t_mtx *fork1, t_mtx *fork2)
|
|
{
|
|
if (fork2)
|
|
pthread_mutex_unlock(fork2);
|
|
if (fork1)
|
|
pthread_mutex_unlock(fork1);
|
|
return (1);
|
|
}
|
|
|
|
|
|
|
|
static int eat(t_philo *philo, t_mtx *fork1, t_mtx *fork2)
|
|
{
|
|
int time;
|
|
|
|
pthread_mutex_lock(fork1);
|
|
if (print_message(philo, WHITE, "has taken a fork"))
|
|
return (ret_err_unlock(fork1, NULL));
|
|
if (fork1 == fork2)
|
|
return (ret_err_unlock(fork1, NULL));
|
|
pthread_mutex_lock(fork2);
|
|
if (print_message(philo, WHITE, "has taken a fork"))
|
|
return (ret_err_unlock(fork1, fork2));
|
|
|
|
// update_time(philo);
|
|
time = get_time(philo->params);
|
|
|
|
if (print_message(philo, B_YELLOW, "is eating"))
|
|
return (ret_err_unlock(fork1, fork2));
|
|
|
|
// action_delay(philo, philo->params->t_eat);
|
|
while (get_time(philo->params) - time < philo->params->t_eat)
|
|
usleep(100);
|
|
|
|
pthread_mutex_lock(&(philo->m_eat));
|
|
philo->eat_count++;
|
|
pthread_mutex_unlock(&(philo->m_eat));
|
|
pthread_mutex_unlock(fork2);
|
|
pthread_mutex_unlock(fork1);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
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));
|
|
if (philo->next == philo)
|
|
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);
|
|
pthread_mutex_lock(&(philo->m_eat));
|
|
philo->eat_count++;
|
|
pthread_mutex_unlock(&(philo->m_eat));
|
|
pthread_mutex_unlock(&(philo->next->m_fork));
|
|
pthread_mutex_unlock(&(philo->m_fork));
|
|
return (0);
|
|
}
|
|
*/
|
|
/*
|
|
==10069== Observed (incorrect) order is: acquisition of lock at 0x54541F8
|
|
==10069== at 0x4C3603C: ??? (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
|
|
==10069== by 0x401188: eat (exec.c:38)
|
|
==10069== by 0x4010E7: philo_exec (exec.c:68)
|
|
==10069== by 0x4C38C26: ??? (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
|
|
==10069== by 0x4E4B6DA: start_thread (pthread_create.c:463)
|
|
==10069== by 0x518471E: clone (clone.S:95)
|
|
==10069==
|
|
==10069== followed by a later acquisition of lock at 0x54542E8
|
|
==10069== at 0x4C3603C: ??? (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
|
|
==10069== by 0x401209: eat (exec.c:43)
|
|
==10069== by 0x4010E7: philo_exec (exec.c:68)
|
|
==10069== by 0x4C38C26: ??? (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
|
|
==10069== by 0x4E4B6DA: start_thread (pthread_create.c:463)
|
|
==10069== by 0x518471E: clone (clone.S:95)
|
|
*/
|
|
|
|
void *philo_exec(void *arg)
|
|
{
|
|
int time;
|
|
|
|
t_philo *philo;
|
|
t_mtx *fork1;
|
|
t_mtx *fork2;
|
|
|
|
philo = (t_philo *)arg;
|
|
|
|
// init_time(philo);
|
|
get_time(philo->params);
|
|
|
|
// if (philo->p_nbr % 2 == 0)
|
|
// usleep(10 * 1000);
|
|
|
|
fork1 = &(philo->m_fork);
|
|
fork2 = &(philo->m_fork);
|
|
// if (philo->global->t_start.ts == 0)
|
|
// if (philo->p_nbr < philo->params->n_phi / 2)
|
|
if (philo->p_nbr % 2 == 0)
|
|
fork1 = &(philo->next->m_fork);
|
|
else
|
|
fork2 = &(philo->next->m_fork);
|
|
|
|
while (1)
|
|
{
|
|
if (eat(philo, fork1, fork2) != 0)
|
|
// if (eat(philo) != 0)
|
|
break ;
|
|
|
|
time = get_time(philo->params);
|
|
|
|
if (print_message(philo, B_BLUE, "is sleeping"))
|
|
break ;
|
|
|
|
// action_delay(philo, philo->params->t_slp);
|
|
while (get_time(philo->params) - time < philo->params->t_slp)
|
|
usleep(100);
|
|
|
|
if (print_message(philo, B_GREEN, "is thinking"))
|
|
break ;
|
|
}
|
|
return (NULL);
|
|
}
|