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 #ifndef _LIBCPP_NO_EXCEPTIONS 96 if (__has_value()) 97 throw future_error(make_error_code(future_errc::promise_already_satisfied)); 98 #endif 99 __state_ |= __constructed | ready; 100 __cv_.notify_all(); 101 __lk.unlock(); 102 } 103 104 void 105 __assoc_sub_state::set_value_at_thread_exit() 106 { 107 unique_lock<mutex> __lk(__mut_); 108 #ifndef _LIBCPP_NO_EXCEPTIONS 109 if (__has_value()) 110 throw future_error(make_error_code(future_errc::promise_already_satisfied)); 111 #endif 112 __state_ |= __constructed; 113 __thread_local_data()->__make_ready_at_thread_exit(this); 114 __lk.unlock(); 115 } 116 117 void 118 __assoc_sub_state::set_exception(exception_ptr __p) 119 { 120 unique_lock<mutex> __lk(__mut_); 121 #ifndef _LIBCPP_NO_EXCEPTIONS 122 if (__has_value()) 123 throw future_error(make_error_code(future_errc::promise_already_satisfied)); 124 #endif 125 __exception_ = __p; 126 __state_ |= ready; 127 __lk.unlock(); 128 __cv_.notify_all(); 129 } 130 131 void 132 __assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p) 133 { 134 unique_lock<mutex> __lk(__mut_); 135 #ifndef _LIBCPP_NO_EXCEPTIONS 136 if (__has_value()) 137 throw future_error(make_error_code(future_errc::promise_already_satisfied)); 138 #endif 139 __exception_ = __p; 140 __thread_local_data()->__make_ready_at_thread_exit(this); 141 __lk.unlock(); 142 } 143 144 void 145 __assoc_sub_state::__make_ready() 146 { 147 unique_lock<mutex> __lk(__mut_); 148 __state_ |= ready; 149 __lk.unlock(); 150 __cv_.notify_all(); 151 } 152 153 void 154 __assoc_sub_state::copy() 155 { 156 unique_lock<mutex> __lk(__mut_); 157 __sub_wait(__lk); 158 if (__exception_ != nullptr) 159 rethrow_exception(__exception_); 160 } 161 162 void 163 __assoc_sub_state::wait() 164 { 165 unique_lock<mutex> __lk(__mut_); 166 __sub_wait(__lk); 167 } 168 169 void 170 __assoc_sub_state::__sub_wait(unique_lock<mutex>& __lk) 171 { 172 if (!__is_ready()) 173 { 174 if (__state_ & static_cast<unsigned>(deferred)) 175 { 176 __state_ &= ~static_cast<unsigned>(deferred); 177 __lk.unlock(); 178 __execute(); 179 } 180 else 181 while (!__is_ready()) 182 __cv_.wait(__lk); 183 } 184 } 185 186 void 187 __assoc_sub_state::__execute() 188 { 189 #ifndef _LIBCPP_NO_EXCEPTIONS 190 throw future_error(make_error_code(future_errc::no_state)); 191 #endif 192 } 193 194 future<void>::future(__assoc_sub_state* __state) 195 : __state_(__state) 196 { 197 #ifndef _LIBCPP_NO_EXCEPTIONS 198 if (__state_->__has_future_attached()) 199 throw future_error(make_error_code(future_errc::future_already_retrieved)); 200 #endif 201 __state_->__add_shared(); 202 __state_->__set_future_attached(); 203 } 204 205 future<void>::~future() 206 { 207 if (__state_) 208 __state_->__release_shared(); 209 } 210 211 void 212 future<void>::get() 213 { 214 unique_ptr<__shared_count, __release_shared_count> __(__state_); 215 __assoc_sub_state* __s = __state_; 216 __state_ = nullptr; 217 __s->copy(); 218 } 219 220 promise<void>::promise() 221 : __state_(new __assoc_sub_state) 222 { 223 } 224 225 promise<void>::~promise() 226 { 227 if (__state_) 228 { 229 if (!__state_->__has_value() && __state_->use_count() > 1) 230 __state_->set_exception(make_exception_ptr( 231 future_error(make_error_code(future_errc::broken_promise)) 232 )); 233 __state_->__release_shared(); 234 } 235 } 236 237 future<void> 238 promise<void>::get_future() 239 { 240 #ifndef _LIBCPP_NO_EXCEPTIONS 241 if (__state_ == nullptr) 242 throw future_error(make_error_code(future_errc::no_state)); 243 #endif 244 return future<void>(__state_); 245 } 246 247 void 248 promise<void>::set_value() 249 { 250 #ifndef _LIBCPP_NO_EXCEPTIONS 251 if (__state_ == nullptr) 252 throw future_error(make_error_code(future_errc::no_state)); 253 #endif 254 __state_->set_value(); 255 } 256 257 void 258 promise<void>::set_exception(exception_ptr __p) 259 { 260 #ifndef _LIBCPP_NO_EXCEPTIONS 261 if (__state_ == nullptr) 262 throw future_error(make_error_code(future_errc::no_state)); 263 #endif 264 __state_->set_exception(__p); 265 } 266 267 void 268 promise<void>::set_value_at_thread_exit() 269 { 270 #ifndef _LIBCPP_NO_EXCEPTIONS 271 if (__state_ == nullptr) 272 throw future_error(make_error_code(future_errc::no_state)); 273 #endif 274 __state_->set_value_at_thread_exit(); 275 } 276 277 void 278 promise<void>::set_exception_at_thread_exit(exception_ptr __p) 279 { 280 #ifndef _LIBCPP_NO_EXCEPTIONS 281 if (__state_ == nullptr) 282 throw future_error(make_error_code(future_errc::no_state)); 283 #endif 284 __state_->set_exception_at_thread_exit(__p); 285 } 286 287 shared_future<void>::~shared_future() 288 { 289 if (__state_) 290 __state_->__release_shared(); 291 } 292 293 shared_future<void>& 294 shared_future<void>::operator=(const shared_future& __rhs) 295 { 296 if (__rhs.__state_) 297 __rhs.__state_->__add_shared(); 298 if (__state_) 299 __state_->__release_shared(); 300 __state_ = __rhs.__state_; 301 return *this; 302 } 303 304 _LIBCPP_END_NAMESPACE_STD 305 306 #endif // !_LIBCPP_HAS_NO_THREADS 307
