ACE/ace/Future.cpp

   1 #ifndef ACE_FUTURE_CPP
   2 #define ACE_FUTURE_CPP
   3
   4 #include "ace/Future.h"
   5
   6 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   7 # pragma once
   8 #endif /* ACE_LACKS_PRAGMA_ONCE */
   9
  10 #if defined (ACE_HAS_THREADS)
  11
  12 #  include "ace/Guard_T.h"
  13 #  include "ace/Recursive_Thread_Mutex.h"
  14
  15 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  16
  17 ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Future_Holder)
  18 ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Future_Observer)
  19 ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Future_Rep)
  20 ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Future)
  21
  22 template <class T>
  23 ACE_Future_Holder<T>::ACE_Future_Holder (const ACE_Future<T> &item)
  24   : item_ (item)
  25 {
  26 }
  27
  28 // Dump the state of an object.
  29
  30 template <class T> void
  31 ACE_Future_Rep<T>::dump () const
  32 {
  33 #if defined (ACE_HAS_DUMP)
  34   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
  35   ACELIB_DEBUG ((LM_DEBUG,
  36               "ref_count_ = %d\n",
  37  (int) this->ref_count_));
  38   ACELIB_DEBUG ((LM_INFO,"value_:\n"));
  39   if (this->value_)
  40     ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT (" (NON-NULL)\n")));
  41   else
  42     //FUZZ: disable check_for_NULL
  43     ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT (" (NULL)\n")));
  44     //FUZZ: enable check_for_NULL
  45
  46   ACELIB_DEBUG ((LM_INFO,"value_ready_:\n"));
  47   this->value_ready_.dump ();
  48   ACELIB_DEBUG ((LM_INFO,"value_ready_mutex_:\n"));
  49   this->value_ready_mutex_.dump ();
  50   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
  51 #endif /* ACE_HAS_DUMP */
  52 }
  53
  54 template <class T> ACE_Future_Rep<T> *
  55 ACE_Future_Rep<T>::internal_create ()
  56 {
  57   ACE_Future_Rep<T> *temp {};
  58   ACE_NEW_RETURN (temp,
  59                   ACE_Future_Rep<T> (),
  60                   nullptr);
  61   return temp;
  62 }
  63
  64 template <class T> ACE_Future_Rep<T> *
  65 ACE_Future_Rep<T>::create ()
  66 {
  67   // Yes set ref count to zero.
  68   ACE_Future_Rep<T> *temp = internal_create ();
  69   if (!temp)
  70     throw std::bad_alloc ();
  71    return temp;
  72  }
  73
  74
  75 template <class T> ACE_Future_Rep<T> *
  76 ACE_Future_Rep<T>::attach (ACE_Future_Rep<T>*& rep)
  77 {
  78   ACE_ASSERT (rep != nullptr);
  79   // Use value_ready_mutex_ for both condition and ref count management
  80   ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, r_mon, rep->value_ready_mutex_, nullptr);
  81   ++rep->ref_count_;
  82   return rep;
  83 }
  84
  85 template <class T> void
  86 ACE_Future_Rep<T>::detach (ACE_Future_Rep<T>*& rep)
  87 {
  88   ACE_ASSERT (rep != nullptr);
  89   // Use value_ready_mutex_ for both condition and ref count management
  90   ACE_GUARD (ACE_SYNCH_RECURSIVE_MUTEX, r_mon, rep->value_ready_mutex_);
  91
  92   if (rep->ref_count_-- == 0)
  93     {
  94       ACE_MT (r_mon.release ());
  95       // We do not need the lock when deleting the representation.
  96       // There should be no side effects from deleting rep and we don
  97       // not want to release a deleted mutex.
  98       delete rep;
  99     }
 100 }
 101
 102 template <class T> void
 103 ACE_Future_Rep<T>::assign (ACE_Future_Rep<T>*& rep, ACE_Future_Rep<T>* new_rep)
 104 {
 105   ACE_ASSERT (rep != nullptr);
 106   ACE_ASSERT (new_rep != nullptr);
 107   // Use value_ready_mutex_ for both condition and ref count management
 108   ACE_GUARD (ACE_SYNCH_RECURSIVE_MUTEX, r_mon, rep->value_ready_mutex_);
 109
 110   ACE_Future_Rep<T>* old = rep;
 111   rep = new_rep;
 112
 113   // detached old last for exception safety
 114   if (old->ref_count_-- == 0)
 115     {
 116       ACE_MT (r_mon.release ());
 117       // We do not need the lock when deleting the representation.
 118       // There should be no side effects from deleting rep and we don
 119       // not want to release a deleted mutex.
 120       delete old;
 121     }
 122 }
 123
 124 template <class T>
 125 ACE_Future_Rep<T>::ACE_Future_Rep ()
 126   : value_ready_ (value_ready_mutex_)
 127 {
 128 }
 129
 130 template <class T>
 131 ACE_Future_Rep<T>::~ACE_Future_Rep ()
 132 {
 133   delete this->value_;
 134 }
 135
 136 template <class T> int
 137 ACE_Future_Rep<T>::ready () const
 138 {
 139   return this->value_ != nullptr;
 140 }
 141
 142 template <class T> int
 143 ACE_Future_Rep<T>::set (const T &r,
 144                         ACE_Future<T> &caller)
 145 {
 146   // If the value is already produced, ignore it...
 147   if (this->value_ == nullptr)
 148     {
 149       ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX,
 150                         ace_mon,
 151                         this->value_ready_mutex_,
 152                         -1);
 153       // Otherwise, create a new result value.  Note the use of the
 154       // Double-checked locking pattern to avoid multiple allocations.
 155
 156       if (this->value_ == nullptr)       // Still no value, so proceed
 157         {
 158           ACE_NEW_RETURN (this->value_,
 159                           T (r),
 160                           -1);
 161
 162           // Remove and notify all subscribed observers.
 163           typename OBSERVER_COLLECTION::iterator iterator = this->observer_collection_.begin ();
 164           typename OBSERVER_COLLECTION::iterator end = this->observer_collection_.end ();
 165
 166           while (iterator != end)
 167             {
 168               OBSERVER *observer = *iterator++;
 169               if (observer)
 170               {
 171                 observer->update (caller);
 172               }
 173             }
 174
 175           // Signal all the waiting threads.
 176           return this->value_ready_.broadcast ();
 177         }
 178       // Destructor releases the lock.
 179     }
 180   return 0;
 181 }
 182
 183 template <class T> int
 184 ACE_Future_Rep<T>::get (T &value,
 185                         ACE_Time_Value *tv) const
 186 {
 187   // If the value is already produced, return it.
 188   if (this->value_ == nullptr)
 189     {
 190       ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon,
 191                         this->value_ready_mutex_,
 192                         -1);
 193       // If the value is not yet defined we must block until the
 194       // producer writes to it.
 195
 196       while (this->value_ == nullptr)
 197         // Perform a timed wait.
 198         if (this->value_ready_.wait (tv) == -1)
 199           return -1;
 200
 201       // Destructor releases the lock.
 202     }
 203
 204   value = *this->value_;
 205   return 0;
 206 }
 207
 208 template <class T> int
 209 ACE_Future_Rep<T>::attach (ACE_Future_Observer<T> *observer,
 210                           ACE_Future<T> &caller)
 211 {
 212   ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->value_ready_mutex_, -1);
 213
 214   // Otherwise, create a new result value.  Note the use of the
 215   // Double-checked locking pattern to avoid corrupting the list.
 216
 217   int result = 1;
 218
 219   // If the value is already produced, then notify observer
 220   if (this->value_ == nullptr)
 221     result = this->observer_collection_.insert (observer);
 222   else
 223     observer->update (caller);
 224
 225   return result;
 226 }
 227
 228 template <class T> int
 229 ACE_Future_Rep<T>::detach (ACE_Future_Observer<T> *observer)
 230 {
 231   ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->value_ready_mutex_, -1);
 232
 233   // Remove all occurrences of the specified observer from this
 234   // objects hash map.
 235   return this->observer_collection_.remove (observer);
 236 }
 237
 238 template <class T>
 239 ACE_Future_Rep<T>::operator T ()
 240 {
 241   // If the value is already produced, return it.
 242   if (this->value_ == nullptr)
 243     {
 244       // Constructor of ace_mon acquires the mutex.
 245       ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->value_ready_mutex_, 0);
 246
 247       // If the value is not yet defined we must block until the
 248       // producer writes to it.
 249
 250       // Wait ``forever.''
 251
 252       while (this->value_ == nullptr)
 253         if (this->value_ready_.wait () == -1)
 254           // What to do in this case since we've got to indicate
 255           // failure somehow?  Exceptions would be nice, but they're
 256           // not portable...
 257           return 0;
 258
 259       // Destructor releases the mutex
 260     }
 261
 262   return *this->value_;
 263 }
 264
 265 template <class T>
 266 ACE_Future<T>::ACE_Future ()
 267   : future_rep_ (FUTURE_REP::create ())
 268 {
 269 }
 270
 271 template <class T>
 272 ACE_Future<T>::ACE_Future (const ACE_Future<T> &r)
 273   : future_rep_ (FUTURE_REP::attach (((ACE_Future<T> &) r).future_rep_))
 274 {
 275 }
 276
 277 template <class T>
 278 ACE_Future<T>::ACE_Future (const T &r)
 279   : future_rep_ (FUTURE_REP::create ())
 280 {
 281   this->future_rep_->set (r, *this);
 282 }
 283
 284 template <class T>
 285 ACE_Future<T>::~ACE_Future ()
 286 {
 287   FUTURE_REP::detach (future_rep_);
 288 }
 289
 290 template <class T> bool
 291 ACE_Future<T>::operator== (const ACE_Future<T> &r) const
 292 {
 293   return r.future_rep_ == this->future_rep_;
 294 }
 295
 296 template <class T> bool
 297 ACE_Future<T>::operator!= (const ACE_Future<T> &r) const
 298 {
 299   return r.future_rep_ != this->future_rep_;
 300 }
 301
 302 template <class T> int
 303 ACE_Future<T>::cancel (const T &r)
 304 {
 305   this->cancel ();
 306   return this->future_rep_->set (r, *this);
 307 }
 308
 309 template <class T> int
 310 ACE_Future<T>::cancel ()
 311 {
 312   // If this ACE_Future is already attached to a ACE_Future_Rep,
 313   // detach it (maybe delete the ACE_Future_Rep).
 314   FUTURE_REP::assign (this->future_rep_,
 315                       FUTURE_REP::create ());
 316   return 0;
 317 }
 318
 319 template <class T> int
 320 ACE_Future<T>::set (const T &r)
 321 {
 322   // Give the pointer to the result to the ACE_Future_Rep.
 323   return this->future_rep_->set (r, *this);
 324 }
 325
 326 template <class T> int
 327 ACE_Future<T>::ready () const
 328 {
 329   // We're ready if the ACE_Future_rep is ready...
 330   return this->future_rep_->ready ();
 331 }
 332
 333 template <class T> int
 334 ACE_Future<T>::get (T &value, ACE_Time_Value *tv) const
 335 {
 336   // We return the ACE_Future_rep.
 337   return this->future_rep_->get (value, tv);
 338 }
 339
 340 template <class T> int
 341 ACE_Future<T>::attach (ACE_Future_Observer<T> *observer)
 342 {
 343   return this->future_rep_->attach (observer, *this);
 344 }
 345
 346 template <class T> int
 347 ACE_Future<T>::detach (ACE_Future_Observer<T> *observer)
 348 {
 349   return this->future_rep_->detach (observer);
 350 }
 351
 352 template <class T>
 353 ACE_Future<T>::operator T ()
 354 {
 355   // note that this will fail (and COREDUMP!)
 356   // if future_rep_ == 0 !
 357   //
 358   // but...
 359   // this is impossible unless somebody is so stupid to
 360   // try something like this:
 361   //
 362   // Future<T> futT;
 363   // T t;
 364   // t = futT;
 365
 366   // perform type conversion on Future_Rep.
 367   return *future_rep_;
 368 }
 369
 370 template <class T> void
 371 ACE_Future<T>::operator = (const ACE_Future<T> &rhs)
 372 {
 373   // assignment:
 374   //
 375   //  bind <this> to the same <ACE_Future_Rep> as <r>.
 376
 377   // This will work if &r == this, by first increasing the ref count
 378   ACE_Future<T> &r = (ACE_Future<T> &) rhs;
 379   FUTURE_REP::assign (this->future_rep_,
 380                       FUTURE_REP::attach (r.future_rep_));
 381 }
 382
 383 template <class T> void
 384 ACE_Future<T>::dump () const
 385 {
 386 #if defined (ACE_HAS_DUMP)
 387   ACELIB_DEBUG ((LM_DEBUG,
 388               ACE_BEGIN_DUMP, this));
 389
 390   if (this->future_rep_)
 391     this->future_rep_->dump ();
 392
 393   ACELIB_DEBUG ((LM_DEBUG,
 394               ACE_END_DUMP));
 395 #endif /* ACE_HAS_DUMP */
 396 }
 397
 398 template <class T> ACE_Future_Rep<T> *
 399 ACE_Future<T>::get_rep ()
 400 {
 401   return this->future_rep_;
 402 }
 403
 404 ACE_END_VERSIONED_NAMESPACE_DECL
 405
 406 #endif /* ACE_HAS_THREADS */
 407
 408 #endif /* ACE_FUTURE_CPP */