208 lines
4.3 KiB
C
208 lines
4.3 KiB
C
/* linux-dp.c --- dining philosophers, on LinuxThreads
|
|
Jim Blandy <jimb@cygnus.com> --- March 1999 */
|
|
|
|
/* It's okay to edit this file and shift line numbers around. The
|
|
tests use gdb_get_line_number to find source locations, so they
|
|
don't depend on having certain line numbers in certain places. */
|
|
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <pthread.h>
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
/* The number of philosophers at the table. */
|
|
int num_philosophers;
|
|
|
|
/* Mutex ordering -
|
|
If you want to lock a mutex M, all the mutexes you have locked
|
|
already must appear before M on this list.
|
|
|
|
fork_mutex[0]
|
|
fork_mutex[1]
|
|
...
|
|
fork_mutex[num_philosophers - 1]
|
|
stdout_mutex
|
|
random_mutex
|
|
*/
|
|
|
|
/* You must hold this mutex while writing to stdout. */
|
|
pthread_mutex_t stdout_mutex;
|
|
|
|
/* You must hold this mutex while calling any of the random number
|
|
generation routines. */
|
|
pthread_mutex_t random_mutex;
|
|
|
|
/* array of mutexes, one for each fork; fork_mutex[i] is to the left
|
|
of philosopher i. A philosopher is holding fork i iff his/her
|
|
thread has locked fork_mutex[i]. */
|
|
pthread_mutex_t *fork_mutex;
|
|
|
|
/* array of threads, one representing each philosopher. */
|
|
pthread_t *philosophers;
|
|
|
|
void *
|
|
xmalloc (size_t n)
|
|
{
|
|
void *p = malloc (n);
|
|
|
|
if (! p)
|
|
{
|
|
fprintf (stderr, "out of memory\n");
|
|
exit (2);
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
void
|
|
shared_printf (char *format, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start (ap, format);
|
|
pthread_mutex_lock (&stdout_mutex);
|
|
vprintf (format, ap);
|
|
pthread_mutex_unlock (&stdout_mutex);
|
|
va_end (ap);
|
|
}
|
|
|
|
int
|
|
shared_random ()
|
|
{
|
|
int result;
|
|
|
|
pthread_mutex_lock (&random_mutex);
|
|
result = rand ();
|
|
pthread_mutex_unlock (&random_mutex);
|
|
return result;
|
|
}
|
|
|
|
void
|
|
my_usleep (long usecs)
|
|
{
|
|
struct timeval timeout;
|
|
|
|
timeout.tv_sec = usecs / 1000000;
|
|
timeout.tv_usec = usecs % 1000000;
|
|
|
|
select (0, 0, 0, 0, &timeout);
|
|
}
|
|
|
|
void
|
|
random_delay ()
|
|
{
|
|
my_usleep ((shared_random () % 2000) * 100);
|
|
}
|
|
|
|
void
|
|
print_philosopher (int n, char left, char right)
|
|
{
|
|
int i;
|
|
|
|
shared_printf ("%*s%c %d %c\n", (n * 4) + 2, "", left, n, right);
|
|
}
|
|
|
|
void *
|
|
philosopher (void *data)
|
|
{
|
|
int n = * (int *) data;
|
|
|
|
print_philosopher (n, '_', '_');
|
|
|
|
#if 1
|
|
if (n == num_philosophers - 1)
|
|
for (;;)
|
|
{
|
|
/* The last philosopher is different. He goes for his right
|
|
fork first, so there is no cycle in the mutex graph. */
|
|
|
|
/* Grab the right fork. */
|
|
pthread_mutex_lock (&fork_mutex[(n + 1) % num_philosophers]);
|
|
print_philosopher (n, '_', '!');
|
|
random_delay ();
|
|
|
|
/* Then grab the left fork. */
|
|
pthread_mutex_lock (&fork_mutex[n]);
|
|
print_philosopher (n, '!', '!');
|
|
random_delay ();
|
|
|
|
print_philosopher (n, '_', '_');
|
|
pthread_mutex_unlock (&fork_mutex[n]);
|
|
pthread_mutex_unlock (&fork_mutex[(n + 1) % num_philosophers]);
|
|
random_delay ();
|
|
}
|
|
else
|
|
#endif
|
|
for (;;)
|
|
{
|
|
/* Grab the left fork. */
|
|
pthread_mutex_lock (&fork_mutex[n]);
|
|
print_philosopher (n, '!', '_');
|
|
random_delay ();
|
|
|
|
/* Then grab the right fork. */
|
|
pthread_mutex_lock (&fork_mutex[(n + 1) % num_philosophers]);
|
|
print_philosopher (n, '!', '!');
|
|
random_delay ();
|
|
|
|
print_philosopher (n, '_', '_');
|
|
pthread_mutex_unlock (&fork_mutex[n]);
|
|
pthread_mutex_unlock (&fork_mutex[(n + 1) % num_philosophers]);
|
|
random_delay ();
|
|
}
|
|
|
|
return (void *) 0;
|
|
}
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
num_philosophers = 5;
|
|
|
|
/* Set up the mutexes. */
|
|
{
|
|
pthread_mutexattr_t ma;
|
|
int i;
|
|
|
|
pthread_mutexattr_init (&ma);
|
|
pthread_mutex_init (&stdout_mutex, &ma);
|
|
pthread_mutex_init (&random_mutex, &ma);
|
|
fork_mutex = xmalloc (num_philosophers * sizeof (fork_mutex[0]));
|
|
for (i = 0; i < num_philosophers; i++)
|
|
pthread_mutex_init (&fork_mutex[i], &ma);
|
|
pthread_mutexattr_destroy (&ma);
|
|
}
|
|
|
|
/* Set off the threads. */
|
|
{
|
|
int i;
|
|
int *numbers = xmalloc (num_philosophers * sizeof (*numbers));
|
|
pthread_attr_t ta;
|
|
|
|
philosophers = xmalloc (num_philosophers * sizeof (*philosophers));
|
|
|
|
pthread_attr_init (&ta);
|
|
|
|
for (i = 0; i < num_philosophers; i++)
|
|
{
|
|
numbers[i] = i;
|
|
/* linuxthreads.exp: create philosopher */
|
|
pthread_create (&philosophers[i], &ta, philosopher, &numbers[i]);
|
|
}
|
|
|
|
pthread_attr_destroy (&ta);
|
|
}
|
|
|
|
/* linuxthreads.exp: info threads 2 */
|
|
sleep (1000000);
|
|
|
|
/* Drink yourself into oblivion. */
|
|
for (;;)
|
|
sleep (1000000);
|
|
|
|
return 0;
|
|
}
|