diff options
Diffstat (limited to 'mit-pthreads/lib/libpthreadutil/pthread_tad.c')
| -rwxr-xr-x | mit-pthreads/lib/libpthreadutil/pthread_tad.c | 170 |
1 files changed, 170 insertions, 0 deletions
diff --git a/mit-pthreads/lib/libpthreadutil/pthread_tad.c b/mit-pthreads/lib/libpthreadutil/pthread_tad.c new file mode 100755 index 00000000000..a59fd9b87bf --- /dev/null +++ b/mit-pthreads/lib/libpthreadutil/pthread_tad.c @@ -0,0 +1,170 @@ +/* ==== pthread_tad.c ========================================================= + * Copyright (c) 1995 by Chris Provenzano, proven@athena.mit.edu + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Chris Provenzano, + * and its contributors. + * 4. Neither the name of Chris Provenzano, nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY CHRIS PROVENZANO, AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ + +#ifndef lint +static char copyright[] = + "@(#) Copyright (c) 1995 Chris Provenzano.\nAll rights reserved.\n"; +#endif /* not lint */ + +/* tad = thread allocation domain */ +#define PTHREAD_KERNEL + +#include "pthreadutil.h" +#include <stdio.h> +#include <errno.h> + +int pthread_tad_count(pthread_tad_t * tad) +{ + int ret; + + pthread_mutex_lock(&tad->mutex); + ret = tad->count_current; + pthread_mutex_unlock(&tad->mutex); + return(ret); +} + +static void pthread_tad_done(void * arg) +{ + pthread_tad_t * tad = arg; + pthread_mutex_lock(&tad->mutex); + --tad->count_current; +/* if (--tad->count_current < tad->count_max) */ + pthread_cond_broadcast(&tad->cond); + pthread_mutex_unlock(&tad->mutex); +} + +#ifndef PTHREAD_KERNEL +struct tad_start { + pthread_tad_t * tad; + void * (*routine)(); + void * arg; +}; + +static void * pthread_tad_start(struct tad_start * tad_start) +{ + void * (*routine)() = tad_start->routine; + void * arg = tad_start->arg; + + pthread_mutex_lock(&tad_start->tad->mutex); + pthread_cleanup_push(pthread_tad_done, tad_start->tad); + pthread_mutex_unlock(&tad_start->tad->mutex); + free(tad_start); + return(routine(arg)); +} +#else +static void * pthread_tad_start(void * tad_start_arg) +{ + pthread_tad_t * tad = tad_start_arg; + void * (*routine)() = tad->routine; + void * arg = tad->arg; + + tad->count_current++; + pthread_cleanup_push(pthread_tad_done, tad); + pthread_mutex_unlock(&tad->mutex); + return(routine(arg)); +} +#endif + +int pthread_tad_create(pthread_tad_t * tad, pthread_t *thread_id, + pthread_attr_t *attr, void * (*routine)(), void * arg) +{ +#ifndef PTHREAD_KERNEL + struct tad_start tad; +#endif + int ret; + + pthread_mutex_lock(&tad->mutex); + while (tad->count_max && (tad->count_current > tad->count_max)) + pthread_cond_wait(&tad->cond, &tad->mutex); + +#ifndef PTHREAD_KERNEL + if ((tad_start = malloc(sizeof(struct tad_start))) == NULL) { + pthread_mutex_unlock(&tad->mutex); + return(ENOMEM); + } + tad_start->routine = routine; + tad_start->arg = arg; + tad_start->tad = tad; + if ((ret = pthread_create(thread_id, attr, + pthread_tad_start, tad_start)) == OK) + tad->count_current++; + pthread_mutex_unlock(&tad->mutex); +#else + tad->routine = routine; + tad->arg = arg; + if (ret = pthread_create(thread_id, attr, pthread_tad_start, tad)) + pthread_mutex_unlock(&tad->mutex); +#endif + return(ret); +} + +int pthread_tad_wait(pthread_tad_t * tad, unsigned int count) +{ + if ((tad->count_max) && (tad->count_max < count)) { + return(EINVAL); + } + pthread_mutex_lock(&tad->mutex); + while (tad->count_current > count) + pthread_cond_wait(&tad->cond, &tad->mutex); + pthread_mutex_unlock(&tad->mutex); + return(OK); +} + +int pthread_tad_init(pthread_tad_t * tad, unsigned int max_count) +{ + int ret; + + if ((ret = pthread_mutex_init(&tad->mutex, NULL)) == OK) { + if (ret = pthread_cond_init(&tad->cond, NULL)) { + pthread_mutex_destroy(&tad->mutex); + } else { + tad->count_max = max_count; + tad->count_current = 0; + } + } + return(ret); +} + +/* User is responsible to make sure their are no threads running */ +int pthread_tad_destroy(pthread_tad_t * tad) +{ + int ret; + + if ((ret = pthread_mutex_destroy(&tad->mutex)) == OK) { + ret = pthread_cond_destroy(&tad->cond); + } else { + pthread_cond_destroy(&tad->cond); + } + tad->count_max = NOTOK; + return(ret); +} |