diff options
Diffstat (limited to 'ace/Synch.h')
| -rw-r--r-- | ace/Synch.h | 1068 |
1 files changed, 0 insertions, 1068 deletions
diff --git a/ace/Synch.h b/ace/Synch.h deleted file mode 100644 index 6d3e864d582..00000000000 --- a/ace/Synch.h +++ /dev/null @@ -1,1068 +0,0 @@ -/* -*- C++ -*- */ -// $Id$ - -// ============================================================================ -// -// = LIBRARY -// ace -// -// = FILENAME -// Synch.h -// -// = DESCRIPTION -// Wrappers for various synchronization routines. -// -// = AUTHOR -// Doug Schmidt -// -// ============================================================================ - -#if !defined (ACE_SYNCH_H) -#define ACE_SYNCH_H - -#include "ace/ACE.h" -#if !(defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM)) -#include "ace/SV_Semaphore_Complex.h" -#endif /* !(defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM)) */ - -// Forward declarations. -class ACE_Time_Value; -// template <class ACE_COND_MUTEX> class ACE_Condition; - -class ACE_Export ACE_File_Lock - // = TITLE - // A wrapper around the UNIX file locking mechanism. - // - // = DESCRIPTION - // Allows us to "adapt" the UNIX file locking mechanisms to work - // with all of our Guard stuff... -{ -public: - ACE_File_Lock (ACE_HANDLE handle = ACE_INVALID_HANDLE); - // Set the <handle_> of the File_Lock to <handle>. Note that this - // constructor assumes ownership of the <handle> and will close it - // down in <remove>. If you want the <handle> stays open when - // <remove> is called make sure to call <dup> on the <handle> before - // closing it. - - ACE_File_Lock (LPCTSTR filename, int flags, mode_t mode = 0); - // Open the <filename> with <flags> and <mode> and set the result to - // <handle_>. - - ~ACE_File_Lock (void); - // Remove a File lock by releasing it and closing down the <handle_>. - - int remove (void); - // Remove a File lock by releasing it and closing down the <handle_>. - - int acquire (short whence = 0, off_t start = 0, off_t len = 1); - // Note, for interface uniformity with other synchronization - // wrappers we include the <acquire> method. This is implemented as - // a write-lock to be on the safe-side... - - int tryacquire (short whence = 0, off_t start = 0, off_t len = 1); - // Note, for interface uniformity with other synchronization - // wrappers we include the <tryacquire> method. This is implemented - // as a write-lock to be on the safe-side... - - int release (short whence = 0, off_t start = 0, off_t len = 1); - // Unlock a readers/writer lock. - - int acquire_write (short whence = 0, off_t start = 0, off_t len = 1); - // Acquire a write lock, but block if any readers or a - // writer hold the lock. - - int tryacquire_write (short whence = 0, off_t start = 0, off_t len = 1); - // Conditionally acquire a write lock (i.e., won't block). - - int acquire_read (short whence = 0, off_t start = 0, off_t len = 1); - // Acquire a read lock, but block if a writer hold the lock. - - int tryacquire_read (short whence = 0, off_t start = 0, off_t len = 1); - // Conditionally acquire a read lock (i.e., won't block). - - ACE_HANDLE get_handle (void); - // Get underlying <ACE_HANDLE>. - - void set_handle (ACE_HANDLE); - // Set underlying <ACE_HANDLE>. Note that this method assumes - // ownership of the <handle> and will close it down in <remove>. If - // you want the <handle> stays open when <remove> is called make - // sure to call <dup> on the <handle> before closing it. - - void dump (void) const; - // Dump state of the object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -protected: - ACE_OS::flock_t lock_; - // Locking structure for OS record locks. - - // = Prevent assignment and initialization. - void operator= (const ACE_File_Lock &) {} - ACE_File_Lock (const ACE_File_Lock &) {} -}; - -class ACE_Export ACE_Semaphore - // = TITLE - // Wrapper for Dijkstra style general semaphores. -{ -public: - // = Initialization and termination. - ACE_Semaphore (u_int count, - int type = USYNC_THREAD, - LPCTSTR name = 0, - void * = 0, - int max = 0x7fffffff); - // Initialize the semaphore, with default value of "count". - - ~ACE_Semaphore (void); - // Implicitly destroy the semaphore. - - int remove (void); - // Explicitly destroy the semaphore. - - int acquire (void); - // Block the thread until the semaphore count becomes - // greater than 0, then decrement it. - - int tryacquire (void); - // Conditionally decrement the semaphore if count is greater - // than 0 (i.e., won't block). - - int release (void); - // Increment the semaphore, potentially unblocking - // a waiting thread. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - - const ACE_sema_t &lock (void) const; - // Return the underlying lock. - -private: - ACE_sema_t semaphore_; - - // = Prevent assignment and initialization. - void operator= (const ACE_Semaphore &) {} - ACE_Semaphore (const ACE_Semaphore &) {} -}; - -class ACE_Export ACE_Process_Semaphore - // = TITLE - // Wrapper for Dijkstra style general semaphores that work - // across processes. -{ -public: - ACE_Process_Semaphore (u_int count, LPCTSTR name = 0, - void * = 0, int max = 0x7FFFFFFF); - // Initialize the semaphore, with an initial value of <count> and a - // maximum value of <max>. - - ~ACE_Process_Semaphore (void); - // Implicitly destroy the semaphore. - - int remove (void); - // Explicitly destroy the semaphore. - - int acquire (void); - // Block the thread until the semaphore count becomes - // greater than 0, then decrement it. - - int tryacquire (void); - // Conditionally decrement the semaphore if count is greater - // than 0 (i.e., won't block). - - int release (void); - // Increment the semaphore, potentially unblocking - // a waiting thread. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -private: -#if defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM) - ACE_Semaphore lock_; -#else - ACE_SV_Semaphore_Complex lock_; - // We need this to get the right semantics... -#endif /* ACE_WIN32 */ -}; - -class ACE_Export ACE_RW_Mutex - // = TITLE - // Wrapper for readers/writer locks. - // - // = DESCRIPTION - // These are most useful for applications that have many more - // parallel readers than writers... -{ -public: - ACE_RW_Mutex (int type = USYNC_THREAD, - LPCTSTR name = 0, - void *arg = 0); - // Initialize a readers/writer lock. - - ~ACE_RW_Mutex (void); - // Implicitly destroy a readers/writer lock - - int remove (void); - // Explicitly destroy a readers/writer lock. - - int acquire_read (void); - // Acquire a read lock, but block if a writer hold the lock. - - int acquire_write (void); - // Acquire a write lock, but block if any readers or a - // writer hold the lock. - - int tryacquire_read (void); - // Conditionally acquire a read lock (i.e., won't block). - - int tryacquire_write (void); - // Conditionally acquire a write lock (i.e., won't block). - - int acquire (void); - // Note, for interface uniformity with other synchronization - // wrappers we include the <acquire> method. This is implemented as - // a write-lock to be on the safe-side... - - int tryacquire (void); - // Note, for interface uniformity with other synchronization - // wrappers we include the <tryacquire> method. This is implemented - // as a write-lock to be on the safe-side... - - int release (void); - // Unlock a readers/writer lock. - - const ACE_rwlock_t &lock (void) const; - // Return the underlying lock. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -private: - ACE_rwlock_t lock_; - // Readers/writer lock. - - // = Prevent assignment and initialization. - void operator= (const ACE_RW_Mutex &) {} - ACE_RW_Mutex (const ACE_RW_Mutex &) {} -}; - -class ACE_Export ACE_Mutex - // = TITLE - // ACE_Mutex wrapper (valid in same process or across processes - // (depending on TYPE flag)) -{ -public: - ACE_Mutex (int type = USYNC_THREAD, - LPCTSTR name = 0, - void *arg = 0); - // Initialize the mutex. - - ~ACE_Mutex (void); - // Implicitly destroy the mutex. - - int remove (void); - // Explicitly destroy the mutex. - - int acquire (void); - // Acquire lock ownership (wait on priority queue if necessary). - - int tryacquire (void); - // Conditionally acquire lock (i.e., don't wait on queue). - - int release (void); - // Release lock and unblock a thread at head of priority queue. - - int acquire_read (void); - // Acquire lock ownership (wait on priority queue if necessary). - - int acquire_write (void); - // Acquire lock ownership (wait on priority queue if necessary). - - int tryacquire_read (void); - // Conditionally acquire a lock (i.e., won't block). - - int tryacquire_write (void); - // Conditionally acquire a lock (i.e., won't block). - - const ACE_mutex_t &lock (void) const; - // Return the underlying mutex. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -//private: - ACE_mutex_t lock_; - // Mutex type supported by the OS. - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Mutex &) {} - ACE_Mutex (const ACE_Mutex &) {} -}; - -class ACE_Export ACE_Process_Mutex - // = TITLE - // ACE_Mutex wrapper (valid in same process, as well as across - // processes). -{ -public: - ACE_Process_Mutex (LPCTSTR name = ACE_DEFAULT_MUTEX, void *arg = 0); - // Create a Process_Mutex, passing in the optional <name>. - - ~ACE_Process_Mutex (void); - - int remove (void); - // Explicitly destroy the mutex. - - int acquire (void); - // Acquire lock ownership (wait on priority queue if necessary). - - int tryacquire (void); - // Conditionally acquire lock (i.e., don't wait on queue). - - int release (void); - // Release lock and unblock a thread at head of priority queue. - - int acquire_read (void); - // Acquire lock ownership (wait on priority queue if necessary). - - int acquire_write (void); - // Acquire lock ownership (wait on priority queue if necessary). - - int tryacquire_read (void); - // Conditionally acquire a lock (i.e., won't block). - - int tryacquire_write (void); - // Conditionally acquire a lock (i.e., won't block). - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -#if defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM) - ACE_Mutex lock_; -#else - ACE_SV_Semaphore_Complex lock_; - // We need this to get the right semantics... -#endif /* ACE_WIN32 */ -}; - -class ACE_Export ACE_RW_Process_Mutex : public ACE_Process_Mutex - // = TITLE - // Wrapper for readers/writer locks that exist across processes. -{ -public: - ACE_RW_Process_Mutex (LPCTSTR name = ACE_DEFAULT_MUTEX, - void *arg = 0); - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -}; - -class ACE_Null_Barrier - // = TITLE - // Implements "NULL barrier synchronization". -{ -public: - ACE_Null_Barrier (u_int, - const char * = 0, - void * = 0) {} - // Initialize the barrier to synchronize <count> threads. - - int wait (void) { return 0; } - // Block the caller until all <count> threads have called <wait> and - // then allow all the caller threads to continue in parallel. - - void dump (void) const {} - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -private: - - // = Prevent assignment and initialization. - void operator= (const ACE_Null_Barrier &) {} - ACE_Null_Barrier (const ACE_Null_Barrier &) {} -}; - -class ACE_Export ACE_Null_Mutex - // = TITLE - // Implement a do nothing <ACE_Mutex>, i.e., all the methods are - // no ops. -{ -public: - ACE_Null_Mutex (LPCTSTR = 0) {} - ~ACE_Null_Mutex (void) {} - int remove (void) { return 0; } - - int acquire (void) { return 0; } - int tryacquire (void) { return 0; } - int release (void) { return 0; } - int acquire_write (void) { return 0; } - int tryacquire_write (void) { return 0; } - int acquire_read (void) { return 0; } - int tryacquire_read (void) { return 0; } - - void dump (void) const { } - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -}; - -class ACE_Export ACE_Null_Condition_Mutex - // = TITLE - // Implement a do nothing <ACE_Condition> variable wrapper, i.e., - // all methods are no ops. This class is necessary since some - // C++ compilers are *very* lame... -{ -public: - ACE_Null_Condition_Mutex (ACE_Null_Mutex &m, int = 0, - LPCTSTR = 0, void * = 0): mutex_ (m) {} - ~ACE_Null_Condition_Mutex (void) {} - int remove (void) { return 0; } - int wait (ACE_Time_Value * = 0) { errno = ETIME; return -1; } - int signal (void) { return 0; } - int broadcast (void) { return 0; } - ACE_Null_Mutex &mutex (void) { return this->mutex_; } - - void dump (void) const {} - // Dump the state of an object. - - // ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -private: - ACE_Null_Mutex &mutex_; // Reference to mutex lock. - - // = Prevent assignment and initialization. - void operator= (const ACE_Null_Condition_Mutex &) {} - ACE_Null_Condition_Mutex (const ACE_Null_Condition_Mutex &c): mutex_ (c.mutex_) {} -}; - -class ACE_Export ACE_Null_Mutex_Guard - // = TITLE - // This data structure is meant to be used within a method or - // function... It performs automatic aquisition and release of - // an ACE_Null_Mutex. - // - // = DESCRIPTION - // This should be a specialization of ACE_Guard, but compiler - // bugs preclude this... -{ -public: - ACE_Null_Mutex_Guard (ACE_Null_Mutex &) {} - ~ACE_Null_Mutex_Guard (void) {} - int remove (void) { return 0; } - int locked (void) { return 1; } - int acquire (void) { return 0; } - int tryacquire (void) { return 0; } - int release (void) { return 0; } - void dump (void) const { } - -protected: - // = Prevent assignment and initialization. - void operator= (const ACE_Null_Mutex_Guard &) {} - ACE_Null_Mutex_Guard (const ACE_Null_Mutex_Guard &) {} -}; - -class ACE_TSS_Adapter - // = TITLE - // This class encapsulates a TSS object and its associated - // C++ destructor function. It is used by the ACE_TSS... - // methods (in Synch_T.cpp) in order to allow an extern - // "C" cleanup routine to be used. Needed by the "frigging" - // MVS C++ compiler. - // - // = DESCRIPTION - // Objects of this class are stored in thread specific - // storage. ts_obj_ points to the "real" object and - // func_ is a pointer to the C++ cleanup function for ts_obj_. - // -{ -public: - ACE_TSS_Adapter (void *object, ACE_THR_DEST f); - // Initialize the adapter. - - void cleanup (void); - // Perform the cleanup operation. - -//private: - - void *ts_obj_; - // The real TS object. - - ACE_THR_DEST func_; - // The real cleanup routine for ts_obj; -}; - -class ACE_Export ACE_Event - // = TITLE - // A wrapper around the Win32 event locking mechanism. - // - // = DESCRIPTION - // Portable implementation of an Event mechanism, which is - // native to Win32, but must be emulated on UNIX. -{ -public: - ACE_Event (int manual_reset = 0, - int initial_state = 0, - int type = USYNC_THREAD, - LPCTSTR name = 0, - void *arg = 0); - // Constructor which will create event. - - ~ACE_Event (void); - // Implicitly destroy the event variable. - - int remove (void); - // Explicitly destroy the event variable. - - ACE_event_t handle (void) const; - // Underlying handle to event. - - int wait (void); - // if MANUAL reset - // sleep till the event becomes signaled - // event remains signaled after wait() completes. - // else AUTO reset - // sleep till the event becomes signaled - // event resets wait() completes. - - int wait (const ACE_Time_Value *abstime); - // Same as wait() above, but this one can be timed - // <abstime> is absolute time-of-day. - - int signal (void); - // if MANUAL reset - // wake up all waiting threads - // set to signaled state - // else AUTO reset - // if no thread is waiting, set to signaled state - // if thread(s) are waiting, wake up one waiting thread and - // reset event - - int pulse (void); - // if MANUAL reset - // wakeup all waiting threads and - // reset event - // else AUTO reset - // wakeup one waiting thread (if present) and - // reset event - - int reset (void); - // Set to nonsignaled state. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks - -private: - - // prevent copy constructors - ACE_Event (const ACE_Event& event); - - // prevent assignment operators - const ACE_Event &operator= (const ACE_Event &rhs); - - ACE_event_t handle_; -}; - -class ACE_Export ACE_Manual_Event : public ACE_Event - // = TITLE - // Manual Events. - // - // = DESCRIPTION - // Specialization of Event mechanism which - // wakes up all on signal() -{ -public: - ACE_Manual_Event (int initial_state = 0, - int type = USYNC_THREAD, - LPCTSTR name = 0, - void *arg = 0); - // constructor which will create manual event - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks -}; - -class ACE_Export ACE_Auto_Event : public ACE_Event - // = TITLE - // Auto Events. - // - // = DESCRIPTION - // Specialization of Event mechanism which - // wakes up all on signal() -{ -public: - ACE_Auto_Event (int initial_state = 0, - int type = USYNC_THREAD, - LPCTSTR name = 0, - void *arg = 0); - // constructor which will create auto event - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks -}; - -#if defined (ACE_HAS_THREADS) /* ACE platform supports some form of threading. */ - -class ACE_Export ACE_Thread_Mutex - // = TITLE - // ACE_Thread_Mutex wrapper (only valid for threads in the same - // process). - // - // = DESCRIPTION - // This implementation is optimized for locking threads that are - // in the same process. It maps to <CRITICAL_SECTION>s on NT - // and <ACE_mutex_t> with <type> set to <USYNC_THREAD> on UNIX. -{ -public: - ACE_Thread_Mutex (LPCTSTR name = 0, void *arg = 0); - - ~ACE_Thread_Mutex (void); - // Implicitly destroy the mutex. - - int remove (void); - // Explicitly destroy the mutex. - - int acquire (void); - // Acquire lock ownership (wait on priority queue if necessary). - - int tryacquire (void); - // Conditionally acquire lock (i.e., don't wait on queue). - - int release (void); - // Release lock and unblock a thread at head of priority queue. - - int acquire_read (void); - // Acquire lock ownership (wait on priority queue if necessary). - - int acquire_write (void); - // Acquire lock ownership (wait on priority queue if necessary). - - int tryacquire_read (void); - // Conditionally acquire a lock (i.e., won't block). - - int tryacquire_write (void); - // Conditionally acquire a lock (i.e., won't block). - - const ACE_thread_mutex_t &lock (void) const; - // Return the underlying mutex. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -//private: - ACE_thread_mutex_t lock_; - // Mutex type that supports single-process locking efficiently. - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Thread_Mutex &) {} - ACE_Thread_Mutex (const ACE_Thread_Mutex &) {} -}; - -class ACE_Export ACE_Thread_Mutex_Guard - // = TITLE - // This data structure is meant to be used within a method or - // function... It performs automatic aquisition and release of - // an ACE_Mutex. - // - // = DESCRIPTION - // This should be a specialization of ACE_Guard, but compiler - // bugs in older C++ compilers preclude this... -{ -public: - ACE_Thread_Mutex_Guard (ACE_Thread_Mutex &m, int block = 1); - // Implicitly and automatically acquire the lock. - - ~ACE_Thread_Mutex_Guard (void); - // Implicitly release the lock. - - int locked (void); - // 1 if locked, 0 if couldn't acquire the lock (errno will contain - // the reason for this). - - int remove (void); - // Explicitly release the lock. - - int acquire (void); - // Explicitly acquire the lock. - - int tryacquire (void); - // Conditionally acquire the lock (i.e., won't block). - - int release (void); - // Explicitly release the lock. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -protected: - ACE_Thread_Mutex &lock_; - // Reference to the mutex. - - int owner_; - // Keeps track of whether we acquired the lock or failed. - - // = Prevent assignment and initialization. - void operator= (const ACE_Thread_Mutex_Guard &) {} - ACE_Thread_Mutex_Guard (const ACE_Thread_Mutex_Guard &g): lock_ (g.lock_) {} -}; - -class ACE_Export ACE_Condition_Thread_Mutex - // = TITLE - // ACE_Condition variable wrapper written using ACE_Mutexes This - // allows threads to block until shared data changes state. - // - // = DESCRIPTION - // This should be an instantiation of ACE_Condition but problems - // with compilers precludes this... -{ -public: - ACE_Condition_Thread_Mutex (const ACE_Thread_Mutex &m, - LPCTSTR name = 0, - void *arg = 0); - // Initialize the condition variable. - - ~ACE_Condition_Thread_Mutex (void); - // Implicitly destroy the condition variable. - - int remove (void); - // Explicitly destroy the condition variable. - - int wait (const ACE_Time_Value *abstime); - // Block on condition, or until absolute time-of-day has passed. If - // abstime == 0 use "blocking" <wait> semantics. Else, if <abstime> - // != 0 and the call times out before the condition is signaled - // <wait> returns -1 and sets errno to ETIME. - - int wait (void); - // Block on condition. - - int wait (ACE_Thread_Mutex &mutex, const ACE_Time_Value *abstime = 0); - // Block on condition or until absolute time-of-day has passed. If - // abstime == 0 use "blocking" wait() semantics on the <mutex> - // passed as a parameter (this is useful if you need to store the - // <Condition> in shared memory). Else, if <abstime> != 0 and the - // call times out before the condition is signaled <wait> returns -1 - // and sets errno to ETIME. - - int signal (void); - // Signal one waiting thread. - - int broadcast (void); - // Signal *all* waiting threads. - - ACE_Thread_Mutex &mutex (void); - // Returns a reference to the underlying mutex_; - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -private: - ACE_cond_t cond_; - // Condition variable. - - ACE_Thread_Mutex &mutex_; - // Reference to mutex lock. - - // = Prevent assignment and initialization. - void operator= (const ACE_Condition_Thread_Mutex &) {} - ACE_Condition_Thread_Mutex (const ACE_Condition_Thread_Mutex &c): mutex_ (c.mutex_) {} -}; - -class ACE_Export ACE_Recursive_Thread_Mutex - // = TITLE - // Implement a C++ wrapper that allows calls to class - // <ACE_Thread_Mutex> to be nested for a nested acquire() that - // occurs in the same thread. - // - // = DESCRIPTION - // This class should be a specialization of the - // ACE_Recursive_Lock template class, but problems with some C++ - // compilers preclude this. This implementation is based - // on an algorithm sketched by Dave Butenhof <butenhof@zko.dec.com>. - // Naturally, I take the credit for any mistakes ;-) -{ - // friend class ACE_Condition<class ACE_COND_MUTEX>; -public: - ACE_Recursive_Thread_Mutex (LPCTSTR name = 0, - void *arg = 0); - // Initialize a recursive mutex. - - ~ACE_Recursive_Thread_Mutex (void); - // Implicitly release a recursive mutex. - - int remove (void); - // Implicitly release a recursive mutex. - - int acquire (void); - // Acquire a recursive mutex (will increment the nesting level and - // not deadmutex if the owner of the mutex calls this method more - // than once). - - int tryacquire (void); - // Conditionally acquire a recursive mutex (i.e., won't block). - - int release (void); - // Releases a recursive mutex (will not release mutex until all the - // nesting level drops to 0, which means the mutex is no longer - // held). - - ACE_thread_t get_thread_id (void); - // Return the id of the thread that currently owns the mutex. - - int get_nesting_level (void); - // Return the nesting level of the recursion. When a thread has - // acquired the mutex for the first time, the nesting level == 1. - // The nesting level is incremented every time the thread acquires - // the mutex recursively. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -private: - // These methods should *not* be public (they hold no locks...) - void set_nesting_level (int d); - void set_thread_id (ACE_thread_t t); - - ACE_Thread_Mutex nesting_mutex_; - // Guards the state of the nesting level and thread id. - - ACE_Condition_Thread_Mutex lock_available_; - // This is the condition variable that actually suspends other - // waiting threads until the mutex is available. - - int nesting_level_; - // Current nesting level of the recursion. - - ACE_thread_t owner_id_; - // Current owner of the lock. - - // = Prevent assignment and initialization. - void operator= (const ACE_Recursive_Thread_Mutex &) {} - ACE_Recursive_Thread_Mutex (const ACE_Recursive_Thread_Mutex &); -}; - -class ACE_Export ACE_RW_Thread_Mutex : public ACE_RW_Mutex - // = TITLE - // Wrapper for readers/writer locks that exist within a process. -{ -public: - ACE_RW_Thread_Mutex (LPCTSTR name = 0, - void *arg = 0); - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -}; - -class ACE_Export ACE_Thread_Semaphore : public ACE_Semaphore - // = TITLE - // Wrapper for Dijkstra style general semaphores that work - // only within on process. -{ -public: - ACE_Thread_Semaphore (u_int count, LPCTSTR name = 0, - void * = 0, int max = 0x7FFFFFFF); - // Initialize the semaphore, with an initial value of <count> and a - // maximum value of <max>. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -}; - -struct ACE_Export ACE_Sub_Barrier -{ - // = Initialization. - ACE_Sub_Barrier (u_int count, - ACE_Thread_Mutex &lock, - LPCTSTR name = 0, - void *arg = 0); - - ACE_Condition_Thread_Mutex barrier_finished_; - // True if this generation of the barrier is done. - - int running_threads_; - // Number of threads that are still running. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -}; - -class ACE_Export ACE_Barrier - // = TITLE - // Implements "barrier synchronization". - // - // = DESCRIPTION - // This class allows <count> number of threads to synchronize - // their completion (so-called "barrier synchronization"). The - // implementation uses a "sub-barrier generation numbering" - // scheme to avoid overhead and to ensure that all threads exit - // the barrier correct. This code is based on an article from - // SunOpsis Vol. 4, No. 1 by Richard Marejka - // (Richard.Marejka@canada.sun.com). -{ -public: - ACE_Barrier (u_int count, - LPCTSTR name = 0, - void *arg = 0); - // Initialize the barrier to synchronize <count> threads. - - int wait (void); - // Block the caller until all <count> threads have called <wait> and - // then allow all the caller threads to continue in parallel. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -private: - ACE_Thread_Mutex lock_; - // Serialize access to the barrier state. - - int current_generation_; - // Either 0 or 1, depending on whether we are the first generation - // of waiters or the next generation of waiters. - - int count_; - // Total number of threads that can be waiting at any one time. - - ACE_Sub_Barrier sub_barrier_1_; - ACE_Sub_Barrier sub_barrier_2_; - ACE_Sub_Barrier *sub_barrier_[2]; - // We keep two <sub_barriers>, one for the first "generation" of - // waiters, and one for the next "generation" of waiters. This - // efficiently solves the problem of what to do if all the first - // generation waiters don't leave the barrier before one of the - // threads calls wait() again (i.e., starts up the next generation - // barrier). - - // = Prevent assignment and initialization. - void operator= (const ACE_Barrier &) {} - ACE_Barrier (const ACE_Barrier &): sub_barrier_1_ (0, lock_), sub_barrier_2_ (0, lock_) {} -}; - -#if 0 -class ACE_Process_Condition - // = TITLE - // ACE_Condition variable wrapper that works across processes. -{ -public: - ACE_Process_Condition (MUTEX &m, LPCTSTR name = 0, void *arg = 0); - - void dump (void) const; - // Dump the state of an object. - - // ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -}; -#endif /* ACE_HAS_STHREADS */ - -#if 0 -class ACE_Export ACE_Process_Barrier : public ACE_Barrier - // = TITLE - // Implements "barrier synchronization" using ACE_Process_Mutexes! - // - // = DESCRIPTION - // This class is just a simple wrapper for ACE_Barrier that - // selects the USYNC_PROCESS variant for the locks. -{ -public: - ACE_Process_Barrier (u_int count, LPCTSTR name = 0); - // Create a Process_Barrier, passing in the optional <name>. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -}; -#endif /* 0 */ - -class ACE_Export ACE_Thread_Barrier : public ACE_Barrier - // = TITLE - // Implements "barrier synchronization" using ACE_Thread_Mutexes! - // - // = DESCRIPTION - // This class is just a simple wrapper for ACE_Barrier that - // selects the USYNC_THREAD variant for the locks. -{ -public: - ACE_Thread_Barrier (u_int count, LPCTSTR name = 0); - // Create a Thread_Barrier, passing in the optional <name>. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -}; - -#endif /* ACE_HAS_THREADS */ - -#if defined (__ACE_INLINE__) -#include "ace/Synch.i" -#endif /* __ACE_INLINE__ */ - -// Include the templates here. -#include "ace/Synch_T.h" - -#endif /* ACE_SYNCH_H */ |