diff options
Diffstat (limited to 'ace/Synch.cpp')
| -rw-r--r-- | ace/Synch.cpp | 887 |
1 files changed, 0 insertions, 887 deletions
diff --git a/ace/Synch.cpp b/ace/Synch.cpp deleted file mode 100644 index eb1a2f159e2..00000000000 --- a/ace/Synch.cpp +++ /dev/null @@ -1,887 +0,0 @@ -// Synch.cpp -// $Id$ - -#if !defined (ACE_SYNCH_C) -#define ACE_SYNCH_C - -#define ACE_BUILD_DLL -#include "ace/Thread.h" -#include "ace/Synch.h" -#include "ace/Time_Value.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Synch.i" -#endif /* __ACE_INLINE__ */ - -ACE_ALLOC_HOOK_DEFINE(ACE_Null_Mutex) -ACE_ALLOC_HOOK_DEFINE(ACE_File_Lock) -ACE_ALLOC_HOOK_DEFINE(ACE_RW_Process_Mutex) -ACE_ALLOC_HOOK_DEFINE(ACE_Process_Mutex) - -ACE_TSS_Adapter::ACE_TSS_Adapter (void *object, ACE_THR_DEST f) - : ts_obj_ (object), - func_ (f) -{ - // ACE_TRACE ("ACE_TSS_Adapter::ACE_TSS_Adapter"); -} - -void -ACE_TSS_Adapter::cleanup (void) -{ - // ACE_TRACE ("ACE_TSS_Adapter::~ACE_TSS_Adapter"); - (*this->func_)(this->ts_obj_); // call cleanup routine for ts_obj_ -} - -extern "C" void -ACE_TSS_C_cleanup (void *object) -{ - // ACE_TRACE ("ACE_TSS_C_cleanup"); - if (object != 0) - { - ACE_TSS_Adapter *tss_adapter = (ACE_TSS_Adapter *) object; - // Perform cleanup on the real TS object. - tss_adapter->cleanup (); - // Delete the adapter object. - delete tss_adapter; - } -} - -void -ACE_Process_Mutex::dump (void) const -{ -// ACE_TRACE ("ACE_Process_Mutex::dump"); - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->lock_.dump (); - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_Process_Mutex::ACE_Process_Mutex (LPCTSTR name, void *arg) -#if defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM) - : lock_ (USYNC_PROCESS, name, arg) -#else - : lock_ (name) -#endif /* ACE_WIN32 || ACE_HAS_POSIX_SEM */ -{ - name = name; - arg = arg; -// ACE_TRACE ("ACE_Process_Mutex::ACE_Process_Mutex"); -} - -ACE_Process_Mutex::~ACE_Process_Mutex (void) -{ -} - -// Explicitly destroy the mutex. -int -ACE_Process_Mutex::remove (void) -{ - return this->lock_.remove (); -} - -// Acquire lock ownership (wait on priority queue if necessary). -int -ACE_Process_Mutex::acquire (void) -{ - return this->lock_.acquire (); -} - -// Conditionally acquire lock (i.e., don't wait on queue). -int -ACE_Process_Mutex::tryacquire (void) -{ - return this->lock_.tryacquire (); -} - -// Release lock and unblock a thread at head of priority queue. -int -ACE_Process_Mutex::release (void) -{ - return this->lock_.release (); -} - -// Acquire lock ownership (wait on priority queue if necessary). -int -ACE_Process_Mutex::acquire_read (void) -{ - return this->lock_.acquire_read (); -} - -// Acquire lock ownership (wait on priority queue if necessary). -int ACE_Process_Mutex::acquire_write (void) -{ - return this->lock_.acquire_write (); -} - -// Conditionally acquire a lock (i.e., won't block). -int -ACE_Process_Mutex::tryacquire_read (void) -{ - return this->lock_.tryacquire_read (); -} - -// Conditionally acquire a lock (i.e., won't block). -int -ACE_Process_Mutex::tryacquire_write (void) -{ - return this->lock_.tryacquire_write (); -} - -ACE_RW_Process_Mutex::ACE_RW_Process_Mutex (LPCTSTR name, - void *arg) - : ACE_Process_Mutex (name, arg) -{ -// ACE_TRACE ("ACE_RW_Process_Mutex::ACE_RW_Process_Mutex"); -} - -void -ACE_RW_Process_Mutex::dump (void) const -{ -// ACE_TRACE ("ACE_RW_Process_Mutex::dump"); - ACE_Process_Mutex::dump (); -} - -void -ACE_RW_Mutex::dump (void) const -{ -// ACE_TRACE ("ACE_RW_Mutex::dump"); - - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACE_DEBUG ((LM_DEBUG, "\n")); - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_RW_Mutex::ACE_RW_Mutex (int type, LPCTSTR name, void *arg) -{ -// ACE_TRACE ("ACE_RW_Mutex::ACE_RW_Mutex"); - if (ACE_OS::rwlock_init (&this->lock_, type, name, arg) != 0) - ACE_ERROR ((LM_ERROR, "%p\n", "ACE_RW_Mutex::~ACE_RW_Mutex")); -} - -ACE_RW_Mutex::~ACE_RW_Mutex (void) -{ -// ACE_TRACE ("ACE_RW_Mutex::~ACE_RW_Mutex"); - if (this->remove () == -1) - ACE_ERROR ((LM_ERROR, "%p\n", "ACE_RW_Mutex::~ACE_RW_Mutex")); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Semaphore) - -void -ACE_Semaphore::dump (void) const -{ -// ACE_TRACE ("ACE_Semaphore::dump"); - - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACE_DEBUG ((LM_DEBUG, "\n")); - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_Semaphore::ACE_Semaphore (u_int count, - int type, - LPCTSTR name, - void *arg, - int max) -{ -// ACE_TRACE ("ACE_Semaphore::ACE_Semaphore"); - if (ACE_OS::sema_init (&this->semaphore_, count, type, - name, arg, max) != 0) - ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Semaphore::ACE_Semaphore")); -} - -ACE_Semaphore::~ACE_Semaphore (void) -{ -// ACE_TRACE ("ACE_Semaphore::~ACE_Semaphore"); - this->remove (); -} - -void -ACE_File_Lock::dump (void) const -{ -// ACE_TRACE ("ACE_File_Lock::dump"); - - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->lock_.dump (); - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_File_Lock::ACE_File_Lock (ACE_HANDLE h) -{ -// ACE_TRACE ("ACE_File_Lock::ACE_File_Lock"); - if (ACE_OS::flock_init (&this->lock_) == -1) - ACE_ERROR ((LM_ERROR, "%p\n", "ACE_File_Lock::ACE_File_Lock")); - this->set_handle (h); -} - -ACE_File_Lock::ACE_File_Lock (LPCTSTR name, - int flags, - mode_t perms) -{ -// ACE_TRACE ("ACE_File_Lock::ACE_File_Lock"); - - if (ACE_OS::flock_init (&this->lock_, flags, name, perms) == -1) - ACE_ERROR ((LM_ERROR, "%p\n", "ACE_File_Lock::ACE_File_Lock")); -} - -ACE_File_Lock::~ACE_File_Lock (void) -{ -// ACE_TRACE ("ACE_File_Lock::~ACE_File_Lock"); - if (this->remove () == -1) - ACE_ERROR ((LM_ERROR, "%p\n", "ACE_File_Lock::~ACE_File_Lock")); -} - -void -ACE_Process_Semaphore::dump (void) const -{ -// ACE_TRACE ("ACE_Process_Semaphore::dump"); - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->lock_.dump (); - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_Process_Semaphore::ACE_Process_Semaphore (u_int count, - LPCTSTR name, - void *arg, - int max) -#if defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM) - : lock_ (count, USYNC_PROCESS, name, arg, max) -#else - : lock_ (name, ACE_SV_Semaphore_Complex::ACE_CREATE, count) -#endif /* ACE_WIN32 || ACE_HAS_POSIX_SEM */ -{ - arg = arg; - max = max; -// ACE_TRACE ("ACE_Process_Semaphore::ACE_Process_Semaphore"); -} - -ACE_Process_Semaphore::~ACE_Process_Semaphore (void) -{ -// ACE_TRACE ("ACE_Process_Semaphore::~ACE_Process_Semaphore"); -} - -// Explicitly destroy the semaphore. - -int -ACE_Process_Semaphore::remove (void) -{ -// ACE_TRACE ("ACE_Process_Semaphore::remove"); - return this->lock_.remove (); -} - -// Block the thread until the semaphore count becomes -// greater than 0, then decrement it. - -int -ACE_Process_Semaphore::acquire (void) -{ -// ACE_TRACE ("ACE_Process_Semaphore::acquire"); - return this->lock_.acquire (); -} - -// Conditionally decrement the semaphore if count is greater -// than 0 (i.e., won't block). - -int -ACE_Process_Semaphore::tryacquire (void) -{ -// ACE_TRACE ("ACE_Process_Semaphore::tryacquire"); - return this->lock_.tryacquire (); -} - -// Increment the semaphore, potentially unblocking -// a waiting thread. - -int -ACE_Process_Semaphore::release (void) -{ -// ACE_TRACE ("ACE_Process_Semaphore::release"); - return this->lock_.release (); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Mutex) - -void -ACE_Mutex::dump (void) const -{ -// ACE_TRACE ("ACE_Mutex::dump"); - - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACE_DEBUG ((LM_DEBUG, "\n")); - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_Mutex::ACE_Mutex (int type, LPCTSTR name, void *arg) -{ -// ACE_TRACE ("ACE_Mutex::ACE_Mutex"); - - if (ACE_OS::mutex_init (&this->lock_, type, name, arg) != 0) - ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Mutex::ACE_Mutex")); -} - -ACE_Mutex::~ACE_Mutex (void) -{ -// ACE_TRACE ("ACE_Mutex::~ACE_Mutex"); - if (this->remove () != 0) - ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Mutex::~ACE_Mutex")); -} - -ACE_Event::ACE_Event (int manual_reset, - int initial_state, - int type, - LPCTSTR name, - void *arg) -{ - if (ACE_OS::event_init (&this->handle_, - manual_reset, - initial_state, - type, - name, - arg) != 0) - ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Event::ACE_Event")); -} - -ACE_Event::~ACE_Event (void) -{ - if (this->remove () != 0) - ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Event::~ACE_Event")); -} - -int -ACE_Event::remove (void) -{ - return ACE_OS::event_destroy (&this->handle_); -} - -ACE_event_t -ACE_Event::handle (void) const -{ - return this->handle_; -} - -int -ACE_Event::wait (void) -{ - return ACE_OS::event_wait (&this->handle_); -} - -int -ACE_Event::wait (const ACE_Time_Value *abstime) -{ - return ACE_OS::event_timedwait (&this->handle_, - (ACE_Time_Value *) abstime); -} - -int -ACE_Event::signal (void) -{ - return ACE_OS::event_signal (&this->handle_); -} - -int -ACE_Event::pulse (void) -{ - return ACE_OS::event_pulse (&this->handle_); -} - -int -ACE_Event::reset (void) -{ - return ACE_OS::event_reset (&this->handle_); -} - -void -ACE_Event::dump (void) const -{ - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_Manual_Event::ACE_Manual_Event (int initial_state, - int type, - LPCTSTR name, - void *arg) - : ACE_Event (1, - initial_state, - type, - name, - arg) -{ -} - -void -ACE_Manual_Event::dump (void) const -{ - ACE_Event::dump (); -} - -ACE_Auto_Event::ACE_Auto_Event (int initial_state, - int type, - LPCTSTR name, - void *arg) - : ACE_Event (0, - initial_state, - type, - name, - arg) -{ -} - -void -ACE_Auto_Event::dump (void) const -{ - ACE_Event::dump (); -} - -#if defined (ACE_HAS_THREADS) - -ACE_ALLOC_HOOK_DEFINE(ACE_Recursive_Thread_Mutex) -ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Mutex_Guard) - -void -ACE_Thread_Semaphore::dump (void) const -{ -// ACE_TRACE ("ACE_Thread_Semaphore::dump"); - - ACE_Semaphore::dump (); -} - -ACE_Thread_Semaphore::ACE_Thread_Semaphore (u_int count, - LPCTSTR name, - void *arg, - int max) - : ACE_Semaphore (count, USYNC_THREAD, name, arg, max) -{ -// ACE_TRACE ("ACE_Thread_Semaphore::ACE_Thread_Semaphore"); -} - -void -ACE_Thread_Mutex_Guard::dump (void) const -{ -// ACE_TRACE ("ACE_Thread_Mutex_Guard::dump"); - - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACE_DEBUG ((LM_DEBUG, "\n")); - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_thread_t -ACE_Recursive_Thread_Mutex::get_thread_id (void) -{ -// ACE_TRACE ("ACE_Recursive_Thread_Mutex::get_thread_id"); - ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->nesting_mutex_, ACE_OS::NULL_thread); - return this->owner_id_; -} - -int -ACE_Recursive_Thread_Mutex::get_nesting_level (void) -{ -// ACE_TRACE ("ACE_Recursive_Thread_Mutex::get_nesting_level"); - ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->nesting_mutex_, -1); - return this->nesting_level_; -} - -ACE_Recursive_Thread_Mutex::ACE_Recursive_Thread_Mutex (const ACE_Recursive_Thread_Mutex &rm) - : lock_available_ ((ACE_Thread_Mutex &) rm.nesting_mutex_) -{ -} - -ACE_Recursive_Thread_Mutex::ACE_Recursive_Thread_Mutex (LPCTSTR name, - void *arg) - : nesting_mutex_ (name, arg), - lock_available_ (nesting_mutex_, name, arg), - nesting_level_ (0), - owner_id_ (ACE_OS::NULL_thread) -{ -#if defined (ACE_HAS_FSU_PTHREADS) -// Initialize FSU pthreads package. -// If called more than once, pthread_init does nothing -// and so does no harm. - pthread_init (); -#endif /* ACE_HAS_FSU_PTHREADS */ -// ACE_TRACE ("ACE_Recursive_Thread_Mutex::ACE_Recursive_Thread_Mutex"); -} - -ACE_Recursive_Thread_Mutex::~ACE_Recursive_Thread_Mutex (void) -{ -// ACE_TRACE ("ACE_Recursive_Thread_Mutex::~ACE_Recursive_Thread_Mutex"); -} - -int -ACE_Recursive_Thread_Mutex::acquire (void) -{ -// ACE_TRACE ("ACE_Recursive_Thread_Mutex::acquire"); - ACE_thread_t t_id = ACE_Thread::self (); - - ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->nesting_mutex_, -1); - - // If there's no contention, just grab the lock immediately. - if (this->nesting_level_ == 0) - { - this->set_thread_id (t_id); - this->nesting_level_ = 1; - } - // If we already own the lock, then increment the nesting level and - // proceed. - else if (ACE_OS::thr_equal (t_id, this->owner_id_)) - this->nesting_level_++; - else - { - // Wait until the nesting level has dropped to zero, - // at which point we can acquire the lock. - while (this->nesting_level_ > 0) - this->lock_available_.wait (); - - // Note that at this point the nesting_mutex_ is held... - - this->set_thread_id (t_id); - this->nesting_level_ = 1; - } - - return 0; -} - -int -ACE_Recursive_Thread_Mutex::release (void) -{ -// ACE_TRACE ("ACE_Recursive_Thread_Mutex::release"); - ACE_thread_t t_id = ACE_Thread::self (); - - // Automatically acquire mutex. - ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->nesting_mutex_, -1); - -#if !defined (ACE_NDEBUG) - if (this->nesting_level_ == 0 - || ACE_OS::thr_equal (t_id, this->owner_id_) == 0) - { - errno = EINVAL; - ACE_RETURN (-1); - } -#endif /* ACE_NDEBUG */ - - this->nesting_level_--; - if (this->nesting_level_ == 0) - { - // This may not be strictly necessary, but it does put the mutex - // into a known state... - this->set_thread_id (ACE_OS::NULL_thread); - - // Inform waiters that the lock is free. - this->lock_available_.signal (); - } - return 0; -} - -int -ACE_Recursive_Thread_Mutex::tryacquire (void) -{ -// ACE_TRACE ("ACE_Recursive_Thread_Mutex::tryacquire"); - ACE_thread_t t_id = ACE_Thread::self (); - - ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->nesting_mutex_, -1); - - // If there's no contention, just grab the lock immediately. - if (this->nesting_level_ == 0) - { - this->set_thread_id (t_id); - this->nesting_level_ = 1; - } - // If we already own the lock, then increment the nesting level and - // proceed. - else if (ACE_OS::thr_equal (t_id, this->owner_id_)) - this->nesting_level_++; - else - { - errno = EBUSY; - ACE_RETURN (-1); - } - return 0; -} - -void -ACE_Recursive_Thread_Mutex::dump (void) const -{ -// ACE_TRACE ("ACE_Recursive_Thread_Mutex::dump"); - - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->lock_available_.dump (); - this->nesting_mutex_.dump (); - ACE_DEBUG ((LM_DEBUG, "nesting_level_ = %d", this->nesting_level_)); -#if !defined (ACE_HAS_DCETHREADS) && !defined (ACE_HAS_PTHREADS) - ACE_DEBUG ((LM_DEBUG, "\nowner_id_ = %u", this->owner_id_)); -#else - ACE_DEBUG ((LM_DEBUG, "\n")); -#endif /* !ACE_HAS_DCETHREADS */ - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Condition_Thread_Mutex) - -void -ACE_Condition_Thread_Mutex::dump (void) const -{ -// ACE_TRACE ("ACE_Condition_Thread_Mutex::dump"); - - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACE_DEBUG ((LM_DEBUG, "\n")); -#if defined (ACE_WIN32) - ACE_DEBUG ((LM_DEBUG, - "waiters = %d\n", - this->cond_.waiters_)); -#endif /* ACE_WIN32 */ - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_Condition_Thread_Mutex::ACE_Condition_Thread_Mutex (const ACE_Thread_Mutex &m, - LPCTSTR name, - void *arg) - : mutex_ ((ACE_Thread_Mutex &) m) -{ -#if defined (ACE_HAS_FSU_PTHREADS) -// Initialize FSU pthreads package. -// If called more than once, pthread_init does nothing -// and so does no harm. - pthread_init (); -#endif /* ACE_HAS_FSU_PTHREADS */ - -// ACE_TRACE ("ACE_Condition_Thread_Mutex::ACE_Condition_Thread_Mutex"); - if (ACE_OS::cond_init (&this->cond_, USYNC_THREAD, name, arg) != 0) - ACE_ERROR ((LM_ERROR, "%p\n", - "ACE_Condition_Thread_Mutex::ACE_Condition_Thread_Mutex")); -} - -ACE_Condition_Thread_Mutex::~ACE_Condition_Thread_Mutex (void) -{ -// ACE_TRACE ("ACE_Condition_Thread_Mutex::~ACE_Condition_Thread_Mutex"); - if (this->remove () == -1) - ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Condition_Thread_Mutex::~ACE_Condition_Thread_Mutex")); -} - -// Peform an "alertable" timed wait. If the argument <abstime> == 0 -// then we do a regular <cond_wait>, else we do a timed wait for up to -// <abstime> using the <cond_timedwait> function. - -int -ACE_Condition_Thread_Mutex::wait (void) -{ -// ACE_TRACE ("ACE_Condition_Thread_Mutex::wait"); - ACE_thread_mutex_t &mutex = (ACE_thread_mutex_t &) this->mutex_.lock (); - - return ACE_OS::cond_wait (&this->cond_, &mutex); -} - -int -ACE_Condition_Thread_Mutex::wait (ACE_Thread_Mutex &mutex, - const ACE_Time_Value *abstime) -{ -// ACE_TRACE ("ACE_Condition<MUTEX>::wait"); - if (abstime == 0) - return this->wait (); - else - return ACE_OS::cond_timedwait (&this->cond_, - &mutex.lock_, - (ACE_Time_Value *) abstime); -} - -int -ACE_Condition_Thread_Mutex::wait (const ACE_Time_Value *abstime) -{ -// ACE_TRACE ("ACE_Condition_Thread_Mutex::wait"); - if (abstime == 0) - return this->wait (); - else - return this->wait (this->mutex_, abstime); -} - -int -ACE_Condition_Thread_Mutex::signal (void) -{ -// ACE_TRACE ("ACE_Condition_Thread_Mutex::signal"); - return ACE_OS::cond_signal (&this->cond_); -} - -int -ACE_Condition_Thread_Mutex::broadcast (void) -{ -// ACE_TRACE ("ACE_Condition_Thread_Mutex::broadcast"); - return ACE_OS::cond_broadcast (&this->cond_); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Sub_Barrier) - -void -ACE_Sub_Barrier::dump (void) const -{ -// ACE_TRACE ("ACE_Sub_Barrier::dump"); - - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->barrier_finished_.dump (); - ACE_DEBUG ((LM_DEBUG, "running_threads_ = %d", this->running_threads_)); - ACE_DEBUG ((LM_DEBUG, "\n")); - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_Sub_Barrier::ACE_Sub_Barrier (u_int count, - ACE_Thread_Mutex &lock, - LPCTSTR name, - void *arg) - : barrier_finished_ (lock, name, arg), - running_threads_ (count) -{ -// ACE_TRACE ("ACE_Sub_Barrier::ACE_Sub_Barrier"); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Barrier) -ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Barrier) -ACE_ALLOC_HOOK_DEFINE(ACE_Process_Barrier) - -void -ACE_Barrier::dump (void) const -{ -// ACE_TRACE ("ACE_Barrier::dump"); - - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->lock_.dump (); - ACE_DEBUG ((LM_DEBUG, "current_generation_ = %d", this->current_generation_)); - ACE_DEBUG ((LM_DEBUG, "\ncount_ = %d", this->count_)); - this->sub_barrier_1_.dump (); - this->sub_barrier_2_.dump (); - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_Barrier::ACE_Barrier (u_int count, - LPCTSTR name, - void *arg) - : lock_ (name, arg), - current_generation_ (0), - count_ (count), - sub_barrier_1_ (count, lock_, name, arg), - sub_barrier_2_ (count, lock_, name, arg) -{ -// ACE_TRACE ("ACE_Barrier::ACE_Barrier"); - this->sub_barrier_[0] = &this->sub_barrier_1_; - this->sub_barrier_[1] = &this->sub_barrier_2_; -} - -int -ACE_Barrier::wait (void) -{ -// ACE_TRACE ("ACE_Barrier::wait"); - ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); - - ACE_Sub_Barrier *sbp = - this->sub_barrier_[this->current_generation_]; - - // Check for shutdown... - if (sbp == 0) - return -1; - - if (sbp->running_threads_ == 1) - { - // We're the last running thread, so swap generations and tell - // all the threads waiting on the barrier to continue on their - // way. - - sbp->running_threads_ = this->count_; - // Swap generations. - this->current_generation_ = 1 - this->current_generation_; - sbp->barrier_finished_.broadcast (); - } - else - { - --sbp->running_threads_; - - // Block until all the other threads wait(). - while (sbp->running_threads_ != this->count_) - sbp->barrier_finished_.wait (); - } - - return 0; -} - -ACE_Thread_Barrier::ACE_Thread_Barrier (u_int count, LPCTSTR name) - : ACE_Barrier (count, name) -{ -// ACE_TRACE ("ACE_Thread_Barrier::ACE_Thread_Barrier"); -} - -void -ACE_Thread_Barrier::dump (void) const -{ -// ACE_TRACE ("ACE_Thread_Barrier::dump"); - ACE_Barrier::dump (); -} - -#if 0 -ACE_Process_Barrier::ACE_Process_Barrier (u_int count, LPCTSTR name) - : ACE_Barrier (count, USYNC_PROCESS, name) -{ -// ACE_TRACE ("ACE_Process_Barrier::ACE_Process_Barrier"); -} - -void -ACE_Process_Barrier::dump (void) const -{ -// ACE_TRACE ("ACE_Process_Barrier::dump"); - ACE_Barrier::dump (); -} - -template <class MUTEX> void -ACE_Process_Condition<MUTEX>::dump (void) const -{ -// ACE_TRACE ("ACE_Process_Condition<MUTEX>::dump"); - - ACE_Condition<MUTEX>::dump (); -} - -template <class MUTEX> -ACE_Process_Condition<MUTEX>::ACE_Process_Condition (MUTEX &m, - LPCTSTR name, - void *arg) - : ACE_Condition<MUTEX> (m, USYNC_PROCESS, name, arg) -{ -// ACE_TRACE ("ACE_Process_Condition<MUTEX>::ACE_Process_Condition"); -} -#endif /* 0 */ - -ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Mutex) - -void -ACE_Thread_Mutex::dump (void) const -{ -// ACE_TRACE ("ACE_Thread_Mutex::dump"); - - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACE_DEBUG ((LM_DEBUG, "\n")); - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -ACE_Thread_Mutex::~ACE_Thread_Mutex (void) -{ -// ACE_TRACE ("ACE_Thread_Mutex::~ACE_Thread_Mutex"); -} - -ACE_Thread_Mutex::ACE_Thread_Mutex (LPCTSTR name, void *arg) -{ -// ACE_TRACE ("ACE_Thread_Mutex::ACE_Thread_Mutex"); - - if (ACE_OS::thread_mutex_init (&this->lock_, USYNC_THREAD, name, arg) != 0) - ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Thread_Mutex::ACE_Thread_Mutex")); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_RW_Thread_Mutex) - -ACE_RW_Thread_Mutex::ACE_RW_Thread_Mutex (LPCTSTR name, - void *arg) - : ACE_RW_Mutex (USYNC_THREAD, name, arg) -{ -// ACE_TRACE ("ACE_RW_Thread_Mutex::ACE_RW_Thread_Mutex"); -} - -void -ACE_RW_Thread_Mutex::dump (void) const -{ -// ACE_TRACE ("ACE_RW_Thread_Mutex::dump"); - ACE_RW_Mutex::dump (); -} - -#endif /* ACE_HAS_THREADS */ -#endif /* ACE_SYNCH_C */ |