(file) Return to Thread.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Thread.h between version 1.27 and 1.61.12.1

version 1.27, 2003/06/14 19:25:38 version 1.61.12.1, 2009/08/19 05:08:10
Line 1 
Line 1 
 //%/-*-c++-*-////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 21 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Day (mdday@us.ibm.com)  
 //  
 // Modified By: Markus Mueller  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #ifndef Pegasus_Thread_h #ifndef Pegasus_Thread_h
Line 32 
Line 36 
  
 #include <cstring> #include <cstring>
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/IPC.h>  #include <Pegasus/Common/AtomicInt.h>
 #include <Pegasus/Common/InternalException.h> #include <Pegasus/Common/InternalException.h>
 #include <Pegasus/Common/DQueue.h>  #include <Pegasus/Common/AcceptLanguageList.h>
 #include <Pegasus/Common/Linkage.h> #include <Pegasus/Common/Linkage.h>
   #include <Pegasus/Common/AutoPtr.h>
   #include <Pegasus/Common/List.h>
   #include <Pegasus/Common/Mutex.h>
   #include <Pegasus/Common/Semaphore.h>
   #include <Pegasus/Common/TSDKey.h>
   #include <Pegasus/Common/Threads.h>
   
   #if defined(PEGASUS_HAVE_PTHREADS)
   # include <signal.h>
   #endif
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 class PEGASUS_COMMON_LINKAGE cleanup_handler  class PEGASUS_COMMON_LINKAGE cleanup_handler : public Linkable
 { {
   
    public:    public:
       cleanup_handler( void (*routine)(void *), void *arg  ) : _routine(routine), _arg(arg)  {}      cleanup_handler(void (*routine) (void *), void *arg):_routine(routine),
       ~cleanup_handler()  {; }          _arg(arg)
       inline Boolean operator==(const void *key) const  
       {       {
          if(key == (void *)_routine)  
             return true;  
          return false;  
       }       }
       inline Boolean operator ==(const cleanup_handler & b) const      ~cleanup_handler()
       {      {;
          return(operator==((const void *)b._routine));  
       }       }
   
    private:    private:
       void execute(void) { _routine(_arg); }  
       void execute()
       {
           _routine(_arg);
       }
   
       cleanup_handler();       cleanup_handler();
       void (*_routine)(void *);  
  
       void (*_routine)(void*);
       void *_arg;       void *_arg;
       PEGASUS_CLEANUP_HANDLE _cleanup_buffer;  
       friend class DQueue<class cleanup_handler>;  
       friend class Thread;       friend class Thread;
 }; };
  
 /////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
  
   class PEGASUS_COMMON_LINKAGE thread_data : public Linkable
 class  PEGASUS_COMMON_LINKAGE thread_data  
 { {
   
    public:    public:
   
       static void default_delete(void *data);       static void default_delete(void *data);
  
       thread_data( const Sint8 *key ) : _delete_func(NULL) , _data(NULL), _size(0)      thread_data(const char *key) : _delete_func(NULL), _data(NULL), _size(0)
       {       {
          PEGASUS_ASSERT(key != NULL);          PEGASUS_ASSERT(key != NULL);
          size_t keysize = strlen(key);          size_t keysize = strlen(key);
          _key = new Sint8 [keysize + 1];          _key.reset(new char[keysize + 1]);
          memcpy(_key, key, keysize);          memcpy(_key.get(), key, keysize);
          _key[keysize] = 0x00;          _key.get()[keysize] = 0x00;
   
       }       }
  
       thread_data(const Sint8 *key, size_t size) : _delete_func(default_delete), _size(size)      thread_data(const char *key, size_t size) :
           _delete_func(default_delete), _size(size)
       {       {
          PEGASUS_ASSERT(key != NULL);          PEGASUS_ASSERT(key != NULL);
          size_t keysize = strlen(key);          size_t keysize = strlen(key);
          _key = new Sint8 [keysize + 1];          _key.reset(new char[keysize + 1]);
          memcpy(_key, key, keysize);          memcpy(_key.get(), key, keysize);
          _key[keysize] = 0x00;          _key.get()[keysize] = 0x00;
          _data = ::operator new(_size) ;          _data = ::operator new(_size) ;
   
       }       }
  
       thread_data(const Sint8 *key, size_t size, void *data) : _delete_func(default_delete), _size(size)      thread_data(const char *key, size_t size, void *data)
           : _delete_func(default_delete), _size(size)
       {       {
          PEGASUS_ASSERT(key != NULL);          PEGASUS_ASSERT(key != NULL);
          PEGASUS_ASSERT(data != NULL);          PEGASUS_ASSERT(data != NULL);
          size_t keysize = strlen(key);          size_t keysize = strlen(key);
  
          _key = new Sint8[keysize + 1];          _key.reset(new char[keysize + 1]);
          memcpy(_key, key, keysize);          memcpy(_key.get(), key, keysize);
          _key[keysize] = 0x00;          _key.get()[keysize] = 0x00;
          _data = ::operator new(_size);          _data = ::operator new(_size);
          memcpy(_data, data, size);          memcpy(_data, data, size);
       }       }
Line 116 
Line 128 
             {             {
                _delete_func( _data );                _delete_func( _data );
             }             }
          if( _key != NULL )  
             delete [] _key;  
       }       }
  
       void put_data(void (*del)(void *), size_t size, void *data ) throw(NullPointer)      /**
        * This function is used to put data in thread space.
        *
        * Be aware that there is NOTHING in place to stop
        * other users of the thread to remove this data.
        * Or change the data.
        *
        * You, the developer has to make sure that there are
        * no situations in which this can arise (ie, have a
        * lock for the function which manipulates the TSD.
        *
        * @exception NullPointer
       */
       void put_data(void (*del) (void *), size_t size, void* data)
       {       {
          if(_data != NULL)          if(_data != NULL)
             if(_delete_func != NULL)             if(_delete_func != NULL)
Line 132 
Line 155 
          return ;          return ;
       }       }
  
       size_t get_size(void) { return _size; }      size_t get_size()
       {
           return _size;
       }
  
       /**
           This function is used to retrieve data from the
           TSD, the thread specific data.
   
           Be aware that there is NOTHING in place to stop
           other users of the thread to change the data you
           get from this function.
   
           You, the developer has to make sure that there are
           no situations in which this can arise (ie, have a
           lock for the function which manipulates the TSD.
        */
       void get_data(void **data, size_t *size)       void get_data(void **data, size_t *size)
       {       {
          if(data == NULL || size == NULL)          if(data == NULL || size == NULL)
Line 141 
Line 179 
  
          *data = _data;          *data = _data;
          *size = _size;          *size = _size;
          return;  
   
       }       }
  
       void copy_data(void **buf, size_t *size) throw(NullPointer)      // @exception NullPointer
       void copy_data(void** buf, size_t* size)
       {       {
          if((buf == NULL) || (size == NULL))          if((buf == NULL) || (size == NULL))
             throw NullPointer() ;             throw NullPointer() ;
          *buf = ::operator new(_size);          *buf = ::operator new(_size);
          *size = _size;          *size = _size;
          memcpy(*buf, _data, _size);          memcpy(*buf, _data, _size);
          return;  
       }       }
  
       inline Boolean operator==(const void *key) const       inline Boolean operator==(const void *key) const
       {       {
          if ( ! strcmp(_key, (Sint8 *)key))          if (!strcmp(_key.get(), reinterpret_cast < const char *>(key)))
             return(true);              return true;
          return(false);          return false;
       }       }
  
       inline Boolean operator==(const thread_data& b) const       inline Boolean operator==(const thread_data& b) const
       {       {
          return(operator==((const void *)b._key));          return operator==(b._key.get());
       }
   
       static bool equal(const thread_data* node, const void* key)
       {
           return ((thread_data *) node)->operator==(key);
       }       }
  
    private:    private:
Line 172 
Line 213 
       thread_data();       thread_data();
       void *_data;       void *_data;
       size_t _size;       size_t _size;
       Sint8 *_key;      AutoArrayPtr<char> _key;
  
       friend class DQueue<thread_data>;  
       friend class Thread;       friend class Thread;
 }; };
  
  
 ///////////////////////////////////////////////////////////////////////////  enum ThreadStatus
   {
       PEGASUS_THREAD_OK = 1,      /* No problems */
       PEGASUS_THREAD_INSUFFICIENT_RESOURCES,      /* Can't allocate a thread.
                                                      Not enough memory. Try
                                                      again later */
       PEGASUS_THREAD_SETUP_FAILURE,       /* Could not allocate into the thread
                                              specific data storage. */
       PEGASUS_THREAD_UNAVAILABLE  /* Service is being destroyed and no new
                                      threads can be provided. */
   };
  
 class PEGASUS_COMMON_LINKAGE ThreadPool;  ///////////////////////////////////////////////////////////////////////////
  
 class PEGASUS_COMMON_LINKAGE Thread  class PEGASUS_COMMON_LINKAGE Thread : public Linkable
 { {
   
    public:    public:
       Thread( PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *start )(void *),  
               void *parameter, Boolean detached );      Thread(
           ThreadReturnType(PEGASUS_THREAD_CDECL* start) (void*),
           void* parameter,
           Boolean detached);
  
       ~Thread();       ~Thread();
  
       void run(void);        /** Start the thread.
             @return PEGASUS_THREAD_OK if the thread is started successfully,
             PEGASUS_THREAD_INSUFFICIENT_RESOURCES if the resources necessary
             to start the thread are not currently available.
             PEGASUS_THREAD_SETUP_FAILURE if the thread could not
             be create properly - check the 'errno' value for specific operating
             system return code.
          */
       ThreadStatus run();
  
       // get the user parameter       // get the user parameter
       inline void *get_parm(void) { return _thread_parm; }      inline void *get_parm()
       {
       // send the thread a signal -- may not be appropriate due to Windows          return _thread_parm;
       //  void kill(int signum);      }
  
       // cancellation must be deferred (not asynchronous)       // cancellation must be deferred (not asynchronous)
       // for user-level threads the thread itself can decide       // for user-level threads the thread itself can decide
       // when it should die.       // when it should die.
       void cancel(void);      void cancel();
   
       // cancel if there is a pending cancellation request  
       void test_cancel(void);  
   
       Boolean is_cancelled(void);  
  
       // for user-level threads  - put the calling thread       // for user-level threads  - put the calling thread
       // to sleep and jump to the thread scheduler.       // to sleep and jump to the thread scheduler.
Line 218 
Line 273 
       // or gnu portable threads will have an existing       // or gnu portable threads will have an existing
       // routine that can be mapped to this method       // routine that can be mapped to this method
  
       void thread_switch(void);      void thread_switch();
   
 #if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)  
       // suspend this thread  
       void suspend(void) ;  
   
       // resume this thread  
       void resume(void) ;  
 #endif  
  
       static void sleep(Uint32 msec) ;       static void sleep(Uint32 msec) ;
  
       // block the calling thread until this thread terminates       // block the calling thread until this thread terminates
       void join( void );      void join();
       void thread_init(void);  
  
       // thread routine needs to call this function when       // thread routine needs to call this function when
       // it is ready to exit       // it is ready to exit
       void exit_self(PEGASUS_THREAD_RETURN return_code) ;      void exit_self(ThreadReturnType return_code);
  
       // stack of functions to be called when thread terminates       // stack of functions to be called when thread terminates
       // will be called last in first out (LIFO)       // will be called last in first out (LIFO)
       void cleanup_push( void (*routine) (void *), void *parm ) throw(IPCException);      // @exception IPCException
       void cleanup_pop(Boolean execute = true) throw(IPCException);      void cleanup_push(void (*routine) (void *), void* parm);
   
       // @exception IPCException
       void cleanup_pop(Boolean execute = true);
  
       // create and initialize a tsd       // create and initialize a tsd
       inline void create_tsd(const Sint8 *key, int size, void *buffer) throw(IPCException)      // @exception IPCException
       inline void create_tsd(const char* key, int size, void* buffer)
       {       {
          thread_data *tsd = new thread_data(key, size, buffer);          AutoPtr<thread_data> tsd(new thread_data(key, size, buffer));
          try { _tsd.insert_first(tsd); }          _tsd.insert_front(tsd.get());
          catch(IPCException& e) { e = e; delete tsd; throw; }          tsd.release();
       }       }
  
       // get the buffer associated with the key       // get the buffer associated with the key
       // NOTE: this call leaves the tsd LOCKED !!!!       // NOTE: this call leaves the tsd LOCKED !!!!
       inline void *reference_tsd(const Sint8 *key) throw(IPCException)      // @exception IPCException
       inline void *reference_tsd(const char* key)
       {       {
          _tsd.lock();          _tsd.lock();
          thread_data *tsd = _tsd.reference((const void *)key);          thread_data *tsd = _tsd.find(thread_data::equal, key);
          if(tsd != NULL)          if(tsd != NULL)
             return( (void *)(tsd->_data) );              return (void *) (tsd->_data);
          else          else
             return(NULL);              return NULL;
       }       }
  
       inline void *try_reference_tsd(const Sint8 *key) throw(IPCException)      // @exception IPCException
       inline void *try_reference_tsd(const char *key)
       {       {
          _tsd.try_lock();          _tsd.try_lock();
          thread_data *tsd = _tsd.reference((const void *)key);          thread_data *tsd = _tsd.find(thread_data::equal, key);
          if(tsd != NULL)          if(tsd != NULL)
             return((void *)(tsd->_data) );              return (void *) (tsd->_data);
          else          else
             return(NULL);              return NULL;
       }       }
  
  
       // release the lock held on the tsd       // release the lock held on the tsd
       // NOTE: assumes a corresponding and prior call to reference_tsd() !!!       // NOTE: assumes a corresponding and prior call to reference_tsd() !!!
       inline void dereference_tsd(void) throw(IPCException)      // @exception IPCException
       inline void dereference_tsd()
       {       {
          _tsd.unlock();          _tsd.unlock();
       }       }
  
       // delete the tsd associated with the key       // delete the tsd associated with the key
       inline void delete_tsd(const Sint8 *key) throw(IPCException)      // @exception IPCException
       inline void delete_tsd(const char *key)
       {       {
          thread_data *tsd = _tsd.remove((const void *)key);          AutoPtr < thread_data > tsd(_tsd.remove(thread_data::equal, key));
          if(tsd != NULL)  
             delete tsd;  
       }       }
  
       // Note: Caller must delete the thread_data object returned (if not null)      // @exception IPCException
       inline void *remove_tsd(const Sint8 *key) throw(IPCException)      inline void empty_tsd()
       {       {
          return(_tsd.remove((const void *)key));          _tsd.clear();
       }  
   
       inline void empty_tsd(void) throw(IPCException)  
       {  
          thread_data* tsd;  
          while (0 != (tsd = _tsd.remove_first()))  
          {  
             delete tsd;  
          }  
          //_tsd.empty_list();  
       }       }
  
       // create or re-initialize tsd associated with the key       // create or re-initialize tsd associated with the key
       // if the tsd already exists, delete the existing buffer       // if the tsd already exists, delete the existing buffer
       void put_tsd(const Sint8 *key, void (*delete_func)(void *), Uint32 size, void *value)      // @exception IPCException
          throw(IPCException)      void put_tsd(
           const char* key,
           void (*delete_func) (void *),
           Uint32 size,
           void* value)
       {       {
          PEGASUS_ASSERT(key != NULL);          PEGASUS_ASSERT(key != NULL);
          thread_data *tsd ;          AutoPtr<thread_data> tsd;
          tsd = _tsd.remove((const void *)key);  // may throw an IPC exception          // This may throw an IPCException
          delete tsd;          tsd.reset(_tsd.remove(thread_data::equal, key));
          thread_data *ntsd = new thread_data(key);          tsd.reset();
           AutoPtr<thread_data> ntsd(new thread_data(key));
          ntsd->put_data(delete_func, size, value);          ntsd->put_data(delete_func, size, value);
          try { _tsd.insert_first(ntsd); }          // This may throw an IPCException
          catch(IPCException& e) { e = e; delete ntsd; throw; }          _tsd.insert_front(ntsd.get());
           ntsd.release();
       }       }
       inline PEGASUS_THREAD_RETURN get_exit(void) { return _exit_code; }  
       inline PEGASUS_THREAD_TYPE self(void) {return pegasus_thread_self(); }  
   
       PEGASUS_THREAD_HANDLE getThreadHandle() {return _handle;}  
  
       inline Boolean operator==(const void *key) const      inline ThreadReturnType get_exit()
       {       {
          if ( (void *)this == key)          return _exit_code;
             return(true);  
          return(false);  
       }       }
       inline Boolean operator==(const Thread & b) const      inline ThreadType self()
       {       {
          return(operator==((const void *)&b ));          return Threads::self();
       }       }
  
       void detach(void);      ThreadHandle getThreadHandle()
   
    private:  
       Thread();  
       inline void create_tsd(const Sint8 *key ) throw(IPCException)  
       {       {
          thread_data *tsd = new thread_data(key);          return _handle;
          try { _tsd.insert_first(tsd); }  
          catch(IPCException& e) { e = e; delete tsd; throw; }  
       }       }
       PEGASUS_THREAD_HANDLE _handle;  
       Boolean _is_detached;  
       Boolean _cancel_enabled;  
       Boolean _cancelled;  
   
       PEGASUS_SEM_HANDLE _suspend_count;  
   
       // always pass this * as the void * parameter to the thread  
       // store the user parameter in _thread_parm  
   
       PEGASUS_THREAD_RETURN  ( PEGASUS_THREAD_CDECL *_start)(void *) ;  
       DQueue<class cleanup_handler> _cleanup;  
       DQueue<class thread_data> _tsd;  
   
       void *_thread_parm;  
       PEGASUS_THREAD_RETURN _exit_code;  
       static Boolean _signals_blocked;  
       friend class ThreadPool;  
 } ;  
   
  
 class PEGASUS_COMMON_LINKAGE ThreadPool      Boolean isDetached()
 { {
    public:          return _is_detached;
   
       ThreadPool(Sint16 initial_size,  
                  const Sint8 *key,  
                  Sint16 min,  
                  Sint16 max,  
                  struct timeval & alloc_wait,  
                  struct timeval & dealloc_wait,  
                  struct timeval & deadlock_detect);  
   
       ~ThreadPool(void);  
   
       void allocate_and_awaken(void *parm,  
                                PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *work)(void *),  
                                Semaphore *blocking = 0)  
          throw(IPCException);  
   
   
       Uint32 kill_dead_threads( void )  
          throw(IPCException);  
   
       void get_key(Sint8 *buf, int bufsize);  
   
       inline Boolean operator==(const void *key) const  
       {  
          if ( ! strncmp( reinterpret_cast<Sint8 *>(const_cast<void *>(key)), _key, 16  ))  
             return(true);  
          return(false);  
       }  
       inline Boolean operator==(const ThreadPool & b) const  
       {  
          return(operator==((const void *) b._key ));  
       }  
   
       inline void set_min_threads(Sint16 min)  
       {  
          _min_threads = min;  
       }  
   
       inline Sint16 get_min_threads(void) const  
       {  
          return _min_threads;  
       }  
   
       inline void set_max_threads(Sint16 max)  
       {  
          _max_threads = max;  
       }       }
  
       inline Sint16 get_max_threads(void) const      void detach();
       {  
          return _max_threads;  
       }  
  
       inline void set_allocate_wait(const struct timeval & alloc_wait)      //
       {      // Gets the Thread object associated with the caller's thread.
          _allocate_wait.tv_sec = alloc_wait.tv_sec;      // Note: this may return NULL if no Thread object is associated
          _allocate_wait.tv_usec = alloc_wait.tv_usec;      // with the caller's thread.
       }      //
       static Thread *getCurrent();
  
       inline struct timeval *get_allocate_wait(struct timeval *buffer) const      //
       {      // Sets the Thread object associated with the caller's thread.
          if(buffer == 0)      // Note: the Thread object must be placed on the heap.
             throw NullPointer();      //
          buffer->tv_sec = _allocate_wait.tv_sec;      static void setCurrent(Thread* thrd);
          buffer->tv_usec = _allocate_wait.tv_usec;  
          return buffer;  
       }  
  
       inline void set_deallocate_wait(const struct timeval & dealloc_wait)      //
       {      // Gets the AcceptLanguageList object associated with the caller's
          _deallocate_wait.tv_sec = dealloc_wait.tv_sec;      // Thread.
          _deallocate_wait.tv_usec = dealloc_wait.tv_usec;      // Note: this may return NULL if no Thread object, or no
       }      // AcceptLanguageList object, is associated with the caller's thread.
       //
       static AcceptLanguageList* getLanguages();
  
       inline struct timeval *get_deallocate_wait(struct timeval *buffer) const      //
       {      // Sets the AcceptLanguageList object associated with the caller's
          if(buffer == 0)      // Thread.
             throw NullPointer();      // Note: a Thread object must have been previously associated with
          buffer->tv_sec = _deallocate_wait.tv_sec;      // the caller's thread.
          buffer->tv_usec = _deallocate_wait.tv_usec;      //
          return buffer;      static void setLanguages(const AcceptLanguageList& langs);
       }  
  
       inline void set_deadlock_detect(const struct timeval & deadlock)      //
       {      // Removes the AcceptLanguageList object associated with the caller's
          _deadlock_detect.tv_sec = deadlock.tv_sec;      // Thread.
          _deadlock_detect.tv_usec = deadlock.tv_usec;      //
       }      static void clearLanguages();
  
       inline struct timeval * get_deadlock_detect(struct timeval *buffer) const  private:
       {      Thread();
          if(buffer == 0)  
             throw NullPointer();  
          buffer->tv_sec = _deadlock_detect.tv_sec;  
          buffer->tv_usec = _deadlock_detect.tv_usec;  
          return buffer;  
       }  
  
       inline Uint32 running_count(void)      static Sint8 initializeKey();
       {  
          return _running.count();  
       }  
  
       inline Uint32 pool_count(void)      // @exception IPCException
       inline void create_tsd(const char *key)
         {         {
           return _pool.count();          AutoPtr<thread_data> tsd(new thread_data(key));
           _tsd.insert_front(tsd.get());
           tsd.release();
         }         }
       inline Uint32 dead_count(void)  
         {  
           return _dead.count();  
         }  
   
   
       static Boolean check_time(struct timeval *start, struct timeval *interval);  
  
       Boolean operator ==(const ThreadPool & p)      ThreadHandle _handle;
       {      Boolean _is_detached;
          return operator==((const void *)&p);      Boolean _cancelled;
       }  
  
       Boolean operator ==(const void *p)      // always pass this * as the void * parameter to the thread
       {      // store the user parameter in _thread_parm
          if((void *)this == p)  
             return true;  
          return false;  
       }  
  
       static void kill_idle_threads(void);      ThreadReturnType(PEGASUS_THREAD_CDECL* _start) (void *);
       List<cleanup_handler, Mutex> _cleanup;
       List<thread_data, Mutex> _tsd;
  
    private:      void* _thread_parm;
       ThreadPool(void);      ThreadReturnType _exit_code;
       Sint16 _max_threads;      static Boolean _signals_blocked;
       Sint16 _min_threads;      static TSDKeyType _platform_thread_key;
       AtomicInt _current_threads;      static Boolean _key_initialized;
       struct timeval _allocate_wait;      static Boolean _key_error;
       struct timeval _deallocate_wait;  
       struct timeval _deadlock_detect;  
       static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _loop(void *);  
       Sint8 _key[17];  
       DQueue<Thread> _pool;  
       DQueue<Thread> _running;  
       DQueue<Thread> _dead;  
       AtomicInt _dying;  
       static void _sleep_sem_del(void *p);  
   
       void _check_deadlock(struct timeval *start) throw(Deadlock);  
       Boolean _check_deadlock_no_throw(struct timeval *start);  
       Boolean _check_dealloc(struct timeval *start);  
       Thread *_init_thread(void) throw(IPCException);  
       void _link_pool(Thread *th) throw(IPCException);  
       static PEGASUS_THREAD_RETURN  _undertaker(void *);  
       static DQueue<ThreadPool> _pools;  
  };  };
  
   
   
   
 #if defined(PEGASUS_OS_TYPE_WINDOWS)  
 # include "ThreadWindows_inline.h"  
 #elif defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)  
 # include "ThreadzOS_inline.h"  
 #elif defined(PEGASUS_OS_TYPE_UNIX)  
 # include "ThreadUnix_inline.h"  
 #endif  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
 #endif // Pegasus_Thread_h #endif // Pegasus_Thread_h

Legend:
Removed from v.1.27  
changed lines
  Added in v.1.61.12.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2