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     union AvoidDestroyingFutureCategory {
  63         __future_error_category future_error_category;
  64         constexpr explicit AvoidDestroyingFutureCategory() : future_error_category() {}
  65         ~AvoidDestroyingFutureCategory() {}
  66     };
  67     constinit static AvoidDestroyingFutureCategory helper;
  68     return helper.future_error_category;
  69 }
  70
  71 future_error::future_error(error_code __ec)
  72     : logic_error(__ec.message()),
  73       __ec_(__ec)
  74 {
  75 }
  76
  77 future_error::~future_error() noexcept
  78 {
  79 }
  80
  81 void
  82 __assoc_sub_state::__on_zero_shared() noexcept
  83 {
  84     delete this;
  85 }
  86
  87 void
  88 __assoc_sub_state::set_value()
  89 {
  90     unique_lock<mutex> __lk(__mut_);
  91     if (__has_value())
  92         __throw_future_error(future_errc::promise_already_satisfied);
  93     __state_ |= __constructed | ready;
  94     __cv_.notify_all();
  95 }
  96
  97 void
  98 __assoc_sub_state::set_value_at_thread_exit()
  99 {
 100     unique_lock<mutex> __lk(__mut_);
 101     if (__has_value())
 102         __throw_future_error(future_errc::promise_already_satisfied);
 103     __state_ |= __constructed;
 104     __thread_local_data()->__make_ready_at_thread_exit(this);
 105 }
 106
 107 void
 108 __assoc_sub_state::set_exception(exception_ptr __p)
 109 {
 110     unique_lock<mutex> __lk(__mut_);
 111     if (__has_value())
 112         __throw_future_error(future_errc::promise_already_satisfied);
 113     __exception_ = __p;
 114     __state_ |= ready;
 115     __cv_.notify_all();
 116 }
 117
 118 void
 119 __assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p)
 120 {
 121     unique_lock<mutex> __lk(__mut_);
 122     if (__has_value())
 123         __throw_future_error(future_errc::promise_already_satisfied);
 124     __exception_ = __p;
 125     __thread_local_data()->__make_ready_at_thread_exit(this);
 126 }
 127
 128 void
 129 __assoc_sub_state::__make_ready()
 130 {
 131     unique_lock<mutex> __lk(__mut_);
 132     __state_ |= ready;
 133     __cv_.notify_all();
 134 }
 135
 136 void
 137 __assoc_sub_state::copy()
 138 {
 139     unique_lock<mutex> __lk(__mut_);
 140     __sub_wait(__lk);
 141     if (__exception_ != nullptr)
 142         rethrow_exception(__exception_);
 143 }
 144
 145 void
 146 __assoc_sub_state::wait()
 147 {
 148     unique_lock<mutex> __lk(__mut_);
 149     __sub_wait(__lk);
 150 }
 151
 152 void
 153 __assoc_sub_state::__sub_wait(unique_lock<mutex>& __lk)
 154 {
 155     if (!__is_ready())
 156     {
 157         if (__state_ & static_cast<unsigned>(deferred))
 158         {
 159             __state_ &= ~static_cast<unsigned>(deferred);
 160             __lk.unlock();
 161             __execute();
 162         }
 163         else
 164             while (!__is_ready())
 165                 __cv_.wait(__lk);
 166     }
 167 }
 168
 169 void
 170 __assoc_sub_state::__execute()
 171 {
 172     __throw_future_error(future_errc::no_state);
 173 }
 174
 175 future<void>::future(__assoc_sub_state* __state)
 176     : __state_(__state)
 177 {
 178     __state_->__attach_future();
 179 }
 180
 181 future<void>::~future()
 182 {
 183     if (__state_)
 184         __state_->__release_shared();
 185 }
 186
 187 void
 188 future<void>::get()
 189 {
 190     unique_ptr<__shared_count, __release_shared_count> __(__state_);
 191     __assoc_sub_state* __s = __state_;
 192     __state_ = nullptr;
 193     __s->copy();
 194 }
 195
 196 promise<void>::promise()
 197     : __state_(new __assoc_sub_state)
 198 {
 199 }
 200
 201 promise<void>::~promise()
 202 {
 203     if (__state_)
 204     {
 205 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 206         if (!__state_->__has_value() && __state_->use_count() > 1)
 207             __state_->set_exception(make_exception_ptr(future_error(future_errc::broken_promise)));
 208 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 209         __state_->__release_shared();
 210     }
 211 }
 212
 213 future<void>
 214 promise<void>::get_future()
 215 {
 216     if (__state_ == nullptr)
 217         __throw_future_error(future_errc::no_state);
 218     return future<void>(__state_);
 219 }
 220
 221 void
 222 promise<void>::set_value()
 223 {
 224     if (__state_ == nullptr)
 225         __throw_future_error(future_errc::no_state);
 226     __state_->set_value();
 227 }
 228
 229 void
 230 promise<void>::set_exception(exception_ptr __p)
 231 {
 232     if (__state_ == nullptr)
 233         __throw_future_error(future_errc::no_state);
 234     __state_->set_exception(__p);
 235 }
 236
 237 void
 238 promise<void>::set_value_at_thread_exit()
 239 {
 240     if (__state_ == nullptr)
 241         __throw_future_error(future_errc::no_state);
 242     __state_->set_value_at_thread_exit();
 243 }
 244
 245 void
 246 promise<void>::set_exception_at_thread_exit(exception_ptr __p)
 247 {
 248     if (__state_ == nullptr)
 249         __throw_future_error(future_errc::no_state);
 250     __state_->set_exception_at_thread_exit(__p);
 251 }
 252
 253 shared_future<void>::~shared_future()
 254 {
 255     if (__state_)
 256         __state_->__release_shared();
 257 }
 258
 259 shared_future<void>&
 260 shared_future<void>::operator=(const shared_future& __rhs)
 261 {
 262     if (__rhs.__state_)
 263         __rhs.__state_->__add_shared();
 264     if (__state_)
 265         __state_->__release_shared();
 266     __state_ = __rhs.__state_;
 267     return *this;
 268 }
 269
 270 _LIBCPP_END_NAMESPACE_STD
 271
 272 #endif // !_LIBCPP_HAS_NO_THREADS