X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;ds=sidebyside;f=libraries%2Flibldap_r%2Ftpool.c;h=140e1af55a4de75211b14abd535d253bafbd62cb;hb=a4f0fc9941adcdab8a414eef05fecfa561097d8e;hp=c3e5686ca4ee206325267986d5a300dee5494331;hpb=1b15fa9c6e2b8b553dec255584067ff86030fb52;p=openldap diff --git a/libraries/libldap_r/tpool.c b/libraries/libldap_r/tpool.c index c3e5686ca4..140e1af55a 100644 --- a/libraries/libldap_r/tpool.c +++ b/libraries/libldap_r/tpool.c @@ -1,7 +1,7 @@ /* $OpenLDAP$ */ /* This work is part of OpenLDAP Software . * - * Copyright 1998-2007 The OpenLDAP Foundation. + * Copyright 1998-2012 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -17,6 +17,7 @@ #include +#include #include #include #include @@ -31,38 +32,42 @@ #ifndef LDAP_THREAD_HAVE_TPOOL -typedef enum ldap_int_thread_pool_state_e { - LDAP_INT_THREAD_POOL_RUNNING, - LDAP_INT_THREAD_POOL_FINISHING, - LDAP_INT_THREAD_POOL_STOPPING -} ldap_int_thread_pool_state_t; - -typedef struct ldap_int_thread_key_s { +/* Thread-specific key with data and optional free function */ +typedef struct ldap_int_tpool_key_s { void *ltk_key; void *ltk_data; ldap_pvt_thread_pool_keyfree_t *ltk_free; -} ldap_int_thread_key_t; +} ldap_int_tpool_key_t; /* Max number of thread-specific keys we store per thread. * We don't expect to use many... */ #define MAXKEYS 32 + +/* Max number of threads */ #define LDAP_MAXTHR 1024 /* must be a power of 2 */ +/* (Theoretical) max number of pending requests */ +#define MAX_PENDING (INT_MAX/2) /* INT_MAX - (room to avoid overflow) */ + +/* pool->ltp_pause values */ +enum { NOT_PAUSED = 0, WANT_PAUSE = 1, PAUSED = 2 }; + +/* Context: thread ID and thread-specific key/data pairs */ typedef struct ldap_int_thread_userctx_s { ldap_pvt_thread_t ltu_id; - ldap_int_thread_key_t ltu_key[MAXKEYS]; + ldap_int_tpool_key_t ltu_key[MAXKEYS]; } ldap_int_thread_userctx_t; -static ldap_pvt_thread_t tid_zero; -/* Thread ID -> context mapping (poor open-addressed hash table). +/* Simple {thread ID -> context} hash table; key=ctx->ltu_id. * Protected by ldap_pvt_thread_pool_mutex except during pauses, * when it is read-only (used by pool_purgekey and pool_context). + * Protected by tpool->ltp_mutex during pauses. */ static struct { - ldap_pvt_thread_t id; - ldap_int_thread_userctx_t *ctx; /* set when id != tid_zero */ + ldap_int_thread_userctx_t *ctx; + /* ctx is valid when not NULL or DELETED_THREAD_CTX */ # define DELETED_THREAD_CTX (&ldap_int_main_thrctx + 1) /* dummy addr */ } thread_keys[LDAP_MAXTHR]; @@ -74,34 +79,81 @@ static struct { } while(0) -typedef struct ldap_int_thread_ctx_s { +/* Task for a thread to perform */ +typedef struct ldap_int_thread_task_s { union { - LDAP_STAILQ_ENTRY(ldap_int_thread_ctx_s) q; - LDAP_SLIST_ENTRY(ldap_int_thread_ctx_s) l; - LDAP_SLIST_ENTRY(ldap_int_thread_ctx_s) al; - } ltc_next; - ldap_pvt_thread_start_t *ltc_start_routine; - void *ltc_arg; -} ldap_int_thread_ctx_t; + LDAP_STAILQ_ENTRY(ldap_int_thread_task_s) q; + LDAP_SLIST_ENTRY(ldap_int_thread_task_s) l; + } ltt_next; + ldap_pvt_thread_start_t *ltt_start_routine; + void *ltt_arg; +} ldap_int_thread_task_t; + +typedef LDAP_STAILQ_HEAD(tcq, ldap_int_thread_task_s) ldap_int_tpool_plist_t; struct ldap_int_thread_pool_s { LDAP_STAILQ_ENTRY(ldap_int_thread_pool_s) ltp_next; + + /* protect members below, and protect thread_keys[] during pauses */ ldap_pvt_thread_mutex_t ltp_mutex; + + /* not paused and something to do for pool_() */ ldap_pvt_thread_cond_t ltp_cond; + + /* ltp_active_count <= 1 && ltp_pause */ ldap_pvt_thread_cond_t ltp_pcond; - LDAP_STAILQ_HEAD(tcq, ldap_int_thread_ctx_s) ltp_pending_list; - LDAP_SLIST_HEAD(tcl, ldap_int_thread_ctx_s) ltp_free_list; - LDAP_SLIST_HEAD(tclq, ldap_int_thread_ctx_s) ltp_active_list; - ldap_int_thread_pool_state_t ltp_state; - int ltp_pause; - long ltp_max_count; - long ltp_max_pending; - long ltp_pending_count; - long ltp_active_count; - long ltp_open_count; - long ltp_starting; + + /* ltp_pause == 0 ? <p_pending_list : &empty_pending_list, + * maintaned to reduce work for pool_wrapper() + */ + ldap_int_tpool_plist_t *ltp_work_list; + + /* pending tasks, and unused task objects */ + ldap_int_tpool_plist_t ltp_pending_list; + LDAP_SLIST_HEAD(tcl, ldap_int_thread_task_s) ltp_free_list; + + /* The pool is finishing, waiting for its threads to close. + * They close when ltp_pending_list is done. pool_submit() + * rejects new tasks. ltp_max_pending = -(its old value). + */ + int ltp_finishing; + + /* Some active task needs to be the sole active task. + * Atomic variable so ldap_pvt_thread_pool_pausing() can read it. + * Note: Pauses adjust ltp_, + * so pool_() mostly can avoid testing ltp_pause. + */ + volatile sig_atomic_t ltp_pause; + + /* Max number of threads in pool, or 0 for default (LDAP_MAXTHR) */ + int ltp_max_count; + + /* Max pending + paused + idle tasks, negated when ltp_finishing */ + int ltp_max_pending; + + int ltp_pending_count; /* Pending + paused + idle tasks */ + int ltp_active_count; /* Active, not paused/idle tasks */ + int ltp_open_count; /* Number of threads, negated when ltp_pause */ + int ltp_starting; /* Currenlty starting threads */ + + /* >0 if paused or we may open a thread, <0 if we should close a thread. + * Updated when ltp_ change. + * Maintained to reduce the time ltp_mutex must be locked in + * ldap_pvt_thread_pool_(). + */ + int ltp_vary_open_count; +# define SET_VARY_OPEN_COUNT(pool) \ + ((pool)->ltp_vary_open_count = \ + (pool)->ltp_pause ? 1 : \ + (pool)->ltp_finishing ? -1 : \ + ((pool)->ltp_max_count ? (pool)->ltp_max_count : LDAP_MAXTHR) \ + - (pool)->ltp_open_count) }; +static ldap_int_tpool_plist_t empty_pending_list = + LDAP_STAILQ_HEAD_INITIALIZER(empty_pending_list); + +static int ldap_int_has_thread_pool = 0; static LDAP_STAILQ_HEAD(tpq, ldap_int_thread_pool_s) ldap_int_thread_pool_list = LDAP_STAILQ_HEAD_INITIALIZER(ldap_int_thread_pool_list); @@ -110,16 +162,16 @@ static ldap_pvt_thread_mutex_t ldap_pvt_thread_pool_mutex; static void *ldap_int_thread_pool_wrapper( void *pool ); -static ldap_pvt_thread_t ldap_int_main_tid; +static ldap_pvt_thread_key_t ldap_tpool_key; +/* Context of the main thread */ static ldap_int_thread_userctx_t ldap_int_main_thrctx; int ldap_int_thread_pool_startup ( void ) { - ldap_int_main_tid = ldap_pvt_thread_self(); - ldap_int_main_thrctx.ltu_id = ldap_int_main_tid; - + ldap_int_main_thrctx.ltu_id = ldap_pvt_thread_self(); + ldap_pvt_thread_key_create( &ldap_tpool_key ); return ldap_pvt_thread_mutex_init(&ldap_pvt_thread_pool_mutex); } @@ -132,134 +184,12 @@ ldap_int_thread_pool_shutdown ( void ) (ldap_pvt_thread_pool_destroy)(&pool, 0); /* ignore thr_debug macro */ } ldap_pvt_thread_mutex_destroy(&ldap_pvt_thread_pool_mutex); + ldap_pvt_thread_key_destroy( ldap_tpool_key ); return(0); } -typedef struct ldap_lazy_sem_t { - ldap_pvt_thread_mutex_t ls_mutex; - ldap_pvt_thread_cond_t ls_cond; - int ls_sem_value; - /* - * when more than ls_lazy_count number of resources - * becmoes available, the thread wating for the resources will - * be waken up in order to prevent frequent blocking/waking-up - */ - unsigned int ls_lazy_count; - /* - * only one thread(listener) will wait on this semaphore - * using a flag instead of a list - */ - int ls_wait; -} ldap_lazy_sem_t; - -ldap_lazy_sem_t* thread_pool_sem = NULL; - -int -ldap_lazy_sem_init( unsigned int value, unsigned int lazyness ) -{ - thread_pool_sem = (ldap_lazy_sem_t*) LDAP_CALLOC(1, - sizeof( ldap_lazy_sem_t )); - - if( thread_pool_sem == NULL ) return -1; - - ldap_pvt_thread_mutex_init( &thread_pool_sem->ls_mutex ); - ldap_pvt_thread_cond_init( &thread_pool_sem->ls_cond ); - thread_pool_sem->ls_sem_value = value; - thread_pool_sem->ls_lazy_count = lazyness; - thread_pool_sem->ls_wait = 0; - - return 0; -} - -/* FIXME: move to some approprite header */ -int ldap_lazy_sem_dec( ldap_lazy_sem_t* ls ); -int ldap_lazy_sem_wait ( ldap_lazy_sem_t* ls ); - -/* - * ldap_lazy_sem_wait is used if a caller is blockable(listener). - * Otherwise use ldap_lazy_sem_dec (worker) - */ -int -ldap_lazy_sem_op_submit( ldap_lazy_sem_t* ls ) -{ - if ( ls == NULL ) return -1; - - /* only worker thread has its thread ctx */ - if ( ldap_pvt_thread_pool_context() ) { - /* worker thread */ - return ldap_lazy_sem_dec( ls ); - } else { - /* listener */ - return ldap_lazy_sem_wait( ls ); - } -} - -/* - * test if given semaphore's count is zero. - * If 0, the caller is blocked - * If not, the count is decremented. - */ -int -ldap_lazy_sem_wait ( ldap_lazy_sem_t* ls ) -{ - ldap_pvt_thread_mutex_lock( &ls->ls_mutex ); - -lazy_sem_retry: - if ( ls->ls_sem_value <= 0 ) { - /* no more avaliable resources */ - ls->ls_wait = 1; - ldap_pvt_thread_cond_wait( &ls->ls_cond, &ls->ls_mutex ); - goto lazy_sem_retry; - } else { - /* avaliable resources */ - ls->ls_sem_value--; - } - - ldap_pvt_thread_mutex_unlock( &ls->ls_mutex ); - - return 0; -} - -/* - * decrement the count without blocking - * even when the count becomes less than or equal to 0 - */ -int -ldap_lazy_sem_dec( ldap_lazy_sem_t* ls ) -{ - ldap_pvt_thread_mutex_lock( &ls->ls_mutex ); - - ls->ls_sem_value--; - - ldap_pvt_thread_mutex_unlock( &ls->ls_mutex ); - - return 0; -} - -/* - * Increment the count by one and test if it is greater or - * equal to lazyness. If it is, wake up a blocked thread. - */ -int -ldap_lazy_sem_post( ldap_lazy_sem_t* ls ) -{ - if( ls == NULL ) return (-1); - - ldap_pvt_thread_mutex_lock( &ls->ls_mutex ); - - ls->ls_sem_value++; - if ( ls->ls_wait ) { - if ( ls->ls_sem_value >= ls->ls_lazy_count ) { - ls->ls_wait = 0; - ldap_pvt_thread_cond_signal( &ls->ls_cond ); - } - } - - ldap_pvt_thread_mutex_unlock( &ls->ls_mutex ); - - return 0; -} +/* Create a thread pool */ int ldap_pvt_thread_pool_init ( ldap_pvt_thread_pool_t *tpool, @@ -269,8 +199,13 @@ ldap_pvt_thread_pool_init ( ldap_pvt_thread_pool_t pool; int rc; + /* multiple pools are currently not supported (ITS#4943) */ + assert(!ldap_int_has_thread_pool); + if (! (0 <= max_threads && max_threads <= LDAP_MAXTHR)) max_threads = 0; + if (! (1 <= max_pending && max_pending <= MAX_PENDING)) + max_pending = MAX_PENDING; *tpool = NULL; pool = (ldap_pvt_thread_pool_t) LDAP_CALLOC(1, @@ -287,63 +222,41 @@ ldap_pvt_thread_pool_init ( rc = ldap_pvt_thread_cond_init(&pool->ltp_pcond); if (rc != 0) return(rc); - pool->ltp_state = LDAP_INT_THREAD_POOL_RUNNING; + + ldap_int_has_thread_pool = 1; + pool->ltp_max_count = max_threads; + SET_VARY_OPEN_COUNT(pool); pool->ltp_max_pending = max_pending; + LDAP_STAILQ_INIT(&pool->ltp_pending_list); + pool->ltp_work_list = &pool->ltp_pending_list; LDAP_SLIST_INIT(&pool->ltp_free_list); - LDAP_SLIST_INIT(&pool->ltp_active_list); + ldap_pvt_thread_mutex_lock(&ldap_pvt_thread_pool_mutex); LDAP_STAILQ_INSERT_TAIL(&ldap_int_thread_pool_list, pool, ltp_next); ldap_pvt_thread_mutex_unlock(&ldap_pvt_thread_pool_mutex); -#if 0 - /* THIS WILL NOT WORK on some systems. If the process - * forks after starting a thread, there is no guarantee - * that the thread will survive the fork. For example, - * slapd forks in order to daemonize, and does so after - * calling ldap_pvt_thread_pool_init. On some systems, - * this initial thread does not run in the child process, - * but ltp_open_count == 1, so two things happen: - * 1) the first client connection fails, and 2) when - * slapd is kill'ed, it never terminates since it waits - * for all worker threads to exit. */ - - /* start up one thread, just so there is one. no need to - * lock the mutex right now, since no threads are running. + /* Start no threads just yet. That can break if the process forks + * later, as slapd does in order to daemonize. On at least POSIX, + * only the forking thread would survive in the child. Yet fork() + * can't unlock/clean up other threads' locks and data structures, + * unless pthread_atfork() handlers have been set up to do so. */ - pool->ltp_open_count++; - - ldap_pvt_thread_t thr; - rc = ldap_pvt_thread_create( &thr, 1, ldap_int_thread_pool_wrapper, pool ); - - if( rc != 0) { - /* couldn't start one? then don't start any */ - ldap_pvt_thread_mutex_lock(&ldap_pvt_thread_pool_mutex); - LDAP_STAILQ_REMOVE(ldap_int_thread_pool_list, pool, - ldap_int_thread_pool_s, ltp_next); - ldap_pvt_thread_mutex_unlock(&ldap_pvt_thread_pool_mutex); - ldap_pvt_thread_cond_destroy(&pool->ltp_pcond); - ldap_pvt_thread_cond_destroy(&pool->ltp_cond); - ldap_pvt_thread_mutex_destroy(&pool->ltp_mutex); - LDAP_FREE(pool); - return(-1); - } -#endif *tpool = pool; return(0); } +/* Submit a task to be performed by the thread pool */ int ldap_pvt_thread_pool_submit ( ldap_pvt_thread_pool_t *tpool, ldap_pvt_thread_start_t *start_routine, void *arg ) { struct ldap_int_thread_pool_s *pool; - ldap_int_thread_ctx_t *ctx; - int need_thread = 0; + ldap_int_thread_task_t *task; ldap_pvt_thread_t thr; if (tpool == NULL) @@ -355,109 +268,131 @@ ldap_pvt_thread_pool_submit ( return(-1); ldap_pvt_thread_mutex_lock(&pool->ltp_mutex); - if (pool->ltp_state != LDAP_INT_THREAD_POOL_RUNNING - || (pool->ltp_max_pending > 0 - && pool->ltp_pending_count >= pool->ltp_max_pending)) - { - ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); - return(-1); - } - ctx = LDAP_SLIST_FIRST(&pool->ltp_free_list); - if (ctx) { - LDAP_SLIST_REMOVE_HEAD(&pool->ltp_free_list, ltc_next.l); + if (pool->ltp_pending_count >= pool->ltp_max_pending) + goto failed; + + task = LDAP_SLIST_FIRST(&pool->ltp_free_list); + if (task) { + LDAP_SLIST_REMOVE_HEAD(&pool->ltp_free_list, ltt_next.l); } else { - ctx = (ldap_int_thread_ctx_t *) LDAP_MALLOC( - sizeof(ldap_int_thread_ctx_t)); - if (ctx == NULL) { - ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); - return(-1); - } + task = (ldap_int_thread_task_t *) LDAP_MALLOC(sizeof(*task)); + if (task == NULL) + goto failed; } - ctx->ltc_start_routine = start_routine; - ctx->ltc_arg = arg; + task->ltt_start_routine = start_routine; + task->ltt_arg = arg; pool->ltp_pending_count++; - LDAP_STAILQ_INSERT_TAIL(&pool->ltp_pending_list, ctx, ltc_next.q); - if (pool->ltp_pause) { - ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); - return(0); - } - ldap_pvt_thread_cond_signal(&pool->ltp_cond); - if (pool->ltp_open_count < pool->ltp_active_count + pool->ltp_pending_count - && (pool->ltp_open_count < - (pool->ltp_max_count ? pool->ltp_max_count : LDAP_MAXTHR))) + LDAP_STAILQ_INSERT_TAIL(&pool->ltp_pending_list, task, ltt_next.q); + + /* true if ltp_pause != 0 or we should open (create) a thread */ + if (pool->ltp_vary_open_count > 0 && + pool->ltp_open_count < pool->ltp_active_count+pool->ltp_pending_count) { - pool->ltp_open_count++; - pool->ltp_starting++; - need_thread = 1; - } + if (pool->ltp_pause) + goto done; -#ifdef LDAP_PVT_THREAD_POOL_SEM_LOAD_CONTROL - ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); - ldap_lazy_sem_op_submit( thread_pool_sem ); - /* FIXME: Another thread can now handle and release ctx, after - * which a newly submitted op can reuse ctx. Then it is wrong for - * the "if (pool->ltp_open_count == 0)" code below to release ctx. - */ -#endif + pool->ltp_starting++; + pool->ltp_open_count++; + SET_VARY_OPEN_COUNT(pool); - if (need_thread) { if (0 != ldap_pvt_thread_create( &thr, 1, ldap_int_thread_pool_wrapper, pool)) { /* couldn't create thread. back out of * ltp_open_count and check for even worse things. */ -#ifdef LDAP_PVT_THREAD_POOL_SEM_LOAD_CONTROL - ldap_pvt_thread_mutex_lock(&pool->ltp_mutex); -#endif pool->ltp_starting--; pool->ltp_open_count--; + SET_VARY_OPEN_COUNT(pool); + if (pool->ltp_open_count == 0) { /* no open threads at all?!? */ - ldap_int_thread_ctx_t *ptr; + ldap_int_thread_task_t *ptr; /* let pool_destroy know there are no more threads */ ldap_pvt_thread_cond_signal(&pool->ltp_cond); - LDAP_STAILQ_FOREACH(ptr, &pool->ltp_pending_list, ltc_next.q) - if (ptr == ctx) break; - if (ptr == ctx) { - /* no open threads, context not handled, so - * back out of ltp_pending_count, free the context, + LDAP_STAILQ_FOREACH(ptr, &pool->ltp_pending_list, ltt_next.q) + if (ptr == task) break; + if (ptr == task) { + /* no open threads, task not handled, so + * back out of ltp_pending_count, free the task, * report the error. */ - LDAP_STAILQ_REMOVE(&pool->ltp_pending_list, ctx, - ldap_int_thread_ctx_s, ltc_next.q); pool->ltp_pending_count--; - ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); - LDAP_FREE(ctx); - return(-1); + LDAP_STAILQ_REMOVE(&pool->ltp_pending_list, task, + ldap_int_thread_task_s, ltt_next.q); + LDAP_SLIST_INSERT_HEAD(&pool->ltp_free_list, task, + ltt_next.l); + goto failed; } } -#ifdef LDAP_PVT_THREAD_POOL_SEM_LOAD_CONTROL - ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); -#endif /* there is another open thread, so this - * context will be handled eventually. - * continue on, we have signalled that - * the context is waiting. + * task will be handled eventually. */ } } + ldap_pvt_thread_cond_signal(&pool->ltp_cond); -#ifndef LDAP_PVT_THREAD_POOL_SEM_LOAD_CONTROL + done: ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); -#endif - return(0); + + failed: + ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); + return(-1); +} + +static void * +no_task( void *ctx, void *arg ) +{ + return NULL; } +/* Cancel a pending task that was previously submitted. + * Return 1 if the task was successfully cancelled, 0 if + * not found, -1 for invalid parameters + */ int -ldap_pvt_thread_pool_maxthreads ( ldap_pvt_thread_pool_t *tpool, int max_threads ) +ldap_pvt_thread_pool_retract ( + ldap_pvt_thread_pool_t *tpool, + ldap_pvt_thread_start_t *start_routine, void *arg ) +{ + struct ldap_int_thread_pool_s *pool; + ldap_int_thread_task_t *task; + + if (tpool == NULL) + return(-1); + + pool = *tpool; + + if (pool == NULL) + return(-1); + + ldap_pvt_thread_mutex_lock(&pool->ltp_mutex); + LDAP_STAILQ_FOREACH(task, &pool->ltp_pending_list, ltt_next.q) + if (task->ltt_start_routine == start_routine && + task->ltt_arg == arg) { + /* Could LDAP_STAILQ_REMOVE the task, but that + * walks ltp_pending_list again to find it. + */ + task->ltt_start_routine = no_task; + task->ltt_arg = NULL; + break; + } + ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); + return task != NULL; +} + +/* Set max #threads. value <= 0 means max supported #threads (LDAP_MAXTHR) */ +int +ldap_pvt_thread_pool_maxthreads( + ldap_pvt_thread_pool_t *tpool, + int max_threads ) { struct ldap_int_thread_pool_s *pool; @@ -473,13 +408,20 @@ ldap_pvt_thread_pool_maxthreads ( ldap_pvt_thread_pool_t *tpool, int max_threads return(-1); ldap_pvt_thread_mutex_lock(&pool->ltp_mutex); + pool->ltp_max_count = max_threads; + SET_VARY_OPEN_COUNT(pool); + ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); return(0); } +/* Inspect the pool */ int -ldap_pvt_thread_pool_query ( ldap_pvt_thread_pool_t *tpool, ldap_pvt_thread_pool_param_t param, void *value ) +ldap_pvt_thread_pool_query( + ldap_pvt_thread_pool_t *tpool, + ldap_pvt_thread_pool_param_t param, + void *value ) { struct ldap_int_thread_pool_s *pool; int count = -1; @@ -502,10 +444,16 @@ ldap_pvt_thread_pool_query ( ldap_pvt_thread_pool_t *tpool, ldap_pvt_thread_pool case LDAP_PVT_THREAD_POOL_PARAM_MAX_PENDING: count = pool->ltp_max_pending; + if (count < 0) + count = -count; + if (count == MAX_PENDING) + count = 0; break; case LDAP_PVT_THREAD_POOL_PARAM_OPEN: count = pool->ltp_open_count; + if (count < 0) + count = -count; break; case LDAP_PVT_THREAD_POOL_PARAM_STARTING: @@ -516,6 +464,10 @@ ldap_pvt_thread_pool_query ( ldap_pvt_thread_pool_t *tpool, ldap_pvt_thread_pool count = pool->ltp_active_count; break; + case LDAP_PVT_THREAD_POOL_PARAM_PAUSING: + count = (pool->ltp_pause != 0); + break; + case LDAP_PVT_THREAD_POOL_PARAM_PENDING: count = pool->ltp_pending_count; break; @@ -533,32 +485,15 @@ ldap_pvt_thread_pool_query ( ldap_pvt_thread_pool_t *tpool, ldap_pvt_thread_pool case LDAP_PVT_THREAD_POOL_PARAM_BACKLOAD_MAX: break; - case LDAP_PVT_THREAD_POOL_PARAM_STATE: { - static struct { - char *name; - ldap_int_thread_pool_state_t state; - } str2state[] = { - { "running", LDAP_INT_THREAD_POOL_RUNNING }, - { "finishing", LDAP_INT_THREAD_POOL_FINISHING }, - { "stopping", LDAP_INT_THREAD_POOL_STOPPING }, - { NULL } - }; - int i; - - if ( pool->ltp_pause ) { - *((char **)value) = "pausing"; - } else { - for ( i = 0; str2state[ i ].name != NULL; i++ ) { - if ( str2state[ i ].state == pool->ltp_state ) { - break; - } - } - *((char **)value) = str2state[ i ].name; - } - if ( *((char **)value) != NULL ) { - count = -2; - } - } break; + case LDAP_PVT_THREAD_POOL_PARAM_STATE: + *((char **)value) = + pool->ltp_pause ? "pausing" : + !pool->ltp_finishing ? "running" : + pool->ltp_pending_count ? "finishing" : "stopping"; + break; + + case LDAP_PVT_THREAD_POOL_PARAM_UNKNOWN: + break; } ldap_pvt_thread_mutex_unlock( &pool->ltp_mutex ); @@ -569,6 +504,23 @@ ldap_pvt_thread_pool_query ( ldap_pvt_thread_pool_t *tpool, ldap_pvt_thread_pool return ( count == -1 ? -1 : 0 ); } +/* + * true if pool is pausing; does not lock any mutex to check. + * 0 if not pause, 1 if pause, -1 if error or no pool. + */ +int +ldap_pvt_thread_pool_pausing( ldap_pvt_thread_pool_t *tpool ) +{ + int rc = -1; + struct ldap_int_thread_pool_s *pool; + + if ( tpool != NULL && (pool = *tpool) != NULL ) { + rc = (pool->ltp_pause != 0); + } + + return rc; +} + /* * wrapper for ldap_pvt_thread_pool_query(), left around * for backwards compatibility @@ -588,11 +540,12 @@ ldap_pvt_thread_pool_backload ( ldap_pvt_thread_pool_t *tpool ) return rc; } +/* Destroy the pool after making its threads finish */ int ldap_pvt_thread_pool_destroy ( ldap_pvt_thread_pool_t *tpool, int run_pending ) { struct ldap_int_thread_pool_s *pool, *pptr; - ldap_int_thread_ctx_t *ctx; + ldap_int_thread_task_t *task; if (tpool == NULL) return(-1); @@ -612,59 +565,63 @@ ldap_pvt_thread_pool_destroy ( ldap_pvt_thread_pool_t *tpool, int run_pending ) if (pool != pptr) return(-1); ldap_pvt_thread_mutex_lock(&pool->ltp_mutex); - pool->ltp_state = run_pending - ? LDAP_INT_THREAD_POOL_FINISHING - : LDAP_INT_THREAD_POOL_STOPPING; + + pool->ltp_finishing = 1; + SET_VARY_OPEN_COUNT(pool); + if (pool->ltp_max_pending > 0) + pool->ltp_max_pending = -pool->ltp_max_pending; + + if (!run_pending) { + while ((task = LDAP_STAILQ_FIRST(&pool->ltp_pending_list)) != NULL) { + LDAP_STAILQ_REMOVE_HEAD(&pool->ltp_pending_list, ltt_next.q); + LDAP_FREE(task); + } + pool->ltp_pending_count = 0; + } while (pool->ltp_open_count) { if (!pool->ltp_pause) ldap_pvt_thread_cond_broadcast(&pool->ltp_cond); ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex); } - ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); - - while ((ctx = LDAP_STAILQ_FIRST(&pool->ltp_pending_list)) != NULL) - { - LDAP_STAILQ_REMOVE_HEAD(&pool->ltp_pending_list, ltc_next.q); - LDAP_FREE(ctx); - } - while ((ctx = LDAP_SLIST_FIRST(&pool->ltp_free_list)) != NULL) + while ((task = LDAP_SLIST_FIRST(&pool->ltp_free_list)) != NULL) { - LDAP_SLIST_REMOVE_HEAD(&pool->ltp_free_list, ltc_next.l); - LDAP_FREE(ctx); + LDAP_SLIST_REMOVE_HEAD(&pool->ltp_free_list, ltt_next.l); + LDAP_FREE(task); } + ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); ldap_pvt_thread_cond_destroy(&pool->ltp_pcond); ldap_pvt_thread_cond_destroy(&pool->ltp_cond); ldap_pvt_thread_mutex_destroy(&pool->ltp_mutex); LDAP_FREE(pool); -#ifdef LDAP_PVT_THREAD_POOL_SEM_LOAD_CONTROL - if ( thread_pool_sem ) { - LDAP_FREE( thread_pool_sem ); - } -#endif + *tpool = NULL; + ldap_int_has_thread_pool = 0; return(0); } +/* Thread loop. Accept and handle submitted tasks. */ static void * ldap_int_thread_pool_wrapper ( void *xpool ) { struct ldap_int_thread_pool_s *pool = xpool; - ldap_int_thread_ctx_t *ctx; - ldap_int_thread_userctx_t uctx; + ldap_int_thread_task_t *task; + ldap_int_tpool_plist_t *work_list; + ldap_int_thread_userctx_t ctx, *kctx; unsigned i, keyslot, hash; - if (pool == NULL) - return NULL; + assert(pool != NULL); for ( i=0; iltp_mutex); @@ -678,92 +635,77 @@ ldap_int_thread_pool_wrapper ( */ ldap_pvt_thread_mutex_lock(&ldap_pvt_thread_pool_mutex); for (keyslot = hash & (LDAP_MAXTHR-1); - !ldap_pvt_thread_equal(thread_keys[keyslot].id, tid_zero); + (kctx = thread_keys[keyslot].ctx) && kctx != DELETED_THREAD_CTX; keyslot = (keyslot+1) & (LDAP_MAXTHR-1)); - thread_keys[keyslot].id = uctx.ltu_id; - thread_keys[keyslot].ctx = &uctx; + thread_keys[keyslot].ctx = &ctx; ldap_pvt_thread_mutex_unlock(&ldap_pvt_thread_pool_mutex); pool->ltp_starting--; + pool->ltp_active_count++; for (;;) { - while (pool->ltp_pause) - ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex); + work_list = pool->ltp_work_list; /* help the compiler a bit */ + task = LDAP_STAILQ_FIRST(work_list); + if (task == NULL) { /* paused or no pending tasks */ + if (--(pool->ltp_active_count) < 2) { + /* Notify pool_pause it is the sole active thread. */ + ldap_pvt_thread_cond_signal(&pool->ltp_pcond); + } - if (pool->ltp_state == LDAP_INT_THREAD_POOL_STOPPING) - break; + do { + if (pool->ltp_vary_open_count < 0) { + /* Not paused, and either finishing or too many + * threads running (can happen if ltp_max_count + * was reduced). Let this thread die. + */ + goto done; + } - ctx = LDAP_STAILQ_FIRST(&pool->ltp_pending_list); - if (ctx == NULL) { - if (pool->ltp_state == LDAP_INT_THREAD_POOL_FINISHING) - break; - - if (pool->ltp_open_count > - (pool->ltp_max_count ? pool->ltp_max_count : LDAP_MAXTHR)) - { - /* too many threads running (can happen if the - * maximum threads value is set during ongoing - * operation using ldap_pvt_thread_pool_maxthreads) - * so let this thread die. + /* We could check an idle timer here, and let the + * thread die if it has been inactive for a while. + * Only die if there are other open threads (i.e., + * always have at least one thread open). + * The check should be like this: + * if (pool->ltp_open_count>1 && pool->ltp_starting==0) + * check timer, wait if ltp_pause, leave thread; + * + * Just use pthread_cond_timedwait() if we want to + * check idle time. */ - break; - } + ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex); - /* we could check an idle timer here, and let the - * thread die if it has been inactive for a while. - * only die if there are other open threads (i.e., - * always have at least one thread open). the check - * should be like this: - * if (pool->ltp_open_count > 1 && pool->ltp_starting == 0) - * check timer, wait if ltp_pause, leave thread (break;) - * - * Just use pthread_cond_timedwait if we want to - * check idle time. - */ + work_list = pool->ltp_work_list; + task = LDAP_STAILQ_FIRST(work_list); + } while (task == NULL); - assert(pool->ltp_state == LDAP_INT_THREAD_POOL_RUNNING); - ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex); - continue; + pool->ltp_active_count++; } - LDAP_STAILQ_REMOVE_HEAD(&pool->ltp_pending_list, ltc_next.q); + LDAP_STAILQ_REMOVE_HEAD(work_list, ltt_next.q); pool->ltp_pending_count--; - - LDAP_SLIST_INSERT_HEAD(&pool->ltp_active_list, ctx, ltc_next.al); - pool->ltp_active_count++; ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); - ctx->ltc_start_routine(&uctx, ctx->ltc_arg); + task->ltt_start_routine(&ctx, task->ltt_arg); -#ifdef LDAP_PVT_THREAD_POOL_SEM_LOAD_CONTROL - ldap_lazy_sem_post( thread_pool_sem ); -#endif ldap_pvt_thread_mutex_lock(&pool->ltp_mutex); - LDAP_SLIST_REMOVE(&pool->ltp_active_list, ctx, - ldap_int_thread_ctx_s, ltc_next.al); - LDAP_SLIST_INSERT_HEAD(&pool->ltp_free_list, ctx, ltc_next.l); - pool->ltp_active_count--; - - /* let pool_pause know when it is the sole active thread */ - if (pool->ltp_active_count < 2) - ldap_pvt_thread_cond_signal(&pool->ltp_pcond); + LDAP_SLIST_INSERT_HEAD(&pool->ltp_free_list, task, ltt_next.l); } + done: - ldap_pvt_thread_pool_context_reset(&uctx); + assert(!pool->ltp_pause); /* thread_keys writable, ltp_open_count >= 0 */ - /* Needed if context_reset can let another thread request a pause */ - while (pool->ltp_pause) - ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex); + /* The ltp_mutex lock protects ctx->ltu_key from pool_purgekey() + * during this call, since it prevents new pauses. */ + ldap_pvt_thread_pool_context_reset(&ctx); ldap_pvt_thread_mutex_lock(&ldap_pvt_thread_pool_mutex); thread_keys[keyslot].ctx = DELETED_THREAD_CTX; - thread_keys[keyslot].id = tid_zero; ldap_pvt_thread_mutex_unlock(&ldap_pvt_thread_pool_mutex); pool->ltp_open_count--; - + SET_VARY_OPEN_COUNT(pool); /* let pool_destroy know we're all done */ - if (pool->ltp_open_count < 1) + if (pool->ltp_open_count == 0) ldap_pvt_thread_cond_signal(&pool->ltp_cond); ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); @@ -772,11 +714,21 @@ ldap_int_thread_pool_wrapper ( return(NULL); } -int -ldap_pvt_thread_pool_pause ( - ldap_pvt_thread_pool_t *tpool ) +/* Arguments > ltp_pause to handle_pause(,PAUSE_ARG()). arg=PAUSE_ARG + * ensures (arg-ltp_pause) sets GO_* at need and keeps DO_PAUSE/GO_*. + */ +#define GO_IDLE 8 +#define GO_UNIDLE 16 +#define CHECK_PAUSE 32 /* if ltp_pause: GO_IDLE; wait; GO_UNIDLE */ +#define DO_PAUSE 64 /* CHECK_PAUSE; pause the pool */ +#define PAUSE_ARG(a) \ + ((a) | ((a) & (GO_IDLE|GO_UNIDLE) ? GO_IDLE-1 : CHECK_PAUSE)) + +static int +handle_pause( ldap_pvt_thread_pool_t *tpool, int pause_type ) { struct ldap_int_thread_pool_s *pool; + int ret = 0, pause, max_ltp_pause; if (tpool == NULL) return(-1); @@ -786,30 +738,100 @@ ldap_pvt_thread_pool_pause ( if (pool == NULL) return(0); + if (pause_type == CHECK_PAUSE && !pool->ltp_pause) + return(0); + + /* Let pool_unidle() ignore requests for new pauses */ + max_ltp_pause = pause_type==PAUSE_ARG(GO_UNIDLE) ? WANT_PAUSE : NOT_PAUSED; + ldap_pvt_thread_mutex_lock(&pool->ltp_mutex); - /* If someone else has already requested a pause, we have to wait */ - while (pool->ltp_pause) { + pause = pool->ltp_pause; /* NOT_PAUSED, WANT_PAUSE or PAUSED */ + + /* If ltp_pause and not GO_IDLE|GO_UNIDLE: Set GO_IDLE,GO_UNIDLE */ + pause_type -= pause; + + if (pause_type & GO_IDLE) { pool->ltp_pending_count++; pool->ltp_active_count--; - /* let the other pool_pause() know when it can proceed */ - if (pool->ltp_active_count < 2) + if (pause && pool->ltp_active_count < 2) { + /* Tell the task waiting to DO_PAUSE it can proceed */ ldap_pvt_thread_cond_signal(&pool->ltp_pcond); - ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex); + } + } + + if (pause_type & GO_UNIDLE) { + /* Wait out pause if any, then cancel GO_IDLE */ + if (pause > max_ltp_pause) { + ret = 1; + do { + ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex); + } while (pool->ltp_pause > max_ltp_pause); + } pool->ltp_pending_count--; pool->ltp_active_count++; } - /* Wait for everyone else to pause or finish */ - pool->ltp_pause = 1; - while (pool->ltp_active_count > 1) { - ldap_pvt_thread_cond_wait(&pool->ltp_pcond, &pool->ltp_mutex); + if (pause_type & DO_PAUSE) { + /* Tell everyone else to pause or finish, then await that */ + ret = 0; + assert(!pool->ltp_pause); + pool->ltp_pause = WANT_PAUSE; + /* Let ldap_pvt_thread_pool_submit() through to its ltp_pause test, + * and do not finish threads in ldap_pvt_thread_pool_wrapper() */ + pool->ltp_open_count = -pool->ltp_open_count; + SET_VARY_OPEN_COUNT(pool); + /* Hide pending tasks from ldap_pvt_thread_pool_wrapper() */ + pool->ltp_work_list = &empty_pending_list; + /* Wait for this task to become the sole active task */ + while (pool->ltp_active_count > 1) { + ldap_pvt_thread_cond_wait(&pool->ltp_pcond, &pool->ltp_mutex); + } + assert(pool->ltp_pause == WANT_PAUSE); + pool->ltp_pause = PAUSED; } ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); - return(0); + return(ret); +} + +/* Consider this task idle: It will not block pool_pause() in other tasks. */ +void +ldap_pvt_thread_pool_idle( ldap_pvt_thread_pool_t *tpool ) +{ + handle_pause(tpool, PAUSE_ARG(GO_IDLE)); +} + +/* Cancel pool_idle(). If the pool is paused, wait it out first. */ +void +ldap_pvt_thread_pool_unidle( ldap_pvt_thread_pool_t *tpool ) +{ + handle_pause(tpool, PAUSE_ARG(GO_UNIDLE)); +} + +/* + * If a pause was requested, wait for it. If several threads + * are waiting to pause, let through one or more pauses. + * The calling task must be active, not idle. + * Return 1 if we waited, 0 if not, -1 at parameter error. + */ +int +ldap_pvt_thread_pool_pausecheck( ldap_pvt_thread_pool_t *tpool ) +{ + return handle_pause(tpool, PAUSE_ARG(CHECK_PAUSE)); +} + +/* + * Pause the pool. The calling task must be active, not idle. + * Return when all other tasks are paused or idle. + */ +int +ldap_pvt_thread_pool_pause( ldap_pvt_thread_pool_t *tpool ) +{ + return handle_pause(tpool, PAUSE_ARG(DO_PAUSE)); } +/* End a pause */ int ldap_pvt_thread_pool_resume ( ldap_pvt_thread_pool_t *tpool ) @@ -825,12 +847,23 @@ ldap_pvt_thread_pool_resume ( return(0); ldap_pvt_thread_mutex_lock(&pool->ltp_mutex); + + assert(pool->ltp_pause == PAUSED); pool->ltp_pause = 0; + if (pool->ltp_open_count <= 0) /* true when paused, but be paranoid */ + pool->ltp_open_count = -pool->ltp_open_count; + SET_VARY_OPEN_COUNT(pool); + pool->ltp_work_list = &pool->ltp_pending_list; + ldap_pvt_thread_cond_broadcast(&pool->ltp_cond); + ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); return(0); } +/* + * Get the key's data and optionally free function in the given context. + */ int ldap_pvt_thread_pool_getkey( void *xctx, void *key, @@ -860,11 +893,22 @@ clear_key_idx( ldap_int_thread_userctx_t *ctx, int i ) ctx->ltu_key[i].ltk_key = NULL; } +/* + * Set or remove data for the key in the given context. + * key can be any unique pointer. + * kfree() is an optional function to free the data (but not the key): + * pool_context_reset() and pool_purgekey() call kfree(key, data), + * but pool_setkey() does not. For pool_setkey() it is the caller's + * responsibility to free any existing data with the same key. + * kfree() must not call functions taking a tpool argument. + */ int ldap_pvt_thread_pool_setkey( void *xctx, void *key, void *data, - ldap_pvt_thread_pool_keyfree_t *kfree ) + ldap_pvt_thread_pool_keyfree_t *kfree, + void **olddatap, + ldap_pvt_thread_pool_keyfree_t **oldkfreep ) { ldap_int_thread_userctx_t *ctx = xctx; int i, found; @@ -880,6 +924,22 @@ int ldap_pvt_thread_pool_setkey( } } + if ( olddatap ) { + if ( found ) { + *olddatap = ctx->ltu_key[i].ltk_data; + } else { + *olddatap = NULL; + } + } + + if ( oldkfreep ) { + if ( found ) { + *oldkfreep = ctx->ltu_key[i].ltk_free; + } else { + *oldkfreep = 0; + } + } + if ( data || kfree ) { if ( i>=MAXKEYS ) return ENOMEM; @@ -920,6 +980,7 @@ void ldap_pvt_thread_pool_purgekey( void *key ) } /* + * Find the context of the current thread. * This is necessary if the caller does not have access to the * thread context handle (for example, a slapd plugin calling * slapi_search_internal()). No doubt it is more efficient @@ -928,30 +989,17 @@ void ldap_pvt_thread_pool_purgekey( void *key ) */ void *ldap_pvt_thread_pool_context( ) { - ldap_pvt_thread_t tid; - unsigned i, hash; - ldap_int_thread_userctx_t *ctx; - - tid = ldap_pvt_thread_self(); - if ( ldap_pvt_thread_equal( tid, ldap_int_main_tid )) - return &ldap_int_main_thrctx; + void *ctx = NULL; - TID_HASH( tid, hash ); - i = hash &= (LDAP_MAXTHR-1); - ldap_pvt_thread_mutex_lock(&ldap_pvt_thread_pool_mutex); - do { - ctx = thread_keys[i].ctx; - if ( ctx != DELETED_THREAD_CTX ) - if ( ldap_pvt_thread_equal(thread_keys[i].id, tid) || !ctx ) - goto done; - } while ( (i = (i+1) & (LDAP_MAXTHR-1)) != hash ); - ctx = NULL; - done: - ldap_pvt_thread_mutex_unlock(&ldap_pvt_thread_pool_mutex); - - return ctx; + ldap_pvt_thread_key_getdata( ldap_tpool_key, &ctx ); + return ctx ? ctx : (void *) &ldap_int_main_thrctx; } +/* + * Free the context's keys. + * Must not call functions taking a tpool argument (because this + * thread already holds ltp_mutex when called from pool_wrapper()). + */ void ldap_pvt_thread_pool_context_reset( void *vctx ) { ldap_int_thread_userctx_t *ctx = vctx;