diff options
Diffstat (limited to 'ace/Synch.h')
| -rw-r--r-- | ace/Synch.h | 1703 |
1 files changed, 0 insertions, 1703 deletions
diff --git a/ace/Synch.h b/ace/Synch.h deleted file mode 100644 index 1257575285f..00000000000 --- a/ace/Synch.h +++ /dev/null @@ -1,1703 +0,0 @@ -/* -*- C++ -*- */ -// $Id$ - -// ============================================================================ -// -// = LIBRARY -// ace -// -// = FILENAME -// Synch.h -// -// = DESCRIPTION -// Wrappers for various synchronization routines. -// -// = AUTHOR -// Doug Schmidt -// -// ============================================================================ - -#ifndef ACE_SYNCH_H -#define ACE_SYNCH_H -#include "ace/pre.h" - -#include "ace/ACE.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#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_Lock -{ - // = TITLE - // This is the abstract base class that contains the uniform - // locking API that is supported by all the ACE synchronization - // mechanisms. - // - // = DESCRIPTION - // This class is typically used in conjunction with the - // <ACE_Lock_Adapter> in order to provide a polymorphic - // interface to the ACE synchronization mechanisms (e.g., - // <ACE_Mutex>, <ACE_Semaphore>, <ACE_RW_Mutex>, etc). Note that - // the reason that all of ACE doesn't use polymorphic locks is - // that (1) they add ~20% extra overhead for virtual function - // calls and (2) objects with virtual functions can't be placed - // into shared memory. -public: - ACE_Lock (void); - // CE needs a default ctor here. - - virtual ~ACE_Lock (void); - // Noop virtual destructor - - virtual int remove (void) = 0; - // Explicitly destroy the lock. Note that only one thread should - // call this method since it doesn't protect against race - // conditions. - - virtual int acquire (void) = 0; - // Block the thread until the lock is acquired. Returns -1 on - // failure. - - virtual int tryacquire (void) = 0; - // Conditionally acquire the lock (i.e., won't block). Returns -1 - // on failure. If we "failed" because someone else already had the - // lock, <errno> is set to <EBUSY>. - - virtual int release (void) = 0; - // Release the lock. Returns -1 on failure. - - virtual int acquire_read (void) = 0; - // Block until the thread acquires a read lock. If the locking - // mechanism doesn't support read locks then this just calls - // <acquire>. Returns -1 on failure. - - virtual int acquire_write (void) = 0; - // Block until the thread acquires a write lock. If the locking - // mechanism doesn't support read locks then this just calls - // <acquire>. Returns -1 on failure. - - virtual int tryacquire_read (void) = 0; - // Conditionally acquire a read lock. If the locking mechanism - // doesn't support read locks then this just calls <acquire>. - // Returns -1 on failure. If we "failed" because someone else - // already had the lock, <errno> is set to <EBUSY>. - - virtual int tryacquire_write (void) = 0; - // Conditionally acquire a write lock. If the locking mechanism - // doesn't support read locks then this just calls <acquire>. - // Returns -1 on failure. If we "failed" because someone else - // already had the lock, <errno> is set to <EBUSY>. -}; - -class ACE_Export ACE_Adaptive_Lock : public ACE_Lock -{ - // = TITLE - // An adaptive general locking class that defers the decision of - // lock type to run time. - // - // = DESCRIPTION - // This class, as ACE_Lock, provide a set of general locking APIs. - // However, it defers our decision of what kind of lock to use - // to the run time and delegates all locking operations to the actual - // lock. Users must define a constructor in their subclass to - // initialize <lock_>. -public: - virtual ~ACE_Adaptive_Lock (void); - // You must also override the destructor function to match with how - // you construct the underneath <lock_>. - - // = Lock/unlock operations. - - virtual int remove (void); - virtual int acquire (void); - virtual int tryacquire (void); - virtual int release (void); - virtual int acquire_read (void); - virtual int acquire_write (void); - virtual int tryacquire_read (void); - virtual int tryacquire_write (void); - void dump (void) const; - -protected: - ACE_Adaptive_Lock (void); - // Create and initialize create the actual lcok used in the class. - // The default constructor simply set the <lock_> to 0 (null). You - // must overwrite this method for this class to work. - - ACE_Lock *lock_; -}; - -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 (const ACE_TCHAR *filename, int flags, mode_t mode = 0); - // Open the <filename> with <flags> and <mode> and set the result to - // <handle_>. - - int open (const ACE_TCHAR *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 (int unlink_file = 1); - // Remove a File lock by releasing it and closing down the - // <handle_>. If <unlink_file> is non-0 then we unlink the file. - - 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... Returns -1 on failure. - // If we "failed" because someone else already had the lock, <errno> - // is set to <EBUSY>. - - 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). Returns - // -1 on failure. If we "failed" because someone else already had - // the lock, <errno> is set to <EBUSY>. - - 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. - // Returns -1 on failure. If we "failed" because someone else - // already had the lock, <errno> is set to <EBUSY>. - - int tryacquire_read (short whence = 0, off_t start = 0, off_t len = 1); - // Conditionally acquire a read lock (i.e., won't block). Returns - // -1 on failure. If we "failed" because someone else already had - // the lock, <errno> is set to <EBUSY>. - - ACE_HANDLE get_handle (void); - // Get underlying <ACE_HANDLE> for the file. - - 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> to stay open when <remove> is called make - // sure to call <dup> on the <handle> before closing it. You are - // responsible for the closing the existing <handle> before - // overwriting it. - - void dump (void) const; - // Dump state of the object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -protected: - ACE_OS::ace_flock_t lock_; - // Locking structure for OS record locks. - - int removed_; - // Keeps track of whether <remove> has been called yet to avoid - // multiple <remove> calls, e.g., explicitly and implicitly in the - // destructor. This flag isn't protected by a lock, so make sure - // that you don't have multiple threads simultaneously calling - // <remove> on the same object, which is a bad idea anyway... - -private: - // = 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 = 1, // By default make this unlocked. - int type = USYNC_THREAD, - const ACE_TCHAR *name = 0, - void * = 0, - int max = 0x7fffffff); - // Initialize the semaphore, with initial value of "count". - - ~ACE_Semaphore (void); - // Implicitly destroy the semaphore. - - int remove (void); - // Explicitly destroy the semaphore. Note that only one thread - // should call this method since it doesn't protect against race - // conditions. - - int acquire (void); - // Block the thread until the semaphore count becomes - // greater than 0, then decrement it. - - int acquire (ACE_Time_Value &tv); - // Block the thread until <tv> times out or until the semaphore - // count becomes greater than 0 (at which point it is decremented). - // Note that <tv> is assumed to be in "absolute" rather than - // "relative" time. The value of <tv> is updated upon return to - // show the actual (absolute) acquisition time. - // - // NOTE: Solaris threads do not support timed semaphores. - // Therefore, if you're running on Solaris you might want to - // consider using the ACE POSIX pthreads implementation instead, - // which can be enabled by compiling ACE with - // -D_POSIX_PTHREAD_SEMANTICS. - - int tryacquire (void); - // Conditionally decrement the semaphore if count is greater than 0 - // (i.e., won't block). Returns -1 on failure. If we "failed" - // because someone else already had the lock, <errno> is set to - // <EBUSY>. - - int release (void); - // Increment the semaphore by 1, potentially unblocking a waiting - // thread. - - int release (size_t release_count); - // Increment the semaphore by <release_count>, potentially - // unblocking waiting threads. - - int acquire_read (void); - // Acquire semaphore ownership. This calls <acquire> and is only - // here to make the <ACE_Semaphore> interface consistent with the - // other synchronization APIs. - - int acquire_write (void); - // Acquire semaphore ownership. This calls <acquire> and is only - // here to make the <ACE_Semaphore> interface consistent with the - // other synchronization APIs. - - int tryacquire_read (void); - // Conditionally acquire semaphore (i.e., won't block). This calls - // <tryacquire> and is only here to make the <ACE_Semaphore> - // interface consistent with the other synchronization APIs. - // Returns -1 on failure. If we "failed" because someone else - // already had the lock, <errno> is set to <EBUSY>. - - int tryacquire_write (void); - // Conditionally acquire semaphore (i.e., won't block). This calls - // <tryacquire> and is only here to make the <ACE_Semaphore> - // interface consistent with the other synchronization APIs. - // Returns -1 on failure. If we "failed" because someone else - // already had the lock, <errno> is set to <EBUSY>. - - 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. - -protected: - ACE_sema_t semaphore_; - - int removed_; - // Keeps track of whether <remove> has been called yet to avoid - // multiple <remove> calls, e.g., explicitly and implicitly in the - // destructor. This flag isn't protected by a lock, so make sure - // that you don't have multiple threads simultaneously calling - // <remove> on the same object, which is a bad idea anyway... - -private: - // = 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 = 1, // By default make this unlocked. - const ACE_TCHAR *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); - // This method is a no-op, i.e., it doesn't remove the semaphore. - // If you want to remove the semaphore, you must call the <remove> - // method explicitly. - - int remove (void); - // Explicitly destroy the semaphore. Note that only one thread - // should call this method since it doesn't protect against race - // conditions. - - 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). Returns -1 on failure. If we "failed" - // because someone else already had the lock, <errno> is set to - // <EBUSY>. - - int release (void); - // Increment the semaphore, potentially unblocking a waiting thread. - - int acquire_read (void); - // Acquire semaphore ownership. This calls <acquire> and is only - // here to make the <ACE_Process_Semaphore> interface consistent - // with the other synchronization APIs. - - int acquire_write (void); - // Acquire semaphore ownership. This calls <acquire> and is only - // here to make the <ACE_Process_Semaphore> interface consistent - // with the other synchronization APIs. - - int tryacquire_read (void); - // Conditionally acquire semaphore (i.e., won't block). This calls - // <tryacquire> and is only here to make the <ACE_Process_Semaphore> - // interface consistent with the other synchronization APIs. - // Returns -1 on failure. If we "failed" because someone else - // already had the lock, <errno> is set to <EBUSY>. - - int tryacquire_write (void); - // Conditionally acquire semaphore (i.e., won't block). This calls - // <tryacquire> and is only here to make the <ACE_Process_Semaphore> - // interface consistent with the other synchronization APIs. - // Returns -1 on failure. If we "failed" because someone else - // already had the lock, <errno> is set to <EBUSY>. - -#if defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM) - const ACE_sema_t &lock (void) const; - // Return the underlying lock. -#endif /* ACE_WIN32 */ - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -protected: -#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_Null_Semaphore -{ - // = TITLE - // Implement a do nothing <ACE_Semaphore>, i.e., all the methods are - // no ops. -public: - ACE_Null_Semaphore (u_int count = 1, // By default make this unlocked. - int type = USYNC_THREAD, - const ACE_TCHAR *name = 0, - void * = 0, - int max = 0x7fffffff); - ~ACE_Null_Semaphore (void); - int remove (void); - - int acquire (ACE_Time_Value &); - int acquire (void); - int tryacquire (void); - int release (void); - int release (size_t); - int acquire_write (void); - int tryacquire_write (void); - int acquire_read (void); - int tryacquire_read (void); - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -}; - -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, - const ACE_TCHAR *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. Note that only one - // thread should call this method since it doesn't protect against - // race conditions. - - 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). Returns - // -1 on failure. If we "failed" because someone else already had - // the lock, <errno> is set to <EBUSY>. - - 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 safe... - - 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 safe... Returns -1 on failure. If we - // "failed" because someone else already had the lock, <errno> is - // set to <EBUSY>. - - 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. - -protected: - ACE_rwlock_t lock_; - // Readers/writer lock. - - int removed_; - // Keeps track of whether <remove> has been called yet to avoid - // multiple <remove> calls, e.g., explicitly and implicitly in the - // destructor. This flag isn't protected by a lock, so make sure - // that you don't have multiple threads simultaneously calling - // <remove> on the same object, which is a bad idea anyway... -private: - // = 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, - const ACE_TCHAR *name = 0, - ACE_mutexattr_t *arg = 0); - // Initialize the mutex. - - ~ACE_Mutex (void); - // Implicitly destroy the mutex. - - int remove (void); - // Explicitly destroy the mutex. Note that only one thread should - // call this method since it doesn't protect against race - // conditions. - - int acquire (void); - // Acquire lock ownership (wait on queue if necessary). - - int tryacquire (void); - // Conditionally acquire lock (i.e., don't wait on queue). Returns - // -1 on failure. If we "failed" because someone else already had - // the lock, <errno> is set to <EBUSY>. - - int release (void); - // Release lock and unblock a thread at head of queue. - - int acquire_read (void); - // Acquire mutex ownership. This calls <acquire> and is only - // here to make the <ACE_Mutex> interface consistent with the - // other synchronization APIs. - - int acquire_write (void); - // Acquire mutex ownership. This calls <acquire> and is only - // here to make the <ACE_Mutex> interface consistent with the - // other synchronization APIs. - - int tryacquire_read (void); - // Conditionally acquire mutex (i.e., won't block). This calls - // <tryacquire> and is only here to make the <ACE_Mutex> interface - // consistent with the other synchronization APIs. Returns -1 on - // failure. If we "failed" because someone else already had the - // lock, <errno> is set to <EBUSY>. - - int tryacquire_write (void); - // Conditionally acquire mutex (i.e., won't block). This calls - // <tryacquire> and is only here to make the <ACE_Mutex> interface - // consistent with the other synchronization APIs. Returns -1 on - // failure. If we "failed" because someone else already had the - // lock, <errno> is set to <EBUSY>. - - 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. - - // = This should be protected but some C++ compilers complain... -public: -#if defined (CHORUS) - ACE_mutex_t *process_lock_; - // This lock resides in shared memory. - - const ACE_TCHAR *lockname_; - // Remember the name of the mutex if we created it so we can unlink - // it when we go away (only the actor that initialized the memory - // can destroy it). -#endif /* CHORUS */ - - ACE_mutex_t lock_; - // Mutex type supported by the OS. - - int removed_; - // Keeps track of whether <remove> has been called yet to avoid - // multiple <remove> calls, e.g., explicitly and implicitly in the - // destructor. This flag isn't protected by a lock, so make sure - // that you don't have multiple threads simultaneously calling - // <remove> on the same object, which is a bad idea anyway... - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Mutex &); - ACE_Mutex (const ACE_Mutex &); -}; - -class ACE_Export ACE_Process_Mutex -{ - // = TITLE - // A wrapper for mutexes that can be used across processes on - // the same host machine, as well as within a process, of - // course. -public: - ACE_Process_Mutex (const ACE_TCHAR *name = 0, - void *arg = 0); - // Create a Process_Mutex, passing in the optional <name>. - - ~ACE_Process_Mutex (void); - - int remove (void); - // Explicitly destroy the mutex. Note that only one thread should - // call this method since it doesn't protect against race - // conditions. - - int acquire (void); - // Acquire lock ownership (wait on queue if necessary). - - int tryacquire (void); - // Conditionally acquire lock (i.e., don't wait on queue). Returns - // -1 on failure. If we "failed" because someone else already had - // the lock, <errno> is set to <EBUSY>. - - int release (void); - // Release lock and unblock a thread at head of queue. - - int acquire_read (void); - // Acquire lock ownership (wait on queue if necessary). - - int acquire_write (void); - // Acquire lock ownership (wait on queue if necessary). - - int tryacquire_read (void); - // Conditionally acquire a lock (i.e., won't block). Returns -1 on - // failure. If we "failed" because someone else already had the - // lock, <errno> is set to <EBUSY>. - - int tryacquire_write (void); - // Conditionally acquire a lock (i.e., won't block). Returns -1 on - // failure. If we "failed" because someone else already had the - // lock, <errno> is set to <EBUSY>. - -#if defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM) - const ACE_mutex_t &lock (void) const; - // Return the underlying mutex. -#endif /* ACE_WIN32 */ - - 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_Mutex lock_; -#else - ACE_TCHAR name_[ACE_UNIQUE_NAME_LEN]; - // If the user does not provide a name we generate a unique name in - // this buffer. - - const ACE_TCHAR *unique_name (void); - // Create and return the unique name. - - ACE_SV_Semaphore_Complex lock_; - // We need this to get the right semantics... -#endif /* ACE_WIN32 */ -}; - -class ACE_Export ACE_RW_Process_Mutex -{ - // = TITLE - // Wrapper for readers/writer locks that exist across processes. - // - // = DESCRIPTION - // Note that because this class uses the - // <ACE_File_Lock> as its implementation it only can be reliably - // used between separate processes, rather than threads in the - // same process. This isn't a limitation of ACE, it's simply - // the file lock semantics on UNIX and Win32. -public: - ACE_RW_Process_Mutex (const ACE_TCHAR *name = 0, - int flags = O_CREAT|O_RDWR); - // Create a readers/writer <Process_Mutex>, passing in the optional - // <name>. - - ~ACE_RW_Process_Mutex (void); - - int remove (void); - // Explicitly destroy the mutex. Note that only one thread should - // call this method since it doesn't protect against race - // conditions. - - int acquire (void); - // Acquire lock ownership (wait on queue if necessary). - - int tryacquire (void); - // Conditionally acquire lock (i.e., don't wait on queue). Returns - // -1 on failure. If we "failed" because someone else already had - // the lock, <errno> is set to <EBUSY>. - - int release (void); - // Release lock and unblock a thread at head of queue. - - int acquire_read (void); - // Acquire lock ownership (wait on queue if necessary). - - int acquire_write (void); - // Acquire lock ownership (wait on queue if necessary). - - int tryacquire_read (void); - // Conditionally acquire a lock (i.e., won't block). Returns -1 on - // failure. If we "failed" because someone else already had the - // lock, <errno> is set to <EBUSY>. - - int tryacquire_write (void); - // Conditionally acquire a lock (i.e., won't block). Returns -1 on - // failure. If we "failed" because someone else already had the - // lock, <errno> is set to <EBUSY>. - - const ACE_File_Lock &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_File_Lock lock_; - // We need this to get the readers/writer semantics... -}; - -class ACE_Export 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. - - ~ACE_Null_Barrier (void); - // Default dtor. - - 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: - // = 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 (const ACE_TCHAR * = 0); - ~ACE_Null_Mutex (void); - int remove (void); - - int acquire (void); - int tryacquire (void); - int release (void); - int acquire_write (void); - int tryacquire_write (void); - int acquire_read (void); - int tryacquire_read (void); - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -}; - -class ACE_Export ACE_Noop_Token : public ACE_Null_Mutex -{ -public: - int renew (int = 0, ACE_Time_Value * =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 -{ - // = 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 (const ACE_Null_Mutex &m, - const ACE_TCHAR * = 0, - void * = 0); - ~ACE_Null_Condition (void); - int remove (void); - int wait (ACE_Time_Value * = 0); - int signal (void); - int broadcast (void); - ACE_Null_Mutex &mutex (void); - - void dump (void) const; - // Dump the state of an object. - - // ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -protected: - ACE_Null_Mutex &mutex_; // Reference to mutex lock. - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Null_Condition &); - ACE_Null_Condition (const ACE_Null_Condition &); -}; - -#if defined (ACE_USES_OBSOLETE_GUARD_CLASSES) -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 class is obsolete and should be replaced by - // ACE_Guard<ACE_Null_Mutex>. -public: - ACE_Null_Mutex_Guard (ACE_Null_Mutex &); - ~ACE_Null_Mutex_Guard (void); - int remove (void); - int locked (void); - int acquire (void); - int tryacquire (void); - int release (void); - void dump (void) const; - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Null_Mutex_Guard &); - ACE_Null_Mutex_Guard (const ACE_Null_Mutex_Guard &); -}; -#endif /* ACE_USES_OBSOLETE_GUARD_CLASSES */ - -class ACE_Export 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. - - ~ACE_TSS_Adapter (void); - // Default dtor. - - 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, - const ACE_TCHAR *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. Note that only one thread - // should call this method since it doesn't protect against race - // conditions. - - ACE_event_t handle (void) const; - // Underlying handle to event. - - void handle (ACE_event_t new_handle); - // Set the underlying handle to event. Note that this method assumes - // ownership of the <handle> and will close it down in <remove>. If - // you want the <handle> to stay open when <remove> is called make - // sure to call <dup> on the <handle> before closing it. You are - // responsible for the closing the existing <handle> before - // overwriting it. - - 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 - -protected: - ACE_event_t handle_; - // The underlying handle. - - int removed_; - // Keeps track of whether <remove> has been called yet to avoid - // multiple <remove> calls, e.g., explicitly and implicitly in the - // destructor. This flag isn't protected by a lock, so make sure - // that you don't have multiple threads simultaneously calling - // <remove> on the same object, which is a bad idea anyway... - -private: - // = Prevent copying. - ACE_Event (const ACE_Event& event); - const ACE_Event &operator= (const ACE_Event &rhs); -}; - -class ACE_Export ACE_Manual_Event : public ACE_Event -{ - // = TITLE - // Manual Events. - // - // = DESCRIPTION - // Specialization of Event mechanism which wakes up all waiting - // threads on signal() -public: - ACE_Manual_Event (int initial_state = 0, - int type = USYNC_THREAD, - const ACE_TCHAR *name = 0, - void *arg = 0); - // constructor which will create manual event - - ~ACE_Manual_Event (void); - // Default dtor. - - 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 one waiting - // thread on signal() -public: - ACE_Auto_Event (int initial_state = 0, - int type = USYNC_THREAD, - const ACE_TCHAR *name = 0, - void *arg = 0); - // constructor which will create auto event - - ~ACE_Auto_Event (void); - // Default dtor. - - void dump (void) const; - // Dump the state of an object. - - ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks -}; - -// ACE platform supports some form of threading. -#if !defined (ACE_HAS_THREADS) -class ACE_Barrier -{ - // = TITLE - // This is a no-op to make ACE "syntactically consistent." -public: - ACE_Barrier (u_int, const ACE_TCHAR * = 0, void * = 0) {} - ~ACE_Barrier (void) {} - int wait (void) { ACE_NOTSUP_RETURN (-1); } - void dump (void) const {} -}; -#else -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. - // - // ACE_Thread_Mutex is recursive on some platforms (like - // Win32). However, on most platforms (like Solaris) it is not - // recursive. To be totally safe and portable, developers - // should use <ACE_Recursive_Thread_Mutex> when they need a - // recursive mutex. - friend class ACE_Condition_Thread_Mutex; -public: - ACE_Thread_Mutex (const ACE_TCHAR *name = 0, - ACE_mutexattr_t *attributes = 0); - // Constructor. - - ~ACE_Thread_Mutex (void); - // Implicitly destroy the mutex. - - int remove (void); - // Explicitly destroy the mutex. Note that only one thread should - // call this method since it doesn't protect against race - // conditions. - - int acquire (void); - // Acquire lock ownership (wait on queue if necessary). - - int tryacquire (void); - // Conditionally acquire lock (i.e., don't wait on queue). Returns - // -1 on failure. If we "failed" because someone else already had - // the lock, <errno> is set to <EBUSY>. - - int release (void); - // Release lock and unblock a thread at head of queue. - - int acquire_read (void); - // Acquire mutex ownership. This calls <acquire> and is only here - // to make the <ACE_Thread_Mutex> interface consistent with the - // other synchronization APIs. - - int acquire_write (void); - // Acquire mutex ownership. This calls <acquire> and is only here - // to make the <ACE_Thread_Mutex> interface consistent with the - // other synchronization APIs. - - int tryacquire_read (void); - // Conditionally acquire mutex (i.e., won't block). This calls - // <tryacquire> and is only here to make the <ACE_Thread_Mutex> - // interface consistent with the other synchronization APIs. - // Returns -1 on failure. If we "failed" because someone else - // already had the lock, <errno> is set to <EBUSY>. - - int tryacquire_write (void); - // Conditionally acquire mutex (i.e., won't block). This calls - // <tryacquire> and is only here to make the <ACE_Thread_Mutex> - // interface consistent with the other synchronization APIs. - // Returns -1 on failure. If we "failed" because someone else - // already had the lock, <errno> is set to <EBUSY>. - - 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. - - // protected: - ACE_thread_mutex_t lock_; - // Mutex type that supports single-process locking efficiently. - - int removed_; - // Keeps track of whether <remove> has been called yet to avoid - // multiple <remove> calls, e.g., explicitly and implicitly in the - // destructor. This flag isn't protected by a lock, so make sure - // that you don't have multiple threads simultaneously calling - // <remove> on the same object, which is a bad idea anyway... - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Thread_Mutex &); - ACE_Thread_Mutex (const ACE_Thread_Mutex &); -}; - -#if defined (ACE_USES_OBSOLETE_GUARD_CLASSES) -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_Thread_Mutex>. - // - // = DESCRIPTION - // This class is obsolete and should be replaced by - // ACE_Guard<ACE_Thread_Mutex>. -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. Note that only one thread should - // call this method since it doesn't protect against race - // conditions. - - int acquire (void); - // Explicitly acquire the lock. - - int tryacquire (void); - // Conditionally acquire the lock (i.e., won't block). Returns -1 - // on failure. If we "failed" because someone else already had the - // lock, <errno> is set to <EBUSY>. - - 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. - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Thread_Mutex_Guard &); - ACE_Thread_Mutex_Guard (const ACE_Thread_Mutex_Guard &); -}; -#endif /* ACE_USES_OBSOLETE_GUARD_CLASSES */ - -class ACE_Export ACE_Condition_Attributes -{ -public: - ACE_Condition_Attributes (int type = ACE_DEFAULT_SYNCH_TYPE); - // Constructor - - ~ACE_Condition_Attributes (void); - // Destructor - -private: - friend class ACE_Condition_Thread_Mutex; - - ACE_condattr_t attributes_; - // The attributes - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Condition_Attributes &); - ACE_Condition_Attributes (const ACE_Condition_Attributes &); -}; - -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. - // - // A condition variable enables threads to atomically block and - // test the condition under the protection of a mutual exclu- - // sion lock (mutex) until the condition is satisfied. That is, - // the mutex must have been held by the thread before calling - // wait or signal on the condition. If the condition is false, - // a thread blocks on a condition variable and atomically - // releases the mutex that is waiting for the condition to - // change. If another thread changes the condition, it may wake - // up waiting threads by signaling the associated condition - // variable. The waiting threads, upon awakening, reacquire the - // mutex and re-evaluate the condition. - // - // = 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, - const ACE_TCHAR *name = 0, - void *arg = 0); - // Initialize the condition variable. - - ACE_Condition_Thread_Mutex (const ACE_Thread_Mutex &m, - ACE_Condition_Attributes &attributes, - const ACE_TCHAR *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. Note that only one - // thread should call this method since it doesn't protect against - // race conditions. - - 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. - -protected: - ACE_cond_t cond_; - // Condition variable. - - ACE_Thread_Mutex &mutex_; - // Reference to mutex lock. - - int removed_; - // Keeps track of whether <remove> has been called yet to avoid - // multiple <remove> calls, e.g., explicitly and implicitly in the - // destructor. This flag isn't protected by a lock, so make sure - // that you don't have multiple threads simultaneously calling - // <remove> on the same object, which is a bad idea anyway... - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Condition_Thread_Mutex &); - ACE_Condition_Thread_Mutex (const ACE_Condition_Thread_Mutex &); -}; - -class ACE_Export ACE_Recursive_Thread_Mutex -{ - // = TITLE - // Implement a C++ wrapper that allows nested acquisition and - // release of a mutex that occurs in the same thread. -public: - ACE_Recursive_Thread_Mutex (const ACE_TCHAR *name = 0, - ACE_mutexattr_t *arg = 0); - // Initialize a recursive mutex. - - ~ACE_Recursive_Thread_Mutex (void); - // Implicitly release a recursive mutex. - - int remove (void); - // Implicitly release a recursive mutex. Note that only one thread - // should call this method since it doesn't protect against race - // conditions. - - 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). - // Returns -1 on failure. If we "failed" because someone else - // already had the lock, <errno> is set to <EBUSY>. - - int acquire_read (void); - // Acquire mutex ownership. This calls <acquire> and is only - // here to make the <ACE_Recusive_Thread_Mutex> interface consistent - // with the other synchronization APIs. - - int acquire_write (void); - // Acquire mutex ownership. This calls <acquire> and is only - // here to make the <ACE_Recusive_Thread_Mutex> interface consistent - // with the other synchronization APIs. - - int tryacquire_read (void); - // Conditionally acquire mutex (i.e., won't block). This calls - // <tryacquire> and is only here to make the - // <ACE_Recusive_Thread_Mutex> interface consistent with the other - // synchronization APIs. Returns -1 on failure. If we "failed" - // because someone else already had the lock, <errno> is set to - // <EBUSY>. - - int tryacquire_write (void); - // Conditionally acquire mutex (i.e., won't block). This calls - // <tryacquire> and is only here to make the - // <ACE_Recusive_Thread_Mutex> interface consistent with the other - // synchronization APIs. Returns -1 on failure. If we "failed" - // because someone else already had the lock, <errno> is set to - // <EBUSY>. - - 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. - -protected: - // = This method should *not* be public (they hold no locks...) - void set_thread_id (ACE_thread_t t); - - ACE_recursive_thread_mutex_t recursive_mutex_; - // Recursive mutex. - - int removed_; - // Keeps track of whether <remove> has been called yet to avoid - // multiple <remove> calls, e.g., explicitly and implicitly in the - // destructor. This flag isn't protected by a lock, so make sure - // that you don't have multiple threads simultaneously calling - // <remove> on the same object, which is a bad idea anyway... - -private: - // = 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 (const ACE_TCHAR *name = 0, - void *arg = 0); - - ~ACE_RW_Thread_Mutex (void); - // Default dtor. - - int tryacquire_write_upgrade (void); - // Conditionally upgrade a read lock to a write lock. This only - // works if there are no other readers present, in which case the - // method returns 0. Otherwise, the method returns -1 and sets - // <errno> to <EBUSY>. Note that the caller of this method *must* - // already possess this lock as a read lock (but this condition is - // not checked by the current implementation). - - 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 one process. -public: - ACE_Thread_Semaphore (u_int count = 1, // By default make this unlocked. - const ACE_TCHAR *name = 0, - void * = 0, - int max = 0x7FFFFFFF); - // Initialize the semaphore, with an initial value of <count>, - // maximum value of <max>, and unlocked by default. - - ~ACE_Thread_Semaphore (void); - // Default dtor. - - 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, - const ACE_TCHAR *name = 0, - void *arg = 0); - - ~ACE_Sub_Barrier (void); - - 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 of (one round of) a task, which is known as - // "barrier synchronization". The implementation uses a - // "sub-barrier generation numbering" scheme to avoid overhead - // and to ensure that all threads wait to leave 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, - const ACE_TCHAR *name = 0, - void *arg = 0); - // Initialize the barrier to synchronize <count> threads. - - ~ACE_Barrier (void); - // Default dtor. - - 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. - -protected: - 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). - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Barrier &); - ACE_Barrier (const ACE_Barrier &); -}; - -#if 0 -// The following two classes are commented out since there doesn't -// appear to be a portable and robust means of implementing this -// functionality across platforms. If you know of a portable and -// robust way to implement this functionality please let us know. - -class ACE_Export ACE_Process_Condition -{ - // = TITLE - // ACE_Condition variable wrapper that works across processes. -public: - ACE_Process_Condition (MUTEX &m, const ACE_TCHAR *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 /* 0 */ - -#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, const ACE_TCHAR *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, const ACE_TCHAR *name = 0); - // Create a Thread_Barrier, passing in the optional <name>. - - ~ACE_Thread_Barrier (void); - // Default dtor. - - 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" - -template <class ACE_LOCK> -class ACE_Guard; - -ACE_TEMPLATE_SPECIALIZATION -class ACE_Export ACE_Guard<ACE_Null_Mutex> -{ - // = TITLE - // Template specialization of <ACE_Guard> for the - // <ACE_Null_Mutex>. - // - // = DESCRIPTION - // This specialization is useful since it helps to speedup - // performance of the "Null_Mutex" considerably. -public: - // = Initialization and termination methods. - ACE_Guard (ACE_Null_Mutex &) {} - ACE_Guard (ACE_Null_Mutex &, int) {} -#if defined (ACE_WIN32) - ~ACE_Guard (void) {} -#endif /* ACE_WIN32 */ - - int acquire (void) { return 0; } - int tryacquire (void) { return 0; } - int release (void) { return 0; } - int locked (void) { return 1; } - int remove (void) { return 0; } - void dump (void) const {} - -private: - // = Prevent assignment and initialization. - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Guard<ACE_Null_Mutex> &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Guard (const ACE_Guard<ACE_Null_Mutex> &)) -}; - -template <class ACE_LOCK> -class ACE_Write_Guard; - -ACE_TEMPLATE_SPECIALIZATION -class ACE_Export ACE_Write_Guard<ACE_Null_Mutex> : public ACE_Guard<ACE_Null_Mutex> -{ - // = TITLE -public: - ACE_Write_Guard (ACE_Null_Mutex &m) - : ACE_Guard<ACE_Null_Mutex> (m) {} - ACE_Write_Guard (ACE_Null_Mutex &m, int blocked) - : ACE_Guard<ACE_Null_Mutex> (m, blocked) {} - - int acquire_write (void) { return 0; } - int acquire (void) { return 0; } - int tryacquire_write (void) { return 0; } - int tryacquire (void) { return 0; } - void dump (void) const {} -}; - -template <class ACE_LOCK> -class ACE_Read_Guard; - -ACE_TEMPLATE_SPECIALIZATION -class ACE_Export ACE_Read_Guard<ACE_Null_Mutex> : public ACE_Guard<ACE_Null_Mutex> -{ - // = TITLE -public: - ACE_Read_Guard (ACE_Null_Mutex &m) - : ACE_Guard<ACE_Null_Mutex> (m) {} - ACE_Read_Guard (ACE_Null_Mutex &m, int blocked) - : ACE_Guard<ACE_Null_Mutex> (m, blocked) {} - - int acquire_write (void) { return 0; } - int acquire (void) { return 0; } - int tryacquire_write (void) { return 0; } - int tryacquire (void) { return 0; } - void dump (void) const {} -}; - -#include "ace/post.h" -#endif /* ACE_SYNCH_H */ |