X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Flibldap_r%2Ftpool.c;h=140e1af55a4de75211b14abd535d253bafbd62cb;hb=a4f0fc9941adcdab8a414eef05fecfa561097d8e;hp=1b18ff8fe0ec5d4708f0ff6e6408b60028f317b0;hpb=f97f10948369f97e6759ec1fceef15744d58b83f;p=openldap diff --git a/libraries/libldap_r/tpool.c b/libraries/libldap_r/tpool.c index 1b18ff8fe0..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,65 +32,128 @@ #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_PAUSING -} 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; +/* 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; + /* 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]; - -typedef struct ldap_int_thread_ctx_s { +#define TID_HASH(tid, hash) do { \ + unsigned const char *ptr_ = (unsigned const char *)&(tid); \ + unsigned i_; \ + for (i_ = 0, (hash) = ptr_[0]; ++i_ < sizeof(tid);) \ + (hash) += ((hash) << 5) ^ ptr_[i_]; \ +} while(0) + + +/* 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; - 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); @@ -98,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); } @@ -120,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, @@ -257,6 +199,14 @@ 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, sizeof(struct ldap_int_thread_pool_s)); @@ -272,66 +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); } -#define TID_HASH(tid, hash) do { unsigned i; \ - unsigned char *ptr = (unsigned char *)&(tid); \ - for (i=0, hash=0; iltp_mutex); - if ((pool->ltp_state != LDAP_INT_THREAD_POOL_RUNNING && - pool->ltp_state != LDAP_INT_THREAD_POOL_PAUSING) - || (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); - } 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); - } - } - ctx->ltc_start_routine = start_routine; - ctx->ltc_arg = arg; + if (pool->ltp_pending_count >= pool->ltp_max_pending) + goto failed; - pool->ltp_pending_count++; - LDAP_STAILQ_INSERT_TAIL(&pool->ltp_pending_list, ctx, ltc_next.q); - if (pool->ltp_state == LDAP_INT_THREAD_POOL_PAUSING) { - 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 <= 0 )) - { - pool->ltp_open_count++; - pool->ltp_starting++; - need_thread = 1; + task = LDAP_SLIST_FIRST(&pool->ltp_free_list); + if (task) { + LDAP_SLIST_REMOVE_HEAD(&pool->ltp_free_list, ltt_next.l); + } else { + task = (ldap_int_thread_task_t *) LDAP_MALLOC(sizeof(*task)); + if (task == NULL) + goto failed; } - ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); -#ifdef LDAP_PVT_THREAD_POOL_SEM_LOAD_CONTROL - ldap_lazy_sem_op_submit( thread_pool_sem ); -#endif + task->ltt_start_routine = start_routine; + task->ltt_arg = arg; - if (need_thread) { - int rc; + pool->ltp_pending_count++; + LDAP_STAILQ_INSERT_TAIL(&pool->ltp_pending_list, task, ltt_next.q); - ldap_pvt_thread_mutex_lock(&pool->ltp_mutex); + /* 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) + { + if (pool->ltp_pause) + goto done; - rc = ldap_pvt_thread_create( &thr, 1, - ldap_int_thread_pool_wrapper, pool ); - if (rc == 0) { - int hash; - pool->ltp_starting--; + pool->ltp_starting++; + pool->ltp_open_count++; + SET_VARY_OPEN_COUNT(pool); - /* assign this thread ID to a key slot; start - * at the thread ID itself (mod LDAP_MAXTHR) and - * look for an empty slot. - */ - TID_HASH(thr, hash); - for (rc = hash & (LDAP_MAXTHR-1); - !ldap_pvt_thread_equal(thread_keys[rc].id, tid_zero); - rc = (rc+1) & (LDAP_MAXTHR-1)); - thread_keys[rc].id = thr; - } else { + 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. */ - pool->ltp_open_count--; 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_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_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, 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); + pool->ltp_pending_count--; + 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; } } /* there is another open thread, so this - * context will be handled eventually. - * continue on and signal that the context - * is waiting. + * task will be handled eventually. */ } - ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); } + ldap_pvt_thread_cond_signal(&pool->ltp_cond); + done: + ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex); 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); @@ -458,13 +374,54 @@ ldap_pvt_thread_pool_maxthreads ( ldap_pvt_thread_pool_t *tpool, int max_threads 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; + + if (! (0 <= max_threads && max_threads <= LDAP_MAXTHR)) + max_threads = 0; + + if (tpool == NULL) + return(-1); + + pool = *tpool; + + if (pool == NULL) + 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; @@ -487,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: @@ -501,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; @@ -518,29 +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 }, - { "pausing", LDAP_INT_THREAD_POOL_PAUSING }, - { NULL } - }; - int i; - - for ( i = 0; str2state[ i ].name != NULL; i++ ) { - if ( str2state[ i ].state == pool->ltp_state ) { - break; - } - } - *((char **)value) = str2state[ i ].name; - if ( str2state[ i ].name != 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 ); @@ -551,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 @@ -570,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); @@ -594,141 +565,147 @@ 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; - if ( pool->ltp_open_count ) { - ldap_pvt_thread_cond_broadcast(&pool->ltp_cond); - ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex); + 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; } - 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 (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); } - 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; - int i, keyslot, hash; + 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); - /* store pointer to our keys */ - TID_HASH(uctx.ltu_id, hash); - for (i = hash & (LDAP_MAXTHR-1); - !ldap_pvt_thread_equal(thread_keys[i].id, uctx.ltu_id); - i = (i+1) & (LDAP_MAXTHR-1)); - thread_keys[i].ctx = &uctx; - keyslot = i; - - while (pool->ltp_state != LDAP_INT_THREAD_POOL_STOPPING) { - ctx = LDAP_STAILQ_FIRST(&pool->ltp_pending_list); - if (ctx) { - LDAP_STAILQ_REMOVE_HEAD(&pool->ltp_pending_list, ltc_next.q); - } else { - if (pool->ltp_state == LDAP_INT_THREAD_POOL_FINISHING) - break; - if (pool->ltp_max_count > 0 - && pool->ltp_open_count > pool->ltp_max_count) - { - /* 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. - */ - break; + /* thread_keys[] is read-only when paused */ + while (pool->ltp_pause) + ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex); + + /* find a key slot to give this thread ID and store a + * pointer to our keys there; start at the thread ID + * itself (mod LDAP_MAXTHR) and look for an empty slot. + */ + ldap_pvt_thread_mutex_lock(&ldap_pvt_thread_pool_mutex); + for (keyslot = hash & (LDAP_MAXTHR-1); + (kctx = thread_keys[keyslot].ctx) && kctx != DELETED_THREAD_CTX; + keyslot = (keyslot+1) & (LDAP_MAXTHR-1)); + thread_keys[keyslot].ctx = &ctx; + ldap_pvt_thread_mutex_unlock(&ldap_pvt_thread_pool_mutex); + + pool->ltp_starting--; + pool->ltp_active_count++; + + for (;;) { + 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); } - /* 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, leave thread (break;) - * - * Just use pthread_cond_timedwait if we want to - * check idle time. - */ + 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; + } - if (pool->ltp_state == LDAP_INT_THREAD_POOL_RUNNING - || pool->ltp_state == LDAP_INT_THREAD_POOL_PAUSING) - { + /* 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. + */ ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex); - } - continue; + work_list = pool->ltp_work_list; + task = LDAP_STAILQ_FIRST(work_list); + } while (task == NULL); + + pool->ltp_active_count++; } + 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--; - - if (pool->ltp_state == LDAP_INT_THREAD_POOL_PAUSING) { - if (pool->ltp_active_count < 2) { - ldap_pvt_thread_cond_signal(&pool->ltp_pcond); - } - ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex); - } + 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 */ - thread_keys[keyslot].ctx = NULL; - thread_keys[keyslot].id = tid_zero; + /* 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); - pool->ltp_open_count--; + ldap_pvt_thread_mutex_lock(&ldap_pvt_thread_pool_mutex); + thread_keys[keyslot].ctx = DELETED_THREAD_CTX; + 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); @@ -737,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); @@ -751,25 +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_state == LDAP_INT_THREAD_POOL_PAUSING) { + 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--; - ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex); + 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); + } + } + + 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 finish */ - pool->ltp_state = LDAP_INT_THREAD_POOL_PAUSING; - 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 ) @@ -786,12 +848,22 @@ ldap_pvt_thread_pool_resume ( ldap_pvt_thread_mutex_lock(&pool->ltp_mutex); - pool->ltp_state = LDAP_INT_THREAD_POOL_RUNNING; + 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, @@ -801,7 +873,7 @@ int ldap_pvt_thread_pool_getkey( ldap_int_thread_userctx_t *ctx = xctx; int i; - if ( !ctx || !data ) return EINVAL; + if ( !ctx || !key || !data ) return EINVAL; for ( i=0; iltu_key[i].ltk_key; i++ ) { if ( ctx->ltu_key[i].ltk_key == key ) { @@ -813,26 +885,72 @@ int ldap_pvt_thread_pool_getkey( return ENOENT; } +static void +clear_key_idx( ldap_int_thread_userctx_t *ctx, int i ) +{ + for ( ; i < MAXKEYS-1 && ctx->ltu_key[i+1].ltk_key; i++ ) + ctx->ltu_key[i] = ctx->ltu_key[i+1]; + 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; + int i, found; if ( !ctx || !key ) return EINVAL; - for ( i=0; iltu_key[i].ltk_key || ctx->ltu_key[i].ltk_key == key ) { - ctx->ltu_key[i].ltk_key = key; - ctx->ltu_key[i].ltk_data = data; - ctx->ltu_key[i].ltk_free = kfree; - return 0; + for ( i=found=0; iltu_key[i].ltk_key == key ) { + found = 1; + break; + } else if ( !ctx->ltu_key[i].ltk_key ) { + break; } } - return ENOMEM; + + 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; + ctx->ltu_key[i].ltk_key = key; + ctx->ltu_key[i].ltk_data = data; + ctx->ltu_key[i].ltk_free = kfree; + } else if ( found ) { + clear_key_idx( ctx, i ); + } + + return 0; } /* Free all elements with this key, no matter which thread they're in. @@ -843,16 +961,17 @@ void ldap_pvt_thread_pool_purgekey( void *key ) int i, j; ldap_int_thread_userctx_t *ctx; + assert ( key != NULL ); + for ( i=0; iltu_key[j].ltk_key; j++ ) { if ( ctx->ltu_key[j].ltk_key == key ) { if (ctx->ltu_key[j].ltk_free) ctx->ltu_key[j].ltk_free( ctx->ltu_key[j].ltk_key, ctx->ltu_key[j].ltk_data ); - ctx->ltu_key[j].ltk_key = NULL; - ctx->ltu_key[j].ltk_free = NULL; + clear_key_idx( ctx, j ); break; } } @@ -861,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 @@ -869,22 +989,17 @@ void ldap_pvt_thread_pool_purgekey( void *key ) */ void *ldap_pvt_thread_pool_context( ) { - ldap_pvt_thread_t tid; - int i, hash; + void *ctx = NULL; - tid = ldap_pvt_thread_self(); - if ( ldap_pvt_thread_equal( tid, ldap_int_main_tid )) - return &ldap_int_main_thrctx; - - TID_HASH( tid, hash ); - for (i = hash & (LDAP_MAXTHR-1); - !ldap_pvt_thread_equal(thread_keys[i].id, tid_zero) && - !ldap_pvt_thread_equal(thread_keys[i].id, tid); - i = (i+1) & (LDAP_MAXTHR-1)); - - return thread_keys[i].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;