ITS#3950 delete gratuitous yield. (could use pthread_cond_timedwait

[openldap] / libraries / libldap_r / tpool.c

diff --git a/libraries/libldap_r/tpool.c b/libraries/libldap_r/tpool.c
index dc1d683bc087966fa565cb06d41722a4ee800a9f..e23f9ad09cf8b252c31e89308af11490431b2a41 100644 (file)
--- a/libraries/libldap_r/tpool.c
+++ b/libraries/libldap_r/tpool.c
@@ -1,7 +1,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 1998-2005 The OpenLDAP Foundation.
+ * Copyright 1998-2006 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -29,10 +29,6 @@
 #define LDAP_THREAD_POOL_IMPLEMENTATION
 #include "ldap_thr_debug.h"  /* May rename symbols defined below */
 
-#ifdef LDAP_DEVEL
-/* #define SLAP_SEM_LOAD_CONTROL /* must also be defined in slapd.h */
-#endif
-
 #ifndef LDAP_THREAD_HAVE_TPOOL
 
 typedef enum ldap_int_thread_pool_state_e {
@@ -142,7 +138,8 @@ typedef struct ldap_lazy_sem_t {
 ldap_lazy_sem_t* thread_pool_sem = NULL;
 
 int
-ldap_lazy_sem_init( unsigned int value, unsigned int lazyness ) {
+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 ));
 
@@ -157,12 +154,17 @@ ldap_lazy_sem_init( unsigned int value, unsigned int lazyness ) {
        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 ) {
+ldap_lazy_sem_op_submit( ldap_lazy_sem_t* ls )
+{
        if ( ls == NULL ) return -1;
 
        /* only worker thread has its thread ctx */
@@ -181,7 +183,8 @@ ldap_lazy_sem_op_submit( ldap_lazy_sem_t* ls ) {
  * If not, the count is decremented.
  */
 int
-ldap_lazy_sem_wait ( ldap_lazy_sem_t* ls ) {
+ldap_lazy_sem_wait ( ldap_lazy_sem_t* ls )
+{
        ldap_pvt_thread_mutex_lock( &ls->ls_mutex );
 
 lazy_sem_retry:
@@ -205,7 +208,8 @@ lazy_sem_retry:
  * even when the count becomes less than or equal to 0
  */
 int
-ldap_lazy_sem_dec ( ldap_lazy_sem_t* ls ) {
+ldap_lazy_sem_dec( ldap_lazy_sem_t* ls )
+{
        ldap_pvt_thread_mutex_lock( &ls->ls_mutex );
 
        ls->ls_sem_value--;
@@ -220,8 +224,8 @@ ldap_lazy_sem_dec ( ldap_lazy_sem_t* ls ) {
  * equal to lazyness. If it is, wake up a blocked thread.
  */
 int
-ldap_lazy_sem_post( ldap_lazy_sem_t* ls ) {
-
+ldap_lazy_sem_post( ldap_lazy_sem_t* ls )
+{
        if( ls == NULL ) return (-1);
 
        ldap_pvt_thread_mutex_lock( &ls->ls_mutex );
@@ -364,13 +368,9 @@ ldap_pvt_thread_pool_submit (
                return(0);
        }
        ldap_pvt_thread_cond_signal(&pool->ltp_cond);
-       if ((pool->ltp_open_count <= 0
-#if 0
-                       || pool->ltp_pending_count > 1
-#endif
-                       || pool->ltp_open_count == pool->ltp_active_count)
-               && (pool->ltp_max_count <= 0
-                       || pool->ltp_open_count < pool->ltp_max_count))
+       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++;
@@ -378,7 +378,7 @@ ldap_pvt_thread_pool_submit (
        }
        ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex);
 
-#ifdef SLAP_SEM_LOAD_CONTROL
+#ifdef LDAP_PVT_THREAD_POOL_SEM_LOAD_CONTROL
        ldap_lazy_sem_op_submit( thread_pool_sem );
 #endif
 
@@ -533,7 +533,7 @@ ldap_pvt_thread_pool_destroy ( ldap_pvt_thread_pool_t *tpool, int run_pending )
        ldap_pvt_thread_cond_destroy(&pool->ltp_cond);
        ldap_pvt_thread_mutex_destroy(&pool->ltp_mutex);
        LDAP_FREE(pool);
-#ifdef SLAP_SEM_LOAD_CONTROL
+#ifdef LDAP_PVT_THREAD_POOL_SEM_LOAD_CONTROL
        if ( thread_pool_sem ) {
                LDAP_FREE( thread_pool_sem );
        }
@@ -595,6 +595,9 @@ ldap_int_thread_pool_wrapper (
                         * 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.
                         */
 
                        if (pool->ltp_state == LDAP_INT_THREAD_POOL_RUNNING
@@ -614,7 +617,7 @@ ldap_int_thread_pool_wrapper (
 
                ctx->ltc_start_routine(ltc_key, ctx->ltc_arg);
 
-#ifdef SLAP_SEM_LOAD_CONTROL
+#ifdef LDAP_PVT_THREAD_POOL_SEM_LOAD_CONTROL
                ldap_lazy_sem_post( thread_pool_sem );
 #endif
                ldap_pvt_thread_mutex_lock(&pool->ltp_mutex);
@@ -629,15 +632,6 @@ ldap_int_thread_pool_wrapper (
                        }
                        ldap_pvt_thread_cond_wait(&pool->ltp_cond, &pool->ltp_mutex);
                }
-               ldap_pvt_thread_mutex_unlock(&pool->ltp_mutex);
-
-               ldap_pvt_thread_yield();
-
-               /* if we use an idle timer, here's
-                * a good place to update it
-                */
-
-               ldap_pvt_thread_mutex_lock(&pool->ltp_mutex);
        }
 
        for ( i=0; i<MAXKEYS && ltc_key[i].ltk_key; i++ ) {