1998-09-13 Ben Elliston <bje@cygnus.com>

	* eyal1.c: New file; contributed by Eyal Lebedinsky
	<eyal@eyal.emu.id.au>.

1 files changed, 345 insertions, 0 deletions

diff --git a/tests/eyal1.c b/tests/eyal1.c
new file mode 100644
index 0000000..e32d29e
--- /dev/null
+++ b/tests/eyal1.c
@@ -0,0 +1,345 @@
+/* Simple POSIX threads program.
+ *
+ * Author: Eyal Lebedinsky eyal@eyal.emu.id.au
+ * Written: Sep 1998.
+ * Version Date: 12 Sep 1998
+ *
+ * Do we need to lock stdout or is it thread safe?
+ *
+ * Used:
+ *	pthread_t
+ *	pthread_attr_t
+ *	pthread_create()
+ *	pthread_join()
+ *	pthread_mutex_t
+ *	PTHREAD_MUTEX_INITIALIZER
+ *	pthread_mutex_init() [not used now]
+ *	pthread_mutex_destroy()
+ *	pthread_mutex_lock()
+ *	pthread_mutex_trylock()
+ *	pthread_mutex_unlock()
+ *
+ * What this program does is establish a work queue (implemented using
+ * four mutexes for each thread). It then schedules work (by storing
+ * a number in 'todo') and releases the threads. When the work is done
+ * the threads will block. The program then repeats the same thing once
+ * more (just to test the logic) and when the work is done it destroyes
+ * the threads.
+ *
+ * The 'work' we do is simply burning CPU cycles in a loop.
+ * The 'todo' work queue is trivial - each threads pops one element
+ * off it by incrementing it, the poped number is the 'work' to do.
+ * When 'todo' reaches the limit (nwork) the queue is considered
+ * empty.
+ *
+ * The number displayed at the end is the amount of work each thread
+ * did, so we can see if the load was properly distributed.
+ *
+ * The program was written to test a threading setup (not seen here)
+ * rather than to demonstrate correct usage of the pthread facilities.
+ *
+ * Note how each thread is given access to a thread control structure
+ * (TC) which is used for communicating to/from the main program (e.g.
+ * the threads knows its 'id' and also filles in the 'work' done).
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include <pthread.h>
+
+
+struct thread_control {
+	int		id;
+	pthread_t	thread;		/* thread id */
+	pthread_mutex_t	mutex_start;
+	pthread_mutex_t	mutex_started;
+	pthread_mutex_t	mutex_end;
+	pthread_mutex_t	mutex_ended;
+	long		work;		/* work done */
+	int		stat;		/* pthread_init status */
+};
+typedef struct thread_control	TC;
+
+static TC		*tcs = NULL;
+static int		nthreads = 2;
+static int		nwork = 0;
+static int		quiet = 0;
+
+static int		todo = -1;
+
+static pthread_mutex_t	mutex_todo = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t	mutex_stdout = PTHREAD_MUTEX_INITIALIZER;
+
+/*static pthread_attr_t    pthread_attr_default;*/
+
+
+static void
+die (int ret)
+{
+	if (NULL != tcs) {
+		free (tcs);
+		tcs = NULL;
+	}
+
+	if (ret)
+		exit (ret);
+}
+
+
+static void
+waste_time (int n)
+{
+	int		i;
+	double		f;
+
+	f = rand ();
+
+	for (i = n*100; i > 0; --i) {
+		f = sqrt (f) * f + 10000.0;
+	}
+}
+
+static int
+do_work_unit (int who, int n)
+{
+	int		i;
+	static int	nchars = 0;
+
+	if (quiet)
+		i = 0;
+	else {
+/* get lock on stdout
+*/
+		if (pthread_mutex_lock (&mutex_stdout))
+			return (-1);
+
+/* do our job
+*/
+		i = printf ("%c",
+			"0123456789abcdefghijklmnopqrstuvwxyz"[who]);
+		if (!(++nchars % 50))
+			printf ("\n");
+		fflush (stdout);
+
+/* release lock on stdout
+*/
+		if (pthread_mutex_unlock (&mutex_stdout))
+			return (-2);
+	}
+
+	n = rand () % 10000;	/* ignore incoming 'n' */
+	waste_time (n);
+
+	return (n);
+}
+
+static int
+print_server (void *ptr)
+{
+	int		mywork;
+	int		n;
+	TC		*tc = (TC *)ptr;
+
+	if (pthread_mutex_lock (&tc->mutex_started))
+		return (-1);
+
+	for (;;) {
+		if (pthread_mutex_lock (&tc->mutex_start))
+			return (-2);
+		if (pthread_mutex_unlock (&tc->mutex_start))
+			return (-3);
+		if (pthread_mutex_lock (&tc->mutex_ended))
+			return (-4);
+		if (pthread_mutex_unlock (&tc->mutex_started))
+			return (-5);
+
+		for (;;) {
+
+/* get lock on todo list
+*/
+			if (pthread_mutex_lock (&mutex_todo))
+				return (-6);
+			mywork = todo;
+			if (todo >= 0) {
+				++todo;
+				if (todo >= nwork)
+					todo = -1;
+			}
+			if (pthread_mutex_unlock (&mutex_todo))
+				return (-7);
+
+			if (mywork < 0)
+				break;
+
+			if ((n = do_work_unit (tc->id, mywork)) < 0)
+				return (-8);
+			tc->work += n;
+		}
+
+		if (pthread_mutex_lock (&tc->mutex_end))
+			return (-9);
+		if (pthread_mutex_unlock (&tc->mutex_end))
+			return (-10);
+		if (pthread_mutex_lock (&tc->mutex_started))
+			return (-11);
+		if (pthread_mutex_unlock (&tc->mutex_ended))
+			return (-12);
+
+		if (-2 == mywork)
+			break;
+	}
+
+	if (pthread_mutex_unlock (&tc->mutex_started))
+		return (-13);
+
+	return (0);
+}
+
+static int
+dosync (void)
+{
+	int		i;
+
+	for (i = 0; i < nthreads; ++i) {
+		if (pthread_mutex_lock (&tcs[i].mutex_end))
+			return (-1);
+		if (pthread_mutex_unlock (&tcs[i].mutex_start))
+			return (-2);
+		if (pthread_mutex_lock (&tcs[i].mutex_started))
+			return (-3);
+		if (pthread_mutex_unlock (&tcs[i].mutex_started))
+			return (-4);
+	}
+
+/* Now threads do their work
+*/
+	for (i = 0; i < nthreads; ++i) {
+		if (pthread_mutex_lock (&tcs[i].mutex_start))
+			return (-5);
+		if (pthread_mutex_unlock (&tcs[i].mutex_end))
+			return (-6);
+		if (pthread_mutex_lock (&tcs[i].mutex_ended))
+			return (-7);
+		if (pthread_mutex_unlock (&tcs[i].mutex_ended))
+			return (-8);
+	}
+
+	return (0);
+}
+
+static int
+dowork (void)
+{
+	todo = 0;
+	if (dosync () < 0)
+		return (-1);
+
+	todo = 0;
+	if (dosync () < 0)
+		return (-2);
+
+	return (0);
+}
+
+int
+main (int argc, char *argv[])
+{
+	int		i;
+	int		nargs;
+
+	nthreads  = 1;
+	nwork = 100;
+	nargs = 0;
+	for (i = 1; i < argc; ++i) {
+		if (!strcmp ("-q", argv[i])) {
+			quiet = 1;
+			continue;
+		}
+		if (!strcmp ("-h", argv[i])) {
+			printf ("usage: pthreads [nthreads] [nwork] [-q]\n");
+			exit (0);
+		}
+		switch (++nargs) {
+		case 1:
+			nthreads  = atoi (argv[i]);
+			if (nthreads > 36) {
+				printf ("max 36 threads allowed\n");
+				die (1);
+			}
+			break;
+		case 2:
+			nwork = atoi (argv[i]);
+			break;
+		default:
+			printf ("bad argument '%s'\n", argv[i]);
+			die (1);
+			break;
+		}
+	}
+
+	if (NULL == (tcs = calloc (nthreads, sizeof (*tcs))))
+		die (1);
+
+/* Launch threads
+*/
+	for (i = 0; i < nthreads; ++i) {
+		tcs[i].id = i;
+		pthread_mutex_init (&tcs[i].mutex_start, NULL);
+		pthread_mutex_init (&tcs[i].mutex_started, NULL);
+		pthread_mutex_init (&tcs[i].mutex_end, NULL);
+		pthread_mutex_init (&tcs[i].mutex_ended, NULL);
+		tcs[i].work = 0;
+		if (pthread_mutex_lock (&tcs[i].mutex_start))
+			{}
+		tcs[i].stat = pthread_create (&tcs[i].thread,
+			NULL /*&pthread_attr_default*/,
+			(void*)&print_server, (void *)&tcs[i]);
+
+/* Wait for thread initialisation
+*/
+		while (!pthread_mutex_trylock (&tcs[i].mutex_started))
+			pthread_mutex_unlock (&tcs[i].mutex_started);
+	}
+
+	dowork ();
+
+/* Terminate threads
+*/
+	todo = -2;	/* please terminate */
+	if (dosync () < 0)
+		die (2);
+
+	for (i = 0; i < nthreads; ++i) {
+		if (0 == tcs[i].stat)
+			pthread_join (tcs[i].thread, NULL);
+	}
+
+/* destroy locks
+*/
+	pthread_mutex_destroy (&mutex_stdout);
+	pthread_mutex_destroy (&mutex_todo);
+
+/* Cleanup
+*/
+	printf ("\n");
+
+/* Show results
+*/
+	for (i = 0; i < nthreads; ++i) {
+		printf ("%2d ", i);
+		if (0 == tcs[i].stat)
+			printf ("%10ld\n", tcs[i].work);
+		else
+			printf ("failed %d\n", tcs[i].stat);
+		pthread_mutex_destroy (&tcs[i].mutex_start);
+		pthread_mutex_destroy (&tcs[i].mutex_started);
+		pthread_mutex_destroy (&tcs[i].mutex_end);
+		pthread_mutex_destroy (&tcs[i].mutex_ended);
+	}
+
+	die (0);
+
+	return (0);
+}