libcxx/src/future.cpp

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