Diff for /include/ldap_int_thread.h between versions 1.2 and 1.25

version 1.2, 2000/06/06 22:29:12 version 1.25, 2007/01/10 23:55:26
Line 1 Line 1
 /* $OpenLDAP: pkg/ldap/include/ldap_int_thread.h,v 1.21 2000/05/19 18:47:32 kurt Exp $ */  /* ldap_int_thread.h - ldap internal thread wrappers header file */
 /*  /* $OpenLDAP: pkg/ldap/include/ldap_int_thread.h,v 1.24 2007/01/10 00:29:16 hyc Exp $ */
  * Copyright 1998-2000 The OpenLDAP Foundation, Redwood City, California, USA  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
    * 
    * Copyright 1998-2007 The OpenLDAP Foundation.
  * All rights reserved.   * All rights reserved.
  *   *
  * Redistribution and use in source and binary forms are permitted only   * Redistribution and use in source and binary forms, with or without
  * as authorized by the OpenLDAP Public License.  A copy of this   * modification, are permitted only as authorized by the OpenLDAP
  * license is available at http://www.OpenLDAP.org/license.html or   * Public License.
  * in file LICENSE in the top-level directory of the distribution.   *
    * A copy of this license is available in file LICENSE in the
    * top-level directory of the distribution or, alternatively, at
    * <http://www.OpenLDAP.org/license.html>.
  */   */
 /* ldap_int_thread.h - ldap internal thread wrappers header file */  
   
   LDAP_BEGIN_DECL
   
   /* Can be done twice in libldap_r.  See libldap_r/ldap_thr_debug.h. */
   LDAP_F(int) ldap_int_thread_initialize LDAP_P(( void ));
   LDAP_F(int) ldap_int_thread_destroy    LDAP_P(( void ));
   
   LDAP_END_DECL
   
   
 #ifndef _LDAP_INT_THREAD_H  #ifndef _LDAP_INT_THREAD_H
 #define _LDAP_INT_THREAD_H  #define _LDAP_INT_THREAD_H
   
 #include "ldap_cdefs.h"  
   
 #if defined( HAVE_PTHREADS )  #if defined( HAVE_PTHREADS )
 /**********************************  /**********************************
  *                                *   *                                *
Line 33  typedef pthread_t  ldap_int_thread_t; Line 45  typedef pthread_t  ldap_int_thread_t;
 typedef pthread_mutex_t         ldap_int_thread_mutex_t;  typedef pthread_mutex_t         ldap_int_thread_mutex_t;
 typedef pthread_cond_t          ldap_int_thread_cond_t;  typedef pthread_cond_t          ldap_int_thread_cond_t;
   
   #define ldap_int_thread_equal(a, b)     pthread_equal((a), (b))
   
 #if defined( _POSIX_REENTRANT_FUNCTIONS ) || \  #if defined( _POSIX_REENTRANT_FUNCTIONS ) || \
         defined( _POSIX_THREAD_SAFE_FUNCTIONS ) || \          defined( _POSIX_THREAD_SAFE_FUNCTIONS ) || \
         defined( _POSIX_THREADSAFE_FUNCTIONS )          defined( _POSIX_THREADSAFE_FUNCTIONS )
Line 41  typedef pthread_cond_t  ldap_int_thread_ Line 55  typedef pthread_cond_t  ldap_int_thread_
   
 #if defined( HAVE_PTHREAD_GETCONCURRENCY ) || \  #if defined( HAVE_PTHREAD_GETCONCURRENCY ) || \
         defined( HAVE_THR_GETCONCURRENCY )          defined( HAVE_THR_GETCONCURRENCY )
 #define HAVE_GETCONCURRENCY 1  #define LDAP_THREAD_HAVE_GETCONCURRENCY 1
 #endif  #endif
   
 #if defined( HAVE_PTHREAD_SETCONCURRENCY ) || \  #if defined( HAVE_PTHREAD_SETCONCURRENCY ) || \
         defined( HAVE_THR_SETCONCURRENCY )          defined( HAVE_THR_SETCONCURRENCY )
 #define HAVE_SETCONCURRENCY 1  #define LDAP_THREAD_HAVE_SETCONCURRENCY 1
 #endif  #endif
   
 #if defined( HAVE_PTHREAD_RWLOCK_DESTROY )  #if defined( HAVE_PTHREAD_RWLOCK_DESTROY )
 #define LDAP_THREAD_HAVE_RDWR 1  #define LDAP_THREAD_HAVE_RDWR 1
 typedef pthread_rwlock_t ldap_pvt_thread_rdwr_t;  typedef pthread_rwlock_t ldap_int_thread_rdwr_t;
 #endif  #endif
   
 LDAP_END_DECL  LDAP_END_DECL
Line 63  LDAP_END_DECL Line 77  LDAP_END_DECL
  *                                *   *                                *
  **********************************/   **********************************/
   
 #include <mach/cthreads.h>  #if defined( HAVE_MACH_CTHREADS_H )
   #       include <mach/cthreads.h>
   #elif defined( HAVE_CTHREAD_H
   #       include <cthreads.h>
   #endif
   
 LDAP_BEGIN_DECL  LDAP_BEGIN_DECL
   
Line 89  typedef pth_t  ldap_int_thread_t; Line 107  typedef pth_t  ldap_int_thread_t;
 typedef pth_mutex_t     ldap_int_thread_mutex_t;  typedef pth_mutex_t     ldap_int_thread_mutex_t;
 typedef pth_cond_t      ldap_int_thread_cond_t;  typedef pth_cond_t      ldap_int_thread_cond_t;
   
 LDAP_END_DECL  #if 0
   #define LDAP_THREAD_HAVE_RDWR 1
   typedef pth_rwlock_t ldap_int_thread_rdwr_t;
   #endif
   
   LDAP_END_DECL
   
 #elif defined( HAVE_THR )  #elif defined( HAVE_THR )
 /********************************************  /********************************************
Line 111  typedef cond_t   ldap_int_thread_cond_t; Line 133  typedef cond_t   ldap_int_thread_cond_t;
 #define HAVE_REENTRANT_FUNCTIONS 1  #define HAVE_REENTRANT_FUNCTIONS 1
   
 #ifdef HAVE_THR_GETCONCURRENCY  #ifdef HAVE_THR_GETCONCURRENCY
 #define HAVE_GETCONCURRENCY 1  #define LDAP_THREAD_HAVE_GETCONCURRENCY 1
 #endif  #endif
 #ifdef HAVE_THR_SETCONCURRENCY  #ifdef HAVE_THR_SETCONCURRENCY
 #define HAVE_SETCONCURRENCY 1  #define LDAP_THREAD_HAVE_SETCONCURRENCY 1
 #endif  #endif
   
 LDAP_END_DECL  LDAP_END_DECL
Line 128  LDAP_END_DECL Line 150  LDAP_END_DECL
   
 #include <lwp/lwp.h>  #include <lwp/lwp.h>
 #include <lwp/stackdep.h>  #include <lwp/stackdep.h>
   #define LDAP_THREAD_HAVE_SLEEP 1
   
 LDAP_BEGIN_DECL  LDAP_BEGIN_DECL
   
Line 144  typedef struct ldap_int_thread_lwp_cv ld Line 167  typedef struct ldap_int_thread_lwp_cv ld
 LDAP_END_DECL  LDAP_END_DECL
   
 #elif defined(HAVE_NT_THREADS)  #elif defined(HAVE_NT_THREADS)
   /*************************************
 LDAP_BEGIN_DECL   *                                   *
    * thread definitions for NT threads *
    *                                   *
    *************************************/
   
 #include <process.h>  #include <process.h>
 #include <windows.h>  #include <windows.h>
   
   LDAP_BEGIN_DECL
   
 typedef unsigned long   ldap_int_thread_t;  typedef unsigned long   ldap_int_thread_t;
 typedef HANDLE  ldap_int_thread_mutex_t;  typedef HANDLE  ldap_int_thread_mutex_t;
 typedef HANDLE  ldap_int_thread_cond_t;  typedef HANDLE  ldap_int_thread_cond_t;
Line 157  typedef HANDLE ldap_int_thread_cond_t; Line 185  typedef HANDLE ldap_int_thread_cond_t;
 LDAP_END_DECL  LDAP_END_DECL
   
 #else  #else
   
 /***********************************  /***********************************
  *                                 *   *                                 *
  * thread definitions for no       *   * thread definitions for no       *
Line 165  LDAP_END_DECL Line 192  LDAP_END_DECL
  *                                 *   *                                 *
  ***********************************/   ***********************************/
   
 LDAP_BEGIN_DECL  
   
 #ifndef NO_THREADS  #ifndef NO_THREADS
 #define NO_THREADS 1  #define NO_THREADS 1
 #endif  #endif
   
   LDAP_BEGIN_DECL
   
 typedef int                     ldap_int_thread_t;  typedef int                     ldap_int_thread_t;
 typedef int                     ldap_int_thread_mutex_t;  typedef int                     ldap_int_thread_mutex_t;
 typedef int                     ldap_int_thread_cond_t;  typedef int                     ldap_int_thread_cond_t;
   
   #define LDAP_THREAD_HAVE_TPOOL 1
   typedef int                     ldap_int_thread_pool_t;
   
 LDAP_END_DECL  LDAP_END_DECL
   
 #endif /* no threads support */  #endif /* no threads support */
   
 LDAP_BEGIN_DECL  
   
 LIBLDAP_F( int )  
 ldap_int_thread_initialize LDAP_P(( void ));  
   
 LIBLDAP_F( int )  LDAP_BEGIN_DECL
 ldap_int_thread_destroy LDAP_P(( void ));  
   
 LIBLDAP_F( unsigned int )  
 ldap_int_thread_sleep LDAP_P(( unsigned int s ));  
   
 #ifdef HAVE_GETCONCURRENCY  #ifndef ldap_int_thread_equal
 LIBLDAP_F( int )  #define ldap_int_thread_equal(a, b)     ((a) == (b))
 ldap_int_thread_get_concurrency LDAP_P(( void ));  
 #endif  #endif
   
 #ifdef HAVE_SETCONCURRENCY  #ifndef LDAP_THREAD_HAVE_RDWR
 #       ifndef LDAP_THREAD_CONCURRENCY  typedef struct ldap_int_thread_rdwr_s * ldap_int_thread_rdwr_t;
         /* three concurrent threads should be enough */  
 #       define LDAP_THREAD_CONCURRENCY  3  
 #       endif  
 LIBLDAP_F( int )  
 ldap_int_thread_set_concurrency LDAP_P(( int ));  
 #endif  #endif
   
 LIBLDAP_F( int )   LDAP_F(int) ldap_int_thread_pool_startup ( void );
 ldap_int_thread_create LDAP_P((  LDAP_F(int) ldap_int_thread_pool_shutdown ( void );
         ldap_int_thread_t * thread,   
         int     detach,  
         void *(*start_routine)( void * ),   
         void *arg));  
   
 LIBLDAP_F( void )   
 ldap_int_thread_exit LDAP_P(( void *retval ));  
   
 LIBLDAP_F( int )  #ifndef LDAP_THREAD_HAVE_TPOOL
 ldap_int_thread_join LDAP_P(( ldap_int_thread_t thread, void **status ));  typedef struct ldap_int_thread_pool_s * ldap_int_thread_pool_t;
   #endif
 LIBLDAP_F( int )  
 ldap_int_thread_kill LDAP_P(( ldap_int_thread_t thread, int signo ));  
   
 LIBLDAP_F( int )  
 ldap_int_thread_yield LDAP_P(( void ));  
   
 LIBLDAP_F( int )  
 ldap_int_thread_cond_init LDAP_P(( ldap_int_thread_cond_t *cond ));  
   
 LIBLDAP_F( int )  
 ldap_int_thread_cond_destroy LDAP_P(( ldap_int_thread_cond_t *cond ));  
   
 LIBLDAP_F( int )  
 ldap_int_thread_cond_signal LDAP_P(( ldap_int_thread_cond_t *cond ));  
   
 LIBLDAP_F( int )  typedef struct ldap_int_thread_rmutex_s * ldap_int_thread_rmutex_t;
 ldap_int_thread_cond_broadcast LDAP_P(( ldap_int_thread_cond_t *cond ));  LDAP_END_DECL
   
 LIBLDAP_F( int )  
 ldap_int_thread_cond_wait LDAP_P((  
         ldap_int_thread_cond_t *cond,   
         ldap_int_thread_mutex_t *mutex ));  
   
 LIBLDAP_F( int )  #if defined(LDAP_THREAD_DEBUG) && !((LDAP_THREAD_DEBUG +0) & 2U)
 ldap_int_thread_mutex_init LDAP_P(( ldap_int_thread_mutex_t *mutex ));  #define LDAP_THREAD_DEBUG_WRAP 1
   #endif
   
 LIBLDAP_F( int )  #ifdef LDAP_THREAD_DEBUG_WRAP
 ldap_int_thread_mutex_destroy LDAP_P(( ldap_int_thread_mutex_t *mutex ));  /**************************************
    *                                    *
    * definitions for type-wrapped debug *
    *                                    *
    **************************************/
   
 LIBLDAP_F( int )  LDAP_BEGIN_DECL
 ldap_int_thread_mutex_lock LDAP_P(( ldap_int_thread_mutex_t *mutex ));  
   
 LIBLDAP_F( int )  #ifndef LDAP_UINTPTR_T  /* May be configured in CPPFLAGS */
 ldap_int_thread_mutex_trylock LDAP_P(( ldap_int_thread_mutex_t *mutex ));  #define LDAP_UINTPTR_T  unsigned long
   #endif
   
 LIBLDAP_F( int )  typedef enum {
 ldap_int_thread_mutex_unlock LDAP_P(( ldap_int_thread_mutex_t *mutex ));          ldap_debug_magic =      -(int) (((unsigned)-1)/19)
   } ldap_debug_magic_t;
   
   typedef enum {
           /* Could fill in "locked" etc here later */
           ldap_debug_state_inited = (int) (((unsigned)-1)/11),
           ldap_debug_state_destroyed
   } ldap_debug_state_t;
   
   typedef struct {
           /* Enclosed in magic numbers in the hope of catching overwrites */
           ldap_debug_magic_t      magic;  /* bit pattern to recognize usages  */
           LDAP_UINTPTR_T          self;   /* ~(LDAP_UINTPTR_T)&(this struct) */
           union ldap_debug_mem_u {        /* Dummy memory reference */
                   unsigned char   *ptr;
                   LDAP_UINTPTR_T  num;
           } mem;
           ldap_debug_state_t      state;  /* doubles as another magic number */
   } ldap_debug_usage_info_t;
   
   typedef struct {
           ldap_int_thread_mutex_t wrapped;
           ldap_debug_usage_info_t usage;
           ldap_int_thread_t       owner;
   } ldap_debug_thread_mutex_t;
   
   typedef struct {
           ldap_int_thread_cond_t  wrapped;
           ldap_debug_usage_info_t usage;
   } ldap_debug_thread_cond_t;
   
   typedef struct {
           ldap_int_thread_rdwr_t  wrapped;
           ldap_debug_usage_info_t usage;
   } ldap_debug_thread_rdwr_t;
   
   #ifndef NDEBUG
   #define LDAP_INT_THREAD_ASSERT_MUTEX_OWNER(mutex) \
           ldap_debug_thread_assert_mutex_owner( \
                   __FILE__, __LINE__, "owns(" #mutex ")", mutex )
   LDAP_F(void) ldap_debug_thread_assert_mutex_owner LDAP_P((
           LDAP_CONST char *file,
           int line,
           LDAP_CONST char *msg,
           ldap_debug_thread_mutex_t *mutex ));
   #endif /* NDEBUG */
   
 LDAP_END_DECL  LDAP_END_DECL
   
   #endif /* LDAP_THREAD_DEBUG_WRAP */
   
 #endif /* _LDAP_INT_THREAD_H */  #endif /* _LDAP_INT_THREAD_H */

Removed from v.1.2  
changed lines
  Added in v.1.25


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org