src/future.cpp

   1 //===------------------------- future.cpp ---------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "__config"
  11
  12 #ifndef _LIBCPP_HAS_NO_THREADS
  13
  14 #include "future"
  15 #include "string"
  16
  17 _LIBCPP_BEGIN_NAMESPACE_STD
  18
  19 class _LIBCPP_HIDDEN __future_error_category
  20     : public __do_message
  21 {
  22 public:
  23     virtual const char* name() const _NOEXCEPT;
  24     virtual string message(int ev) const;
  25 };
  26
  27 const char*
  28 __future_error_category::name() const _NOEXCEPT
  29 {
  30     return "future";
  31 }
  32
  33 #if defined(__clang__)
  34 #pragma clang diagnostic push
  35 #pragma clang diagnostic ignored "-Wswitch"
  36 #elif defined(__GNUC__) || defined(__GNUG__)
  37 #pragma GCC diagnostic push
  38 #pragma GCC diagnostic ignored "-Wswitch"
  39 #endif
  40
  41 string
  42 __future_error_category::message(int ev) const
  43 {
  44     switch (static_cast<future_errc>(ev))
  45     {
  46     case future_errc(0):  // For backwards compatibility with C++11 (LWG 2056)
  47     case future_errc::broken_promise:
  48         return string("The associated promise has been destructed prior "
  49                       "to the associated state becoming ready.");
  50     case future_errc::future_already_retrieved:
  51         return string("The future has already been retrieved from "
  52                       "the promise or packaged_task.");
  53     case future_errc::promise_already_satisfied:
  54         return string("The state of the promise has already been set.");
  55     case future_errc::no_state:
  56         return string("Operation not permitted on an object without "
  57                       "an associated state.");
  58     }
  59     return string("unspecified future_errc value\n");
  60 }
  61
  62 #if defined(__clang__)
  63 #pragma clang diagnostic pop
  64 #elif defined(__GNUC__) || defined(__GNUG__)
  65 #pragma GCC diagnostic pop
  66 #endif
  67
  68 const error_category&
  69 future_category() _NOEXCEPT
  70 {
  71     static __future_error_category __f;
  72     return __f;
  73 }
  74
  75 future_error::future_error(error_code __ec)
  76     : logic_error(__ec.message()),
  77       __ec_(__ec)
  78 {
  79 }
  80
  81 future_error::~future_error() _NOEXCEPT
  82 {
  83 }
  84
  85 void
  86 __assoc_sub_state::__on_zero_shared() _NOEXCEPT
  87 {
  88     delete this;
  89 }
  90
  91 void
  92 __assoc_sub_state::set_value()
  93 {
  94     unique_lock<mutex> __lk(__mut_);
  95     if (__has_value())
  96         __throw_future_error(future_errc::promise_already_satisfied);
  97     __state_ |= __constructed | ready;
  98     __cv_.notify_all();
  99 }
 100
 101 void
 102 __assoc_sub_state::set_value_at_thread_exit()
 103 {
 104     unique_lock<mutex> __lk(__mut_);
 105     if (__has_value())
 106         __throw_future_error(future_errc::promise_already_satisfied);
 107     __state_ |= __constructed;
 108     __thread_local_data()->__make_ready_at_thread_exit(this);
 109 }
 110
 111 void
 112 __assoc_sub_state::set_exception(exception_ptr __p)
 113 {
 114     unique_lock<mutex> __lk(__mut_);
 115     if (__has_value())
 116         __throw_future_error(future_errc::promise_already_satisfied);
 117     __exception_ = __p;
 118     __state_ |= ready;
 119     __cv_.notify_all();
 120 }
 121
 122 void
 123 __assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p)
 124 {
 125     unique_lock<mutex> __lk(__mut_);
 126     if (__has_value())
 127         __throw_future_error(future_errc::promise_already_satisfied);
 128     __exception_ = __p;
 129     __thread_local_data()->__make_ready_at_thread_exit(this);
 130 }
 131
 132 void
 133 __assoc_sub_state::__make_ready()
 134 {
 135     unique_lock<mutex> __lk(__mut_);
 136     __state_ |= ready;
 137     __cv_.notify_all();
 138 }
 139
 140 void
 141 __assoc_sub_state::copy()
 142 {
 143     unique_lock<mutex> __lk(__mut_);
 144     __sub_wait(__lk);
 145     if (__exception_ != nullptr)
 146         rethrow_exception(__exception_);
 147 }
 148
 149 void
 150 __assoc_sub_state::wait()
 151 {
 152     unique_lock<mutex> __lk(__mut_);
 153     __sub_wait(__lk);
 154 }
 155
 156 void
 157 __assoc_sub_state::__sub_wait(unique_lock<mutex>& __lk)
 158 {
 159     if (!__is_ready())
 160     {
 161         if (__state_ & static_cast<unsigned>(deferred))
 162         {
 163             __state_ &= ~static_cast<unsigned>(deferred);
 164             __lk.unlock();
 165             __execute();
 166         }
 167         else
 168             while (!__is_ready())
 169                 __cv_.wait(__lk);
 170     }
 171 }
 172
 173 void
 174 __assoc_sub_state::__execute()
 175 {
 176     __throw_future_error(future_errc::no_state);
 177 }
 178
 179 future<void>::future(__assoc_sub_state* __state)
 180     : __state_(__state)
 181 {
 182     __state_->__attach_future();
 183 }
 184
 185 future<void>::~future()
 186 {
 187     if (__state_)
 188         __state_->__release_shared();
 189 }
 190
 191 void
 192 future<void>::get()
 193 {
 194     unique_ptr<__shared_count, __release_shared_count> __(__state_);
 195     __assoc_sub_state* __s = __state_;
 196     __state_ = nullptr;
 197     __s->copy();
 198 }
 199
 200 promise<void>::promise()
 201     : __state_(new __assoc_sub_state)
 202 {
 203 }
 204
 205 promise<void>::~promise()
 206 {
 207     if (__state_)
 208     {
 209 #ifndef _LIBCPP_NO_EXCEPTIONS
 210         if (!__state_->__has_value() && __state_->use_count() > 1)
 211             __state_->set_exception(make_exception_ptr(
 212                       future_error(make_error_code(future_errc::broken_promise))
 213                                                       ));
 214 #endif // _LIBCPP_NO_EXCEPTIONS
 215         __state_->__release_shared();
 216     }
 217 }
 218
 219 future<void>
 220 promise<void>::get_future()
 221 {
 222     if (__state_ == nullptr)
 223         __throw_future_error(future_errc::no_state);
 224     return future<void>(__state_);
 225 }
 226
 227 void
 228 promise<void>::set_value()
 229 {
 230     if (__state_ == nullptr)
 231         __throw_future_error(future_errc::no_state);
 232     __state_->set_value();
 233 }
 234
 235 void
 236 promise<void>::set_exception(exception_ptr __p)
 237 {
 238     if (__state_ == nullptr)
 239         __throw_future_error(future_errc::no_state);
 240     __state_->set_exception(__p);
 241 }
 242
 243 void
 244 promise<void>::set_value_at_thread_exit()
 245 {
 246     if (__state_ == nullptr)
 247         __throw_future_error(future_errc::no_state);
 248     __state_->set_value_at_thread_exit();
 249 }
 250
 251 void
 252 promise<void>::set_exception_at_thread_exit(exception_ptr __p)
 253 {
 254     if (__state_ == nullptr)
 255         __throw_future_error(future_errc::no_state);
 256     __state_->set_exception_at_thread_exit(__p);
 257 }
 258
 259 shared_future<void>::~shared_future()
 260 {
 261     if (__state_)
 262         __state_->__release_shared();
 263 }
 264
 265 shared_future<void>&
 266 shared_future<void>::operator=(const shared_future& __rhs)
 267 {
 268     if (__rhs.__state_)
 269         __rhs.__state_->__add_shared();
 270     if (__state_)
 271         __state_->__release_shared();
 272     __state_ = __rhs.__state_;
 273     return *this;
 274 }
 275
 276 _LIBCPP_END_NAMESPACE_STD
 277
 278 #endif // !_LIBCPP_HAS_NO_THREADS