tp1.c

For more information about this program, see Controlling the number of threads in the Processes and Threads chapter.

/*
 *	tp1.c
 *
 *	Thread Pool Example (1)
 *
 *	1999 06 26 R. Krten
*/

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/neutrino.h>
#include <sys/dispatch.h>

char *progname = "tp1";

void
tag (char *name)
{
	time_t	t;
	char	buffer [BUFSIZ];

	time (&t);
	strftime (buffer, BUFSIZ, "%T ", localtime (&t));
	printf ("%s %3d %-20.20s:  ", buffer, pthread_self (), name);
}
	                                     
THREAD_POOL_PARAM_T *
blockfunc (THREAD_POOL_PARAM_T *ctp)
{
	tag ("blockfunc"); printf ("ctp %p\n", ctp);
	tag ("blockfunc"); printf ("sleep (%d);\n", 15 * pthread_self ());
	sleep (pthread_self () * 15);
	tag ("blockfunc"); printf ("done sleep\n");
	tag ("blockfunc"); printf ("returning 0x%08X\n", 0x10000000 + pthread_self ());
	return ((void *) (0x10000000 + pthread_self ()));		// passed to handlerfunc
}

THREAD_POOL_PARAM_T *
contextalloc (THREAD_POOL_HANDLE_T *handle)
{
	tag ("contextalloc"); printf ("handle %p\n", handle);
	tag ("contextalloc"); printf ("returning 0x%08X\n", 0x20000000 + pthread_self ());
	return ((void *) (0x20000000 + pthread_self ()));		// passed to blockfunc
}

void
contextfree (THREAD_POOL_PARAM_T *param)
{
	tag ("contextfree"); printf ("param %p\n", param);
}

void
unblockfunc (THREAD_POOL_PARAM_T *ctp)
{
	tag ("unblockfunc"); printf ("ctp %p\n", ctp);
}

int
handlerfunc (THREAD_POOL_PARAM_T *ctp)
{
	static int i = 0;

	tag ("handlerfunc"); printf ("ctp %p\n", ctp);
	if (i++ > 15) {
		tag ("handlerfunc"); printf ("exceeded 15 operations, return 0\n");
		return (0);
	}
	tag ("handlerfunc"); printf ("sleep (%d)\n", pthread_self () * 25);
	sleep (pthread_self () * 25);
	tag ("handlerfunc"); printf ("done sleep\n");

/*
	i = 0;
	if (i++ & 1) {
		tag ("handlerfunc"); printf ("returning 0\n");
		return (0);
	} else {
*/
		tag ("handlerfunc"); printf ("returning 0x%08X\n", 0x30000000 + pthread_self ());
		return (0x30000000 + pthread_self ());
/*
	}
*/
}


main ()
{
	thread_pool_attr_t	tp_attr;
	void				*tpp;

	memset (&tp_attr, 0, sizeof (tp_attr));
	tp_attr.handle = (void *) 0x12345678;		// passed to contextalloc
	tp_attr.block_func = blockfunc;
	tp_attr.unblock_func = unblockfunc;
	tp_attr.context_alloc = contextalloc;
	tp_attr.context_free = contextfree;
	tp_attr.handler_func = handlerfunc;

	tp_attr.lo_water = 3;
	tp_attr.hi_water = 7;
	tp_attr.increment = 2;
	tp_attr.maximum = 10;

    tpp = thread_pool_create (&tp_attr, POOL_FLAG_USE_SELF);
    if (tpp == NULL) {
        fprintf (stderr, 
                 "%s:  can't thread_pool_create, errno %s\n",
                 progname, strerror (errno));
        exit (EXIT_FAILURE);
    }

	thread_pool_start (tpp);

	fprintf (stderr, "%s:  thread_pool_start returned; errno %s\n",
             progname, strerror (errno));
	sleep (3000);
	exit (EXIT_FAILURE);
}