diff options
Diffstat (limited to 'ace/Future.cpp')
| -rw-r--r-- | ace/Future.cpp | 100 |
1 files changed, 51 insertions, 49 deletions
diff --git a/ace/Future.cpp b/ace/Future.cpp index d240a9adc42..2e77d001ba4 100644 --- a/ace/Future.cpp +++ b/ace/Future.cpp @@ -17,8 +17,8 @@ ACE_Future_Rep<T>::dump (void) const { ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, - "ref_count_ = %d\n", - (int) this->ref_count_)); + "ref_count_ = %d\n", + (int) this->ref_count_)); ACE_DEBUG ((LM_INFO,"value_: \n")); if (this->value_) ACE_DEBUG ((LM_DEBUG," (NON-NULL)\n")); @@ -36,35 +36,58 @@ template <class T> ACE_Future_Rep<T> * ACE_Future_Rep<T>::create (void) { // Yes set ref count to zero. - ACE_NEW_RETURN (((ACE_Future<T> *) this)->future_rep_, ACE_Future_Rep<T>, 0); + return new ACE_Future_Rep<T>(); } template <class T> ACE_Future_Rep<T> * -ACE_Future_Rep<T>::attach (ACE_Future_Rep<T> *rep) +ACE_Future_Rep<T>::attach (ACE_Future_Rep<T>*& rep) { ACE_ASSERT (rep != 0); // Use value_ready_mutex_ for both condition and ref count management - ACE_MT (ACE_GUARD (ACE_Thread_Mutex, r_mon, (ACE_Thread_Mutex &) rep->value_ready_mutex_)); + ACE_MT (ACE_Guard<ACE_Thread_Mutex> r_mon(rep->value_ready_mutex_)); ++rep->ref_count_; return rep; } template <class T> void -ACE_Future_Rep<T>::detach (ACE_Future_Rep<T> *rep) +ACE_Future_Rep<T>::detach (ACE_Future_Rep<T>*& rep) { ACE_ASSERT(rep != 0); // Use value_ready_mutex_ for both condition and ref count management - ACE_MT (ACE_GUARD (ACE_Thread_Mutex, r_mon, (ACE_Thread_Mutex &) rep->value_ready_mutex_)); + ACE_MT (ACE_GUARD (ACE_Thread_Mutex, r_mon, rep->value_ready_mutex_)); if (rep->ref_count_-- == 0) { r_mon.release (); // We do not need the lock when deleting the representation. - // There should be no side effects from deleting rep. + // There should be no side effects from deleting rep and we don + // not want to release a deleted mutex. delete rep; } } +template <class T> void +ACE_Future_Rep<T>::assign (ACE_Future_Rep<T>*& rep, ACE_Future_Rep<T>* new_rep) +{ + ACE_ASSERT(rep != 0); + ACE_ASSERT(new_rep != 0); + // Use value_ready_mutex_ for both condition and ref count management + ACE_MT (ACE_GUARD (ACE_Thread_Mutex, r_mon, rep->value_ready_mutex_)); + + ACE_Future_Rep<T>* old = rep; + rep = new_rep; + + // detached old last for exception safety + if (old->ref_count_-- == 0) + { + r_mon.release (); + // We do not need the lock when deleting the representation. + // There should be no side effects from deleting rep and we don + // not want to release a deleted mutex. + delete old; + } +} + template <class T> ACE_Future_Rep<T>::ACE_Future_Rep (void) : value_ (0), @@ -96,7 +119,7 @@ ACE_Future_Rep<T>::set (const T &r) // Double-checked locking pattern to avoid multiple allocations. if (this->value_ == 0) - ACE_NEW_RETURN (this->value_, T (r), -1); + ACE_NEW_RETURN (this->value_, T (r), -1); // Signal all the waiting threads. return this->value_ready_.broadcast (); @@ -108,7 +131,7 @@ ACE_Future_Rep<T>::set (const T &r) template <class T> int ACE_Future_Rep<T>::get (T &value, - ACE_Time_Value *tv) + ACE_Time_Value *tv) { // If the value is already produced, return it. if (this->value_ == 0) @@ -119,9 +142,9 @@ ACE_Future_Rep<T>::get (T &value, // producer writes to it. while (this->value_ == 0) - // Perform a timed wait. - if (this->value_ready_.wait (tv) == -1) - return -1; + // Perform a timed wait. + if (this->value_ready_.wait (tv) == -1) + return -1; // Destructor releases the lock. } @@ -145,11 +168,11 @@ ACE_Future_Rep<T>::operator T () // Wait ``forever.'' while (this->value_ == 0) - if (this->value_ready_.wait () == -1) - // What to do in this case since we've got to indicate - // failure somehow? Exceptions would be nice, but they're - // not portable... - return 0; + if (this->value_ready_.wait () == -1) + // What to do in this case since we've got to indicate + // failure somehow? Exceptions would be nice, but they're + // not portable... + return 0; // Destructor releases the mutex } @@ -174,15 +197,13 @@ ACE_Future<T>::ACE_Future (const T &r) : future_rep_ (Future_Rep::create ()) { ACE_DEBUG ((LM_DEBUG," (%t) funny constructor\n")); - ACE_MT (ACE_GUARD (ACE_Thread_Mutex, ace_mon, this->mutex_)); this->future_rep_->set (r); } template <class T> ACE_Future<T>::~ACE_Future (void) { - ACE_MT (ACE_GUARD (ACE_Thread_Mutex, ace_mon, this->mutex_)); - Future_Rep::detach (future_rep_); + FUTURE_REP::detach (future_rep_); } template <class T> int @@ -204,17 +225,13 @@ ACE_Future<T>::cancel (const T &r) return this->future_rep_->set (r); } -template <class T> void +template <class T> int ACE_Future<T>::cancel (void) -{ - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->mutex_, -1)); - +{ // If this ACE_Future is already attached to a ACE_Future_Rep, // detach it (maybe delete the ACE_Future_Rep). - Future_Rep *new_rep (Future_Rep::create ()); - Future_Rep *old_rep (this->future_rep_); - this->future_rep_ = new_rep; - Future_Rep::detach (old_rep); + FUTURE_REP::assign (this->future_rep_, FUTURE_REP::create ()); + return 0; } template <class T> int @@ -233,8 +250,6 @@ ACE_Future<T>::ready (void) template <class T> int ACE_Future<T>::get (T &value, ACE_Time_Value *tv) { - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->mutex_, -1)); - // We return the ACE_Future_rep. return this->future_rep_->get (value, tv); } @@ -258,27 +273,16 @@ ACE_Future<T>::operator T () } template <class T> void -ACE_Future<T>::operator = (const ACE_Future<T> &r) +ACE_Future<T>::operator = (const ACE_Future<T> &rhs) { // assignment: // // bind <this> to the same <ACE_Future_Rep> as <r>. - Future_Rep *new_rep = 0; - { - // This will work if &r == this - // and if not it will keep the r.mutex_ locked for as little - // time as possible - ACE_MT (ACE_GUARD (ACE_Thread_Mutex, ace_mon, r.mutex_)); - new_rep = Future_Rep::attach (r.future_rep_); - } - - ACE_MT (ACE_GUARD (ACE_Thread_Mutex, ace_mon, this->mutex_)); - - Future_Rep *old_rep = this->future_rep_; - this->future_rep_ = new_rep; - // Setup the new rep before detaching old rep for exception safety. - Future_Rep::detach (old_rep); + // This will work if &r == this, by first increasing the ref count + ACE_Future<T> &r = ( ACE_Future<T> &) rhs; + FUTURE_REP::assign (this->future_rep_, + FUTURE_REP::attach (r.future_rep_)); } template <class T> void @@ -288,8 +292,6 @@ ACE_Future<T>::dump (void) const if (this->future_rep_) this->future_rep_->dump (); - - this->mutex_.dump (); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); } |