1// <experimental/executor> -*- C++ -*- 2 3// Copyright (C) 2015-2021 Free Software Foundation, Inc. 4// 5// This file is part of the GNU ISO C++ Library. This library is free 6// software; you can redistribute it and/or modify it under the 7// terms of the GNU General Public License as published by the 8// Free Software Foundation; either version 3, or (at your option) 9// any later version. 10 11// This library is distributed in the hope that it will be useful, 12// but WITHOUT ANY WARRANTY; without even the implied warranty of 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14// GNU General Public License for more details. 15 16// Under Section 7 of GPL version 3, you are granted additional 17// permissions described in the GCC Runtime Library Exception, version 18// 3.1, as published by the Free Software Foundation. 19 20// You should have received a copy of the GNU General Public License and 21// a copy of the GCC Runtime Library Exception along with this program; 22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23// <http://www.gnu.org/licenses/>. 24 25/** @file experimental/executor 26 * This is a TS C++ Library header. 27 * @ingroup networking-ts 28 */ 29 30#ifndef _GLIBCXX_EXPERIMENTAL_EXECUTOR 31#define _GLIBCXX_EXPERIMENTAL_EXECUTOR 1 32 33#pragma GCC system_header 34 35#if __cplusplus >= 201402L 36 37#include <algorithm> 38#include <condition_variable> 39#include <functional> 40#include <future> 41#include <list> 42#include <queue> 43#include <thread> 44#include <tuple> 45#include <unordered_map> 46#include <utility> 47#include <experimental/netfwd> 48#include <bits/unique_ptr.h> 49#include <experimental/bits/net.h> 50 51namespace std _GLIBCXX_VISIBILITY(default) 52{ 53_GLIBCXX_BEGIN_NAMESPACE_VERSION 54namespace experimental 55{ 56namespace net 57{ 58inline namespace v1 59{ 60 61 /** @addtogroup networking-ts 62 * @{ 63 */ 64 65 /// Customization point for asynchronous operations. 66 template<typename _CompletionToken, typename _Signature, typename = void> 67 class async_result; 68 69 /// Convenience utility to help implement asynchronous operations. 70 template<typename _CompletionToken, typename _Signature> 71 class async_completion; 72 73 template<typename _Tp, typename _ProtoAlloc, typename = __void_t<>> 74 struct __associated_allocator_impl 75 { 76 using type = _ProtoAlloc; 77 78 static type 79 _S_get(const _Tp&, const _ProtoAlloc& __a) noexcept { return __a; } 80 }; 81 82 template<typename _Tp, typename _ProtoAlloc> 83 struct __associated_allocator_impl<_Tp, _ProtoAlloc, 84 __void_t<typename _Tp::allocator_type>> 85 { 86 using type = typename _Tp::allocator_type; 87 88 static type 89 _S_get(const _Tp& __t, const _ProtoAlloc&) noexcept 90 { return __t.get_allocator(); } 91 }; 92 93 /// Helper to associate an allocator with a type. 94 template<typename _Tp, typename _ProtoAllocator = allocator<void>> 95 struct associated_allocator 96 : __associated_allocator_impl<_Tp, _ProtoAllocator> 97 { 98 static auto 99 get(const _Tp& __t, 100 const _ProtoAllocator& __a = _ProtoAllocator()) noexcept 101 { 102 using _Impl = __associated_allocator_impl<_Tp, _ProtoAllocator>; 103 return _Impl::_S_get(__t, __a); 104 } 105 }; 106 107 /// Alias template for associated_allocator. 108 template<typename _Tp, typename _ProtoAllocator = allocator<void>> 109 using associated_allocator_t 110 = typename associated_allocator<_Tp, _ProtoAllocator>::type; 111 112 // get_associated_allocator: 113 114 template<typename _Tp> 115 inline associated_allocator_t<_Tp> 116 get_associated_allocator(const _Tp& __t) noexcept 117 { return associated_allocator<_Tp>::get(__t); } 118 119 template<typename _Tp, typename _ProtoAllocator> 120 inline associated_allocator_t<_Tp, _ProtoAllocator> 121 get_associated_allocator(const _Tp& __t, 122 const _ProtoAllocator& __a) noexcept 123 { return associated_allocator<_Tp, _ProtoAllocator>::get(__t, __a); } 124 125 enum class fork_event { prepare, parent, child }; 126 127 /// An extensible, type-safe, polymorphic set of services. 128 class execution_context; 129 130 class service_already_exists : public logic_error 131 { 132 public: 133 // _GLIBCXX_RESOLVE_LIB_DEFECTS 134 // 3414. service_already_exists has no usable constructors 135 service_already_exists() : logic_error("service already exists") { } 136 }; 137 138 template<typename _Tp> struct is_executor; 139 140 struct executor_arg_t { }; 141 142 constexpr executor_arg_t executor_arg = executor_arg_t(); 143 144 /// Trait for determining whether to construct an object with an executor. 145 template<typename _Tp, typename _Executor> struct uses_executor; 146 147 template<typename _Tp, typename _Executor, typename = __void_t<>> 148 struct __associated_executor_impl 149 { 150 using type = _Executor; 151 152 static type 153 _S_get(const _Tp&, const _Executor& __e) noexcept { return __e; } 154 }; 155 156 template<typename _Tp, typename _Executor> 157 struct __associated_executor_impl<_Tp, _Executor, 158 __void_t<typename _Tp::executor_type>> 159 { 160 using type = typename _Tp::executor_type; 161 162 static type 163 _S_get(const _Tp& __t, const _Executor&) noexcept 164 { return __t.get_executor(); } 165 }; 166 167 /// Helper to associate an executor with a type. 168 template<typename _Tp, typename _Executor = system_executor> 169 struct associated_executor 170 : __associated_executor_impl<_Tp, _Executor> 171 { 172 static auto 173 get(const _Tp& __t, const _Executor& __e = _Executor()) noexcept 174 { return __associated_executor_impl<_Tp, _Executor>::_S_get(__t, __e); } 175 }; 176 177 178 template<typename _Tp, typename _Executor = system_executor> 179 using associated_executor_t 180 = typename associated_executor<_Tp, _Executor>::type; 181 182 template<typename _ExecutionContext> 183 using __is_exec_context 184 = is_convertible<_ExecutionContext&, execution_context&>; 185 186 template<typename _Tp> 187 using __executor_t = typename _Tp::executor_type; 188 189 // get_associated_executor: 190 191 template<typename _Tp> 192 inline associated_executor_t<_Tp> 193 get_associated_executor(const _Tp& __t) noexcept 194 { return associated_executor<_Tp>::get(__t); } 195 196 template<typename _Tp, typename _Executor> 197 inline 198 enable_if_t<is_executor<_Executor>::value, 199 associated_executor_t<_Tp, _Executor>> 200 get_associated_executor(const _Tp& __t, const _Executor& __ex) 201 { return associated_executor<_Tp, _Executor>::get(__t, __ex); } 202 203 template<typename _Tp, typename _ExecutionContext> 204 inline 205 enable_if_t<__is_exec_context<_ExecutionContext>::value, 206 associated_executor_t<_Tp, __executor_t<_ExecutionContext>>> 207 get_associated_executor(const _Tp& __t, _ExecutionContext& __ctx) noexcept 208 { return net::get_associated_executor(__t, __ctx.get_executor()); } 209 210 211 /// Helper to bind an executor to an object or function. 212 template<typename _Tp, typename _Executor> 213 class executor_binder; 214 215 template<typename _Tp, typename _Executor, typename _Signature> 216 class async_result<executor_binder<_Tp, _Executor>, _Signature>; 217 218 template<typename _Tp, typename _Executor, typename _ProtoAllocator> 219 struct associated_allocator<executor_binder<_Tp, _Executor>, 220 _ProtoAllocator>; 221 222 template<typename _Tp, typename _Executor, typename _Executor1> 223 struct associated_executor<executor_binder<_Tp, _Executor>, _Executor1>; 224 225 // bind_executor: 226 227 template<typename _Executor, typename _Tp> 228 inline 229 enable_if_t<is_executor<_Executor>::value, 230 executor_binder<decay_t<_Tp>, _Executor>> 231 bind_executor(const _Executor& __ex, _Tp&& __t) 232 { return { std::forward<_Tp>(__t), __ex }; } 233 234 template<typename _ExecutionContext, typename _Tp> 235 inline 236 enable_if_t<__is_exec_context<_ExecutionContext>::value, 237 executor_binder<decay_t<_Tp>, __executor_t<_ExecutionContext>>> 238 bind_executor(_ExecutionContext& __ctx, _Tp&& __t) 239 { return { __ctx.get_executor(), forward<_Tp>(__t) }; } 240 241 242 /// A scope-guard type to record when work is started and finished. 243 template<typename _Executor> 244 class executor_work_guard; 245 246 // make_work_guard: 247 248 template<typename _Executor> 249 inline 250 enable_if_t<is_executor<_Executor>::value, executor_work_guard<_Executor>> 251 make_work_guard(const _Executor& __ex) 252 { return executor_work_guard<_Executor>(__ex); } 253 254 template<typename _ExecutionContext> 255 inline 256 enable_if_t<__is_exec_context<_ExecutionContext>::value, 257 executor_work_guard<__executor_t<_ExecutionContext>>> 258 make_work_guard(_ExecutionContext& __ctx) 259 { return net::make_work_guard(__ctx.get_executor()); } 260 261 template<typename _Tp> 262 inline 263 enable_if_t<__not_<__or_<is_executor<_Tp>, __is_exec_context<_Tp>>>::value, 264 executor_work_guard<associated_executor_t<_Tp>>> 265 make_work_guard(const _Tp& __t) 266 { return net::get_associated_executor(__t); } 267 268 template<typename _Tp, typename _Up> 269 auto 270 make_work_guard(const _Tp& __t, _Up&& __u) 271 -> decltype(net::make_work_guard( 272 net::get_associated_executor(__t, forward<_Up>(__u)))) 273 { 274 return net::make_work_guard( 275 net::get_associated_executor(__t, forward<_Up>(__u))); 276 } 277 278 /// Allows function objects to execute on any thread. 279 class system_executor; 280 281 /// The execution context associated with system_executor objects. 282 class system_context; 283 284 inline bool 285 operator==(const system_executor&, const system_executor&) { return true; } 286 287 inline bool 288 operator!=(const system_executor&, const system_executor&) { return false; } 289 290 /// Exception thrown by empty executors. 291 class bad_executor; 292 293 /// Polymorphic wrapper for types satisfying the Executor requirements. 294 class executor; 295 296 bool 297 operator==(const executor&, const executor&) noexcept; 298 299 bool 300 operator==(const executor&, nullptr_t) noexcept; 301 302 bool 303 operator==(nullptr_t, const executor&) noexcept; 304 305 bool 306 operator!=(const executor&, const executor&) noexcept; 307 308 bool 309 operator!=(const executor&, nullptr_t) noexcept; 310 311 bool 312 operator!=(nullptr_t, const executor&) noexcept; 313 314 void swap(executor&, executor&) noexcept; 315 316 // dispatch: 317 318 template<typename _CompletionToken> 319 __deduced_t<_CompletionToken, void()> 320 dispatch(_CompletionToken&& __token); 321 322 template<typename _Executor, typename _CompletionToken> 323 __deduced_t<_CompletionToken, void()> 324 dispatch(const _Executor& __ex, _CompletionToken&& __token); 325 326 template<typename _ExecutionContext, typename _CompletionToken> 327 __deduced_t<_CompletionToken, void()> 328 dispatch(_ExecutionContext& __ctx, _CompletionToken&& __token); 329 330 // post: 331 332 template<typename _CompletionToken> 333 __deduced_t<_CompletionToken, void()> 334 post(_CompletionToken&& __token); 335 template<typename _Executor, typename _CompletionToken> 336 enable_if_t<is_executor<_Executor>::value, 337 __deduced_t<_CompletionToken, void()>> 338 post(const _Executor& __ex, _CompletionToken&& __token); 339 template<typename _ExecutionContext, typename _CompletionToken> 340 enable_if_t<__is_exec_context<_ExecutionContext>::value, 341 __deduced_t<_CompletionToken, void()>> 342 post(_ExecutionContext& __ctx, _CompletionToken&& __token); 343 344 // defer: 345 346 template<typename _CompletionToken> 347 __deduced_t<_CompletionToken, void()> 348 defer(_CompletionToken&& __token); 349 template<typename _Executor, typename _CompletionToken> 350 __deduced_t<_CompletionToken, void()> 351 defer(const _Executor& __ex, _CompletionToken&& __token); 352 template<typename _ExecutionContext, typename _CompletionToken> 353 __deduced_t<_CompletionToken, void()> 354 defer(_ExecutionContext& __ctx, _CompletionToken&& __token); 355 356 template<typename _Executor> 357 class strand; 358 359 template<typename _Executor> 360 bool 361 operator==(const strand<_Executor>& __a, const strand<_Executor>& __b); 362 363 template<typename _Executor> 364 bool 365 operator!=(const strand<_Executor>& __a, const strand<_Executor>& __b) 366 { return !(__a == __b); } 367 368 template<typename _CompletionToken, typename _Signature, typename> 369 class async_result 370 { 371 public: 372 using completion_handler_type = _CompletionToken; 373 using return_type = void; 374 375 explicit async_result(completion_handler_type&) {} 376 async_result(const async_result&) = delete; 377 async_result& operator=(const async_result&) = delete; 378 379 return_type get() {} 380 }; 381 382 template<typename _CompletionToken, typename _Signature> 383 class async_completion 384 { 385 using __result_type 386 = async_result<decay_t<_CompletionToken>, _Signature>; 387 388 public: 389 using completion_handler_type 390 = typename __result_type::completion_handler_type; 391 392 private: 393 using __handler_type = conditional_t< 394 is_same<_CompletionToken, completion_handler_type>::value, 395 completion_handler_type&, 396 completion_handler_type>; 397 398 public: 399 explicit 400 async_completion(_CompletionToken& __t) 401 : completion_handler(std::forward<__handler_type>(__t)), 402 result(completion_handler) 403 { } 404 405 async_completion(const async_completion&) = delete; 406 async_completion& operator=(const async_completion&) = delete; 407 408 __handler_type completion_handler; 409 __result_type result; 410 }; 411 412 413 class execution_context 414 { 415 public: 416 class service 417 { 418 protected: 419 // construct / copy / destroy: 420 421 explicit 422 service(execution_context& __owner) : _M_context(__owner) { } 423 424 service(const service&) = delete; 425 service& operator=(const service&) = delete; 426 427 virtual ~service() { } // TODO should not be inline 428 429 // service observers: 430 431 execution_context& context() const noexcept { return _M_context; } 432 433 private: 434 // service operations: 435 436 virtual void shutdown() noexcept = 0; 437 virtual void notify_fork(fork_event) { } 438 439 friend class execution_context; 440 execution_context& _M_context; 441 }; 442 443 // construct / copy / destroy: 444 445 execution_context() { } 446 447 execution_context(const execution_context&) = delete; 448 execution_context& operator=(const execution_context&) = delete; 449 450 virtual ~execution_context() 451 { 452 shutdown(); 453 destroy(); 454 } 455 456 // execution context operations: 457 458 void 459 notify_fork(fork_event __e) 460 { 461 auto __l = [=](auto& __svc) { __svc._M_ptr->notify_fork(__e); }; 462 if (__e == fork_event::prepare) 463 std::for_each(_M_services.rbegin(), _M_services.rend(), __l); 464 else 465 std::for_each(_M_services.begin(), _M_services.end(), __l); 466 } 467 468 protected: 469 // execution context protected operations: 470 471 void 472 shutdown() 473 { 474 std::for_each(_M_services.rbegin(), _M_services.rend(), 475 [=](auto& __svc) { 476 if (__svc._M_active) 477 { 478 __svc._M_ptr->shutdown(); 479 __svc._M_active = false; 480 } 481 }); 482 } 483 484 void 485 destroy() 486 { 487 while (_M_services.size()) 488 _M_services.pop_back(); 489 _M_keys.clear(); 490 } 491 492 protected: 493 494 template<typename _Service> 495 static void 496 _S_deleter(service* __svc) { delete static_cast<_Service*>(__svc); } 497 498 struct _ServicePtr 499 { 500 template<typename _Service> 501 explicit 502 _ServicePtr(_Service* __svc) 503 : _M_ptr(__svc, &_S_deleter<_Service>), _M_active(true) { } 504 505 std::unique_ptr<service, void(*)(service*)> _M_ptr; 506 bool _M_active; 507 }; 508 509#if defined(_GLIBCXX_HAS_GTHREADS) 510 using mutex_type = std::mutex; 511#else 512 struct mutex_type 513 { 514 void lock() const { } 515 void unlock() const { } 516 }; 517#endif 518 mutable mutex_type _M_mutex; 519 520 // Sorted in order of beginning of service object lifetime. 521 std::list<_ServicePtr> _M_services; 522 523 template<typename _Service, typename... _Args> 524 service* 525 _M_add_svc(_Args&&... __args) 526 { 527 _M_services.push_back( 528 _ServicePtr{new _Service{*this, std::forward<_Args>(__args)...}} ); 529 return _M_services.back()._M_ptr.get(); 530 } 531 532 using __key_type = void(*)(); 533 534 template<typename _Key> 535 static __key_type 536 _S_key() { return reinterpret_cast<__key_type>(&_S_key<_Key>); } 537 538 std::unordered_map<__key_type, service*> _M_keys; 539 540 template<typename _Service> 541 friend typename _Service::key_type& 542 use_service(execution_context&); 543 544 template<typename _Service, typename... _Args> 545 friend _Service& 546 make_service(execution_context&, _Args&&...); 547 548 template<typename _Service> 549 friend bool 550 has_service(const execution_context&) noexcept; 551 }; 552 553 // service access: 554 555 template<typename _Service> 556 typename _Service::key_type& 557 use_service(execution_context& __ctx) 558 { 559 using _Key = typename _Service::key_type; 560 static_assert(is_base_of<execution_context::service, _Key>::value, 561 "a service type must derive from execution_context::service"); 562 static_assert(is_base_of<_Key, _Service>::value, 563 "a service type must match or derive from its key_type"); 564 auto __key = execution_context::_S_key<_Key>(); 565 lock_guard<execution_context::mutex_type> __lock(__ctx._M_mutex); 566 auto& __svc = __ctx._M_keys[__key]; 567 if (__svc == nullptr) 568 { 569 __try { 570 __svc = __ctx._M_add_svc<_Service>(); 571 } __catch(...) { 572 __ctx._M_keys.erase(__key); 573 __throw_exception_again; 574 } 575 } 576 return static_cast<_Key&>(*__svc); 577 } 578 579 template<typename _Service, typename... _Args> 580 _Service& 581 make_service(execution_context& __ctx, _Args&&... __args) 582 { 583 using _Key = typename _Service::key_type; 584 static_assert(is_base_of<execution_context::service, _Key>::value, 585 "a service type must derive from execution_context::service"); 586 static_assert(is_base_of<_Key, _Service>::value, 587 "a service type must match or derive from its key_type"); 588 auto __key = execution_context::_S_key<_Key>(); 589 lock_guard<execution_context::mutex_type> __lock(__ctx._M_mutex); 590 auto& __svc = __ctx._M_keys[__key]; 591 if (__svc != nullptr) 592 throw service_already_exists(); 593 __try { 594 __svc = __ctx._M_add_svc<_Service>(std::forward<_Args>(__args)...); 595 } __catch(...) { 596 __ctx._M_keys.erase(__key); 597 __throw_exception_again; 598 } 599 return static_cast<_Service&>(*__svc); 600 } 601 602 template<typename _Service> 603 inline bool 604 has_service(const execution_context& __ctx) noexcept 605 { 606 using _Key = typename _Service::key_type; 607 static_assert(is_base_of<execution_context::service, _Key>::value, 608 "a service type must derive from execution_context::service"); 609 static_assert(is_base_of<_Key, _Service>::value, 610 "a service type must match or derive from its key_type"); 611 lock_guard<execution_context::mutex_type> __lock(__ctx._M_mutex); 612 return __ctx._M_keys.count(execution_context::_S_key<_Key>()); 613 } 614 615 template<typename _Tp, typename = __void_t<>> 616 struct __is_executor_impl : false_type 617 { }; 618 619 // Check Executor requirements. 620 template<typename _Tp, typename _Up = remove_const_t<_Tp>> 621 auto 622 __executor_reqs(_Up* __x = 0, const _Up* __cx = 0, void(*__f)() = 0, 623 const allocator<int>& __a = {}) 624 -> enable_if_t<__is_value_constructible<_Tp>::value, __void_t< 625 decltype(*__cx == *__cx), 626 decltype(*__cx != *__cx), 627 decltype(__x->context()), 628 decltype(__x->on_work_started()), 629 decltype(__x->on_work_finished()), 630 decltype(__x->dispatch(std::move(__f), __a)), 631 decltype(__x->post(std::move(__f), __a)), 632 decltype(__x->defer(std::move(__f), __a)) 633 >>; 634 635 template<typename _Tp> 636 struct __is_executor_impl<_Tp, decltype(__executor_reqs<_Tp>())> 637 : true_type 638 { }; 639 640 template<typename _Tp> 641 struct is_executor : __is_executor_impl<_Tp> 642 { }; 643 644 template<typename _Tp> 645 constexpr bool is_executor_v = is_executor<_Tp>::value; 646 647 template<typename _Tp, typename _Executor, typename = __void_t<>> 648 struct __uses_executor_impl : false_type 649 { }; 650 651 template<typename _Tp, typename _Executor> 652 struct __uses_executor_impl<_Tp, _Executor, 653 __void_t<typename _Tp::executor_type>> 654 : is_convertible<_Executor, typename _Tp::executor_type> 655 { }; 656 657 template<typename _Tp, typename _Executor> 658 struct uses_executor : __uses_executor_impl<_Tp, _Executor>::type 659 { }; 660 661 template<typename _Tp, typename _Executor> 662 constexpr bool uses_executor_v = uses_executor<_Tp, _Executor>::value; 663 664 template<typename _Tp, typename _Executor> 665 class executor_binder 666 { 667 struct __use_exec { }; 668 669 public: 670 // types: 671 672 using target_type = _Tp; 673 using executor_type = _Executor; 674 675 // construct / copy / destroy: 676 677 executor_binder(_Tp __t, const _Executor& __ex) 678 : executor_binder(__use_exec{}, std::move(__t), __ex) 679 { } 680 681 executor_binder(const executor_binder&) = default; 682 executor_binder(executor_binder&&) = default; 683 684 template<typename _Up, typename _OtherExecutor> 685 executor_binder(const executor_binder<_Up, _OtherExecutor>& __other) 686 : executor_binder(__use_exec{}, __other.get(), __other.get_executor()) 687 { } 688 689 template<typename _Up, typename _OtherExecutor> 690 executor_binder(executor_binder<_Up, _OtherExecutor>&& __other) 691 : executor_binder(__use_exec{}, std::move(__other.get()), 692 __other.get_executor()) 693 { } 694 695 template<typename _Up, typename _OtherExecutor> 696 executor_binder(executor_arg_t, const _Executor& __ex, 697 const executor_binder<_Up, _OtherExecutor>& __other) 698 : executor_binder(__use_exec{}, __other.get(), __ex) 699 { } 700 701 template<typename _Up, typename _OtherExecutor> 702 executor_binder(executor_arg_t, const _Executor& __ex, 703 executor_binder<_Up, _OtherExecutor>&& __other) 704 : executor_binder(__use_exec{}, std::move(__other.get()), __ex) 705 { } 706 707 ~executor_binder(); 708 709 // executor binder access: 710 711 _Tp& get() noexcept { return _M_target; } 712 const _Tp& get() const noexcept { return _M_target; } 713 executor_type get_executor() const noexcept { return _M_ex; } 714 715 // executor binder invocation: 716 717 template<class... _Args> 718 result_of_t<_Tp&(_Args&&...)> 719 operator()(_Args&&... __args) 720 { return std::__invoke(get(), std::forward<_Args>(__args)...); } 721 722 template<class... _Args> 723 result_of_t<const _Tp&(_Args&&...)> 724 operator()(_Args&&... __args) const 725 { return std::__invoke(get(), std::forward<_Args>(__args)...); } 726 727 private: 728 template<typename _Up> 729 using __use_exec_cond 730 = __and_<uses_executor<_Tp, _Executor>, 731 is_constructible<_Tp, executor_arg_t, _Executor, _Up>>; 732 733 template<typename _Up, typename _Exec, typename = 734 enable_if_t<__use_exec_cond<_Up>::value>> 735 executor_binder(__use_exec, _Up&& __u, _Exec&& __ex) 736 : _M_ex(std::forward<_Exec>(__ex)), 737 _M_target(executor_arg, _M_ex, std::forward<_Up>(__u)) 738 { } 739 740 template<typename _Up, typename _Exec, typename = 741 enable_if_t<!__use_exec_cond<_Up>::value>> 742 executor_binder(__use_exec, _Up&& __u, const _Exec& __ex) 743 : _M_ex(std::forward<_Exec>(__ex)), 744 _M_target(std::forward<_Up>(__u)) 745 { } 746 747 _Executor _M_ex; 748 _Tp _M_target; 749 }; 750 751 template<typename _Tp, typename _Executor, typename _Signature> 752 class async_result<executor_binder<_Tp, _Executor>, _Signature> 753 { 754 using __inner = async_result<_Tp, _Signature>; 755 756 public: 757 using completion_handler_type = 758 executor_binder<typename __inner::completion_handler_type, _Executor>; 759 760 using return_type = typename __inner::return_type; 761 762 explicit 763 async_result(completion_handler_type& __h) 764 : _M_target(__h.get()) { } 765 766 async_result(const async_result&) = delete; 767 async_result& operator=(const async_result&) = delete; 768 769 return_type get() { return _M_target.get(); } 770 771 private: 772 __inner _M_target; 773 }; 774 775 template<typename _Tp, typename _Executor, typename _ProtoAlloc> 776 struct associated_allocator<executor_binder<_Tp, _Executor>, _ProtoAlloc> 777 { 778 using type = associated_allocator_t<_Tp, _ProtoAlloc>; 779 780 static type 781 get(const executor_binder<_Tp, _Executor>& __b, 782 const _ProtoAlloc& __a = _ProtoAlloc()) noexcept 783 { return associated_allocator<_Tp, _ProtoAlloc>::get(__b.get(), __a); } 784 }; 785 786 template<typename _Tp, typename _Executor, typename _Executor1> 787 struct associated_executor<executor_binder<_Tp, _Executor>, _Executor1> 788 { 789 using type = _Executor; 790 791 static type 792 get(const executor_binder<_Tp, _Executor>& __b, 793 const _Executor1& = _Executor1()) noexcept 794 { return __b.get_executor(); } 795 }; 796 797 template<typename _Executor> 798 class executor_work_guard 799 { 800 public: 801 // types: 802 803 using executor_type = _Executor; 804 805 // construct / copy / destroy: 806 807 explicit 808 executor_work_guard(const executor_type& __ex) noexcept 809 : _M_ex(__ex), _M_owns(true) 810 { _M_ex.on_work_started(); } 811 812 executor_work_guard(const executor_work_guard& __other) noexcept 813 : _M_ex(__other._M_ex), _M_owns(__other._M_owns) 814 { 815 if (_M_owns) 816 _M_ex.on_work_started(); 817 } 818 819 executor_work_guard(executor_work_guard&& __other) noexcept 820 : _M_ex(__other._M_ex), _M_owns(__other._M_owns) 821 { __other._M_owns = false; } 822 823 executor_work_guard& operator=(const executor_work_guard&) = delete; 824 825 ~executor_work_guard() 826 { 827 if (_M_owns) 828 _M_ex.on_work_finished(); 829 } 830 831 // executor work guard observers: 832 833 executor_type get_executor() const noexcept { return _M_ex; } 834 835 bool owns_work() const noexcept { return _M_owns; } 836 837 // executor work guard modifiers: 838 839 void reset() noexcept 840 { 841 if (_M_owns) 842 _M_ex.on_work_finished(); 843 _M_owns = false; 844 } 845 846 private: 847 _Executor _M_ex; 848 bool _M_owns; 849 }; 850 851 852 class system_context : public execution_context 853 { 854 public: 855 // types: 856 857 using executor_type = system_executor; 858 859 // construct / copy / destroy: 860 861 system_context() = delete; 862 system_context(const system_context&) = delete; 863 system_context& operator=(const system_context&) = delete; 864 865 ~system_context() 866 { 867 stop(); 868 join(); 869 } 870 871 // system_context operations: 872 873 executor_type get_executor() noexcept; 874 875 void stop() 876 { 877 lock_guard<mutex_type> __lock(_M_mtx); 878 _M_stopped = true; 879 _M_cv.notify_all(); 880 } 881 882 bool stopped() const noexcept 883 { 884 lock_guard<mutex_type> __lock(_M_mtx); 885 return _M_stopped; 886 } 887 888 void join() 889 { 890 if (_M_thread.joinable()) 891 _M_thread.join(); 892 } 893 894 private: 895 friend system_executor; 896 897 struct __tag { explicit __tag() = default; }; 898 system_context(__tag) { } 899 900#ifndef _GLIBCXX_HAS_GTHREADS 901 struct thread 902 { 903 bool joinable() const { return false; } 904 void join() { } 905 }; 906 struct condition_variable 907 { 908 void notify_all() { } 909 }; 910#endif 911 912 thread _M_thread; 913 mutable mutex_type _M_mtx; // XXX can we reuse base's _M_mutex? 914 condition_variable _M_cv; 915 queue<function<void()>> _M_tasks; 916 bool _M_stopped = false; 917 918#ifdef _GLIBCXX_HAS_GTHREADS 919 void 920 _M_run() 921 { 922 while (true) 923 { 924 function<void()> __f; 925 { 926 unique_lock<mutex_type> __lock(_M_mtx); 927 _M_cv.wait(__lock, 928 [this]{ return _M_stopped || !_M_tasks.empty(); }); 929 if (_M_stopped) 930 return; 931 __f = std::move(_M_tasks.front()); 932 _M_tasks.pop(); 933 } 934 __f(); 935 } 936 } 937#endif 938 939 void 940 _M_post(std::function<void()> __f __attribute__((__unused__))) 941 { 942 lock_guard<mutex_type> __lock(_M_mtx); 943 if (_M_stopped) 944 return; 945#ifdef _GLIBCXX_HAS_GTHREADS 946 if (!_M_thread.joinable()) 947 _M_thread = std::thread(&system_context::_M_run, this); 948 _M_tasks.push(std::move(__f)); // XXX allocator not used 949 _M_cv.notify_one(); 950#else 951 __throw_system_error(EOPNOTSUPP); 952#endif 953 } 954 955 static system_context& 956 _S_get() noexcept 957 { 958 static system_context __sc(__tag{}); 959 return __sc; 960 } 961 }; 962 963 class system_executor 964 { 965 public: 966 // executor operations: 967 968 system_executor() { } 969 970 system_context& 971 context() const noexcept { return system_context::_S_get(); } 972 973 void on_work_started() const noexcept { } 974 void on_work_finished() const noexcept { } 975 976 template<typename _Func, typename _ProtoAlloc> 977 void 978 dispatch(_Func&& __f, const _ProtoAlloc& __a) const 979 { decay_t<_Func>{std::forward<_Func>(__f)}(); } 980 981 template<typename _Func, typename _ProtoAlloc> 982 void 983 post(_Func&& __f, const _ProtoAlloc&) const // XXX allocator not used 984 { 985 system_context::_S_get()._M_post(std::forward<_Func>(__f)); 986 } 987 988 template<typename _Func, typename _ProtoAlloc> 989 void 990 defer(_Func&& __f, const _ProtoAlloc& __a) const 991 { post(std::forward<_Func>(__f), __a); } 992 }; 993 994 inline system_executor 995 system_context::get_executor() noexcept 996 { return {}; } 997 998 class bad_executor : public std::exception 999 { 1000 virtual const char* what() const noexcept { return "bad executor"; } 1001 }; 1002 1003 inline void __throw_bad_executor() // TODO make non-inline 1004 { 1005#if __cpp_exceptions 1006 throw bad_executor(); 1007#else 1008 __builtin_abort(); 1009#endif 1010 } 1011 1012 class executor 1013 { 1014 public: 1015 // construct / copy / destroy: 1016 1017 executor() noexcept = default; 1018 1019 executor(nullptr_t) noexcept { } 1020 executor(const executor&) noexcept = default; 1021 executor(executor&&) noexcept = default; 1022 1023 template<typename _Executor> 1024 executor(_Executor __e) 1025 : _M_target(make_shared<_Tgt1<_Executor>>(std::move(__e))) 1026 { } 1027 1028 template<typename _Executor, typename _ProtoAlloc> 1029 executor(allocator_arg_t, const _ProtoAlloc& __a, _Executor __e) 1030 : _M_target(allocate_shared<_Tgt2<_Executor, _ProtoAlloc>>(__a, 1031 std::move(__e), __a)) 1032 { } 1033 1034 executor& operator=(const executor&) noexcept = default; 1035 executor& operator=(executor&&) noexcept = default; 1036 1037 executor& 1038 operator=(nullptr_t) noexcept 1039 { 1040 _M_target = nullptr; 1041 return *this; 1042 } 1043 1044 template<typename _Executor> 1045 executor& 1046 operator=(_Executor __e) 1047 { 1048 executor(std::move(__e)).swap(*this); 1049 return *this; 1050 } 1051 1052 ~executor() = default; 1053 1054 // executor modifiers: 1055 1056 void 1057 swap(executor& __other) noexcept 1058 { _M_target.swap(__other._M_target); } 1059 1060 template<typename _Executor, typename _Alloc> 1061 void 1062 assign(_Executor __e, const _Alloc& __a) 1063 { executor(allocator_arg, __a, std::move(__e)).swap(*this); } 1064 1065 // executor operations: 1066 1067 execution_context& 1068 context() const noexcept 1069 { 1070 __glibcxx_assert( _M_target ); 1071 return _M_target->context(); 1072 } 1073 1074 void 1075 on_work_started() const noexcept 1076 { 1077 __glibcxx_assert( _M_target ); 1078 return _M_target->on_work_started(); 1079 } 1080 1081 void 1082 on_work_finished() const noexcept 1083 { 1084 __glibcxx_assert( _M_target ); 1085 return _M_target->on_work_finished(); 1086 } 1087 1088 template<typename _Func, typename _Alloc> 1089 void 1090 dispatch(_Func&& __f, const _Alloc& __a) const 1091 { 1092 if (!_M_target) 1093 __throw_bad_executor(); 1094 // _M_target->dispatch({allocator_arg, __a, std::forward<_Func>(__f)}); 1095 _M_target->dispatch(std::forward<_Func>(__f)); 1096 } 1097 1098 template<typename _Func, typename _Alloc> 1099 void 1100 post(_Func&& __f, const _Alloc& __a) const 1101 { 1102 if (!_M_target) 1103 __throw_bad_executor(); 1104 // _M_target->post({allocator_arg, __a, std::forward<_Func>(__f)}); 1105 _M_target->post(std::forward<_Func>(__f)); 1106 } 1107 1108 template<typename _Func, typename _Alloc> 1109 void 1110 defer(_Func&& __f, const _Alloc& __a) const 1111 { 1112 if (!_M_target) 1113 __throw_bad_executor(); 1114 // _M_target->defer({allocator_arg, __a, std::forward<_Func>(__f)}); 1115 _M_target->defer(std::forward<_Func>(__f)); 1116 } 1117 1118 // executor capacity: 1119 1120 explicit operator bool() const noexcept 1121 { return static_cast<bool>(_M_target); } 1122 1123 // executor target access: 1124 1125#if __cpp_rtti 1126 const type_info& 1127 target_type() const noexcept 1128 { 1129 if (_M_target) 1130 return *static_cast<const type_info*>(_M_target->target_type()); 1131 return typeid(void); 1132 } 1133#endif 1134 1135 template<typename _Executor> 1136 _Executor* 1137 target() noexcept 1138 { 1139 void* __p = nullptr; 1140 if (_M_target) 1141 { 1142 if (_M_target->_M_func == &_Tgt1<remove_cv_t<_Executor>>::_S_func) 1143 __p = _M_target->_M_func(_M_target.get(), nullptr); 1144#if __cpp_rtti 1145 else 1146 __p = _M_target->target(&typeid(_Executor)); 1147#endif 1148 } 1149 return static_cast<_Executor*>(__p); 1150 } 1151 1152 template<typename _Executor> 1153 const _Executor* 1154 target() const noexcept 1155 { 1156 const void* __p = nullptr; 1157 if (_M_target) 1158 { 1159 if (_M_target->_M_func == &_Tgt1<remove_cv_t<_Executor>>::_S_func) 1160 return (_Executor*)_M_target->_M_func(_M_target.get(), nullptr); 1161#if __cpp_rtti 1162 else 1163 __p = _M_target->target(&typeid(_Executor)); 1164#endif 1165 } 1166 return static_cast<const _Executor*>(__p); 1167 } 1168 1169 private: 1170 struct _Tgt 1171 { 1172 virtual void on_work_started() const noexcept = 0; 1173 virtual void on_work_finished() const noexcept = 0; 1174 virtual execution_context& context() const noexcept = 0; 1175 virtual void dispatch(std::function<void()>) const = 0; 1176 virtual void post(std::function<void()>) const = 0; 1177 virtual void defer(std::function<void()>) const = 0; 1178 virtual const void* target_type() const noexcept = 0; 1179 virtual void* target(const void*) noexcept = 0; 1180 virtual bool _M_equals(_Tgt*) const noexcept = 0; 1181 1182 using _Func = void* (_Tgt*, const _Tgt*); 1183 _Func* _M_func; // Provides access to target without RTTI 1184 }; 1185 1186 template<typename _Ex> 1187 struct _Tgt1 : _Tgt 1188 { 1189 explicit 1190 _Tgt1(_Ex&& __ex) 1191 : _M_ex(std::move(__ex)) 1192 { this->_M_func = &_S_func; } 1193 1194 void 1195 on_work_started() const noexcept override 1196 { _M_ex.on_work_started(); } 1197 1198 void 1199 on_work_finished() const noexcept override 1200 { _M_ex.on_work_finished(); } 1201 1202 execution_context& 1203 context() const noexcept override 1204 { return _M_ex.context(); } 1205 1206 void 1207 dispatch(std::function<void()> __f) const override 1208 { _M_ex.dispatch(std::move(__f), allocator<void>()); } 1209 1210 void 1211 post(std::function<void()> __f) const override 1212 { _M_ex.post(std::move(__f), allocator<void>()); } 1213 1214 void 1215 defer(std::function<void()> __f) const override 1216 { _M_ex.defer(std::move(__f), allocator<void>()); } 1217 1218 const void* 1219 target_type() const noexcept override 1220 { 1221#if __cpp_rtti 1222 return &typeid(_Ex); 1223#else 1224 return nullptr; 1225#endif 1226 } 1227 1228 void* 1229 target(const void* __ti) noexcept override 1230 { 1231#if __cpp_rtti 1232 if (*static_cast<const type_info*>(__ti) == typeid(_Ex)) 1233 return std::__addressof(_M_ex); 1234#endif 1235 return nullptr; 1236 } 1237 1238 bool 1239 _M_equals(_Tgt* __tgt) const noexcept override 1240 { 1241#if __cpp_rtti 1242 if (const void* __p = __tgt->target(&typeid(_Ex))) 1243 return *static_cast<const _Ex*>(__p) == _M_ex; 1244#endif 1245 return false; 1246 } 1247 1248 _Ex _M_ex [[__no_unique_address__]]; 1249 1250 static void* 1251 _S_func(_Tgt* __p, const _Tgt* __q) noexcept 1252 { 1253 auto& __ex = static_cast<_Tgt1*>(__p)->_M_ex; 1254 if (__q) 1255 { 1256 if (__ex == static_cast<const _Tgt1*>(__q)->_M_ex) 1257 return __p; 1258 else 1259 return nullptr; 1260 } 1261 else 1262 return std::__addressof(__ex); 1263 } 1264 }; 1265 1266 template<typename _Ex, typename _Alloc> 1267 struct _Tgt2 : _Tgt1<_Ex> 1268 { 1269 explicit 1270 _Tgt2(_Ex&& __ex, const _Alloc& __a) 1271 : _Tgt1<_Ex>(std::move(__ex)), _M_alloc(__a) { } 1272 1273 void 1274 dispatch(std::function<void()> __f) const override 1275 { this->_M_ex.dispatch(std::move(__f), _M_alloc); } 1276 1277 void 1278 post(std::function<void()> __f) const override 1279 { this->_M_ex.post(std::move(__f), _M_alloc); } 1280 1281 void 1282 defer(std::function<void()> __f) const override 1283 { this->_M_ex.defer(std::move(__f), _M_alloc); } 1284 1285 _Alloc _M_alloc [[__no_unique_address__]]; 1286 }; 1287 1288 // Partial specialization for std::allocator<T>. 1289 // Don't store the allocator. 1290 template<typename _Ex, typename _Tp> 1291 struct _Tgt2<_Ex, std::allocator<_Tp>> : _Tgt1<_Ex> 1292 { }; 1293 1294 friend bool 1295 operator==(const executor& __a, const executor& __b) noexcept 1296 { 1297 _Tgt* __ta = __a._M_target.get(); 1298 _Tgt* __tb = __b._M_target.get(); 1299 if (__ta == __tb) 1300 return true; 1301 if (!__ta || !__tb) 1302 return false; 1303 if (__ta->_M_func == __tb->_M_func) 1304 return __ta->_M_func(__ta, __tb); 1305 return __ta->_M_equals(__tb); 1306 } 1307 1308 shared_ptr<_Tgt> _M_target; 1309 }; 1310 1311 template<> struct is_executor<executor> : true_type { }; 1312 1313 /// executor comparisons 1314 inline bool 1315 operator==(const executor& __e, nullptr_t) noexcept 1316 { return !__e; } 1317 1318 inline bool 1319 operator==(nullptr_t, const executor& __e) noexcept 1320 { return !__e; } 1321 1322 inline bool 1323 operator!=(const executor& __a, const executor& __b) noexcept 1324 { return !(__a == __b); } 1325 1326 inline bool 1327 operator!=(const executor& __e, nullptr_t) noexcept 1328 { return (bool)__e; } 1329 1330 inline bool 1331 operator!=(nullptr_t, const executor& __e) noexcept 1332 { return (bool)__e; } 1333 1334 /// Swap two executor objects. 1335 inline void swap(executor& __a, executor& __b) noexcept { __a.swap(__b); } 1336 1337 1338 template<typename _CompletionHandler> 1339 struct __dispatcher 1340 { 1341 explicit 1342 __dispatcher(_CompletionHandler& __h) 1343 : _M_h(std::move(__h)), _M_w(net::make_work_guard(_M_h)) 1344 { } 1345 1346 void operator()() 1347 { 1348 auto __alloc = net::get_associated_allocator(_M_h); 1349 _M_w.get_executor().dispatch(std::move(_M_h), __alloc); 1350 _M_w.reset(); 1351 } 1352 1353 _CompletionHandler _M_h; 1354 decltype(net::make_work_guard(_M_h)) _M_w; 1355 }; 1356 1357 template<typename _CompletionHandler> 1358 inline __dispatcher<_CompletionHandler> 1359 __make_dispatcher(_CompletionHandler& __h) 1360 { return __dispatcher<_CompletionHandler>{__h}; } 1361 1362 1363 1364 // dispatch: 1365 1366 template<typename _CompletionToken> 1367 inline __deduced_t<_CompletionToken, void()> 1368 dispatch(_CompletionToken&& __token) 1369 { 1370 async_completion<_CompletionToken, void()> __cmpl{__token}; 1371 auto __ex = net::get_associated_executor(__cmpl.completion_handler); 1372 auto __alloc = net::get_associated_allocator(__cmpl.completion_handler); 1373 __ex.dispatch(std::move(__cmpl.completion_handler), __alloc); 1374 return __cmpl.result.get(); 1375 } 1376 1377 template<typename _Executor, typename _CompletionToken> 1378 inline 1379 enable_if_t<is_executor<_Executor>::value, 1380 __deduced_t<_CompletionToken, void()>> 1381 dispatch(const _Executor& __ex, _CompletionToken&& __token) 1382 { 1383 async_completion<_CompletionToken, void()> __cmpl{__token}; 1384 auto __alloc = net::get_associated_allocator(__cmpl.completion_handler); 1385 __ex.dispatch(net::__make_dispatcher(__cmpl.completion_handler), 1386 __alloc); 1387 return __cmpl.result.get(); 1388 } 1389 1390 template<typename _ExecutionContext, typename _CompletionToken> 1391 inline 1392 enable_if_t<__is_exec_context<_ExecutionContext>::value, 1393 __deduced_t<_CompletionToken, void()>> 1394 dispatch(_ExecutionContext& __ctx, _CompletionToken&& __token) 1395 { 1396 return net::dispatch(__ctx.get_executor(), 1397 forward<_CompletionToken>(__token)); 1398 } 1399 1400 // post: 1401 1402 template<typename _CompletionToken> 1403 inline __deduced_t<_CompletionToken, void()> 1404 post(_CompletionToken&& __token) 1405 { 1406 async_completion<_CompletionToken, void()> __cmpl{__token}; 1407 auto __ex = net::get_associated_executor(__cmpl.completion_handler); 1408 auto __alloc = net::get_associated_allocator(__cmpl.completion_handler); 1409 __ex.post(std::move(__cmpl.completion_handler), __alloc); 1410 return __cmpl.result.get(); 1411 } 1412 1413 template<typename _Executor, typename _CompletionToken> 1414 inline 1415 enable_if_t<is_executor<_Executor>::value, 1416 __deduced_t<_CompletionToken, void()>> 1417 post(const _Executor& __ex, _CompletionToken&& __token) 1418 { 1419 async_completion<_CompletionToken, void()> __cmpl{__token}; 1420 auto __alloc = net::get_associated_allocator(__cmpl.completion_handler); 1421 __ex.post(net::__make_dispatcher(__cmpl.completion_handler), __alloc); 1422 return __cmpl.result.get(); 1423 } 1424 1425 template<typename _ExecutionContext, typename _CompletionToken> 1426 inline 1427 enable_if_t<__is_exec_context<_ExecutionContext>::value, 1428 __deduced_t<_CompletionToken, void()>> 1429 post(_ExecutionContext& __ctx, _CompletionToken&& __token) 1430 { 1431 return net::post(__ctx.get_executor(), 1432 forward<_CompletionToken>(__token)); 1433 } 1434 1435 // defer: 1436 1437 template<typename _CompletionToken> 1438 inline __deduced_t<_CompletionToken, void()> 1439 defer(_CompletionToken&& __token) 1440 { 1441 async_completion<_CompletionToken, void()> __cmpl{__token}; 1442 auto __ex = net::get_associated_executor(__cmpl.completion_handler); 1443 auto __alloc = net::get_associated_allocator(__cmpl.completion_handler); 1444 __ex.defer(std::move(__cmpl.completion_handler), __alloc); 1445 return __cmpl.result.get(); 1446 } 1447 1448 template<typename _Executor, typename _CompletionToken> 1449 inline 1450 enable_if_t<is_executor<_Executor>::value, 1451 __deduced_t<_CompletionToken, void()>> 1452 defer(const _Executor& __ex, _CompletionToken&& __token) 1453 { 1454 async_completion<_CompletionToken, void()> __cmpl{__token}; 1455 auto __alloc = net::get_associated_allocator(__cmpl.completion_handler); 1456 __ex.defer(net::__make_dispatcher(__cmpl.completion_handler), __alloc); 1457 return __cmpl.result.get(); 1458 } 1459 1460 template<typename _ExecutionContext, typename _CompletionToken> 1461 inline 1462 enable_if_t<__is_exec_context<_ExecutionContext>::value, 1463 __deduced_t<_CompletionToken, void()>> 1464 defer(_ExecutionContext& __ctx, _CompletionToken&& __token) 1465 { 1466 return net::defer(__ctx.get_executor(), 1467 forward<_CompletionToken>(__token)); 1468 } 1469 1470 1471 template<typename _Executor> 1472 class strand 1473 { 1474 public: 1475 // types: 1476 1477 using inner_executor_type = _Executor; 1478 1479 // construct / copy / destroy: 1480 1481 strand(); // TODO make state 1482 1483 explicit strand(_Executor __ex) : _M_inner_ex(__ex) { } // TODO make state 1484 1485 template<typename _Alloc> 1486 strand(allocator_arg_t, const _Alloc& __a, _Executor __ex) 1487 : _M_inner_ex(__ex) { } // TODO make state 1488 1489 strand(const strand& __other) noexcept 1490 : _M_state(__other._M_state), _M_inner_ex(__other._M_inner_ex) { } 1491 1492 strand(strand&& __other) noexcept 1493 : _M_state(std::move(__other._M_state)), 1494 _M_inner_ex(std::move(__other._M_inner_ex)) { } 1495 1496 template<typename _OtherExecutor> 1497 strand(const strand<_OtherExecutor>& __other) noexcept 1498 : _M_state(__other._M_state), _M_inner_ex(__other._M_inner_ex) { } 1499 1500 template<typename _OtherExecutor> 1501 strand(strand<_OtherExecutor>&& __other) noexcept 1502 : _M_state(std::move(__other._M_state)), 1503 _M_inner_ex(std::move(__other._M_inner_ex)) { } 1504 1505 strand& 1506 operator=(const strand& __other) noexcept 1507 { 1508 static_assert(is_copy_assignable<_Executor>::value, 1509 "inner executor type must be CopyAssignable"); 1510 1511 // TODO lock __other 1512 // TODO copy state 1513 _M_inner_ex = __other._M_inner_ex; 1514 return *this; 1515 } 1516 1517 strand& 1518 operator=(strand&& __other) noexcept 1519 { 1520 static_assert(is_move_assignable<_Executor>::value, 1521 "inner executor type must be MoveAssignable"); 1522 1523 // TODO move state 1524 _M_inner_ex = std::move(__other._M_inner_ex); 1525 return *this; 1526 } 1527 1528 template<typename _OtherExecutor> 1529 strand& 1530 operator=(const strand<_OtherExecutor>& __other) noexcept 1531 { 1532 static_assert(is_convertible<_OtherExecutor, _Executor>::value, 1533 "inner executor type must be compatible"); 1534 1535 // TODO lock __other 1536 // TODO copy state 1537 _M_inner_ex = __other._M_inner_ex; 1538 return *this; 1539 } 1540 1541 template<typename _OtherExecutor> 1542 strand& 1543 operator=(strand<_OtherExecutor>&& __other) noexcept 1544 { 1545 static_assert(is_convertible<_OtherExecutor, _Executor>::value, 1546 "inner executor type must be compatible"); 1547 1548 // TODO move state 1549 _M_inner_ex = std::move(__other._M_inner_ex); 1550 return *this; 1551 } 1552 1553 ~strand() 1554 { 1555 // the task queue outlives this object if non-empty 1556 // TODO create circular ref in queue? 1557 } 1558 1559 // strand operations: 1560 1561 inner_executor_type 1562 get_inner_executor() const noexcept 1563 { return _M_inner_ex; } 1564 1565 bool 1566 running_in_this_thread() const noexcept 1567 { return _M_state->running_in_this_thread(); } 1568 1569 execution_context& 1570 context() const noexcept 1571 { return _M_inner_ex.context(); } 1572 1573 void on_work_started() const noexcept { _M_inner_ex.on_work_started(); } 1574 void on_work_finished() const noexcept { _M_inner_ex.on_work_finished(); } 1575 1576 template<typename _Func, typename _Alloc> 1577 void 1578 dispatch(_Func&& __f, const _Alloc& __a) const 1579 { 1580 if (running_in_this_thread()) 1581 decay_t<_Func>{std::forward<_Func>(__f)}(); 1582 else 1583 post(std::forward<_Func>(__f), __a); 1584 } 1585 1586 template<typename _Func, typename _Alloc> 1587 void 1588 post(_Func&& __f, const _Alloc& __a) const; // TODO 1589 1590 template<typename _Func, typename _Alloc> 1591 void 1592 defer(_Func&& __f, const _Alloc& __a) const 1593 { post(std::forward<_Func>(__f), __a); } 1594 1595 private: 1596 friend bool 1597 operator==(const strand& __a, const strand& __b) 1598 { return __a._M_state == __b._M_state; } 1599 1600 // TODO add synchronised queue 1601 struct _State 1602 { 1603#if defined(_GLIBCXX_HAS_GTHREADS) 1604 bool 1605 running_in_this_thread() const noexcept 1606 { return std::this_thread::get_id() == _M_running_on; } 1607 1608 std::thread::id _M_running_on; 1609#else 1610 bool running_in_this_thread() const { return true; } 1611#endif 1612 }; 1613 shared_ptr<_State> _M_state; 1614 _Executor _M_inner_ex; 1615 }; 1616 1617#if defined(_GLIBCXX_HAS_GTHREADS) 1618 1619 // Completion token for asynchronous operations initiated with use_future. 1620 template<typename _Func, typename _Alloc> 1621 struct __use_future_ct 1622 { 1623 std::tuple<_Func, _Alloc> _M_t; 1624 }; 1625 1626 template<typename _Func, typename _Tp> 1627 struct __use_future_ct<_Func, std::allocator<_Tp>> 1628 { 1629 _Func _M_f; 1630 }; 1631 1632 template<typename _ProtoAllocator = allocator<void>> 1633 class use_future_t 1634 { 1635 public: 1636 // use_future_t types: 1637 using allocator_type = _ProtoAllocator; 1638 1639 // use_future_t members: 1640 constexpr 1641 use_future_t() 1642 noexcept(is_nothrow_default_constructible<_ProtoAllocator>::value) 1643 : _M_alloc() { } 1644 1645 explicit 1646 use_future_t(const _ProtoAllocator& __a) noexcept : _M_alloc(__a) { } 1647 1648 template<typename _OtherAllocator> 1649 use_future_t<_OtherAllocator> 1650 rebind(const _OtherAllocator& __a) const noexcept 1651 { return use_future_t<_OtherAllocator>(__a); } 1652 1653 allocator_type get_allocator() const noexcept { return _M_alloc; } 1654 1655 template<typename _Func> 1656 auto 1657 operator()(_Func&& __f) const 1658 { 1659 using _Token = __use_future_ct<decay_t<_Func>, _ProtoAllocator>; 1660 return _Token{ {std::forward<_Func>(__f), _M_alloc} }; 1661 } 1662 1663 private: 1664 _ProtoAllocator _M_alloc; 1665 }; 1666 1667 template<typename _Tp> 1668 class use_future_t<std::allocator<_Tp>> 1669 { 1670 public: 1671 // use_future_t types: 1672 using allocator_type = std::allocator<_Tp>; 1673 1674 // use_future_t members: 1675 constexpr use_future_t() noexcept = default; 1676 1677 explicit 1678 use_future_t(const allocator_type& __a) noexcept { } 1679 1680 template<class _Up> 1681 use_future_t<std::allocator<_Up>> 1682 rebind(const std::allocator<_Up>& __a) const noexcept 1683 { return use_future_t<std::allocator<_Up>>(__a); } 1684 1685 allocator_type get_allocator() const noexcept { return {}; } 1686 1687 template<typename _Func> 1688 auto 1689 operator()(_Func&& __f) const 1690 { 1691 using _Token = __use_future_ct<decay_t<_Func>, allocator_type>; 1692 return _Token{std::forward<_Func>(__f)}; 1693 } 1694 }; 1695 1696 constexpr use_future_t<> use_future = use_future_t<>(); 1697 1698 template<typename _Func, typename _Alloc, typename _Res, typename... _Args> 1699 class async_result<__use_future_ct<_Func, _Alloc>, _Res(_Args...)>; 1700 1701 template<typename _Result, typename _Executor> 1702 struct __use_future_ex; 1703 1704 // Completion handler for asynchronous operations initiated with use_future. 1705 template<typename _Func, typename... _Args> 1706 struct __use_future_ch 1707 { 1708 template<typename _Alloc> 1709 explicit 1710 __use_future_ch(__use_future_ct<_Func, _Alloc>&& __token) 1711 : _M_f{ std::move(std::get<0>(__token._M_t)) }, 1712 _M_promise{ std::get<1>(__token._M_t) } 1713 { } 1714 1715 template<typename _Tp> 1716 explicit 1717 __use_future_ch(__use_future_ct<_Func, std::allocator<_Tp>>&& __token) 1718 : _M_f{ std::move(__token._M_f) } 1719 { } 1720 1721 void 1722 operator()(_Args&&... __args) 1723 { 1724 __try 1725 { 1726 _M_promise.set_value(_M_f(std::forward<_Args>(__args)...)); 1727 } 1728 __catch(__cxxabiv1::__forced_unwind&) 1729 { 1730 __throw_exception_again; 1731 } 1732 __catch(...) 1733 { 1734 _M_promise.set_exception(std::current_exception()); 1735 } 1736 } 1737 1738 using __result = result_of_t<_Func(decay_t<_Args>...)>; 1739 1740 future<__result> get_future() { return _M_promise.get_future(); } 1741 1742 private: 1743 template<typename _Result, typename _Executor> 1744 friend struct __use_future_ex; 1745 1746 _Func _M_f; 1747 mutable promise<__result> _M_promise; 1748 }; 1749 1750 // Specialization of async_result for operations initiated with use_future. 1751 template<typename _Func, typename _Alloc, typename _Res, typename... _Args> 1752 class async_result<__use_future_ct<_Func, _Alloc>, _Res(_Args...)> 1753 { 1754 public: 1755 using completion_handler_type = __use_future_ch<_Func, _Args...>; 1756 using return_type = future<typename completion_handler_type::__result>; 1757 1758 explicit 1759 async_result(completion_handler_type& __h) 1760 : _M_future(__h.get_future()) 1761 { } 1762 1763 async_result(const async_result&) = delete; 1764 async_result& operator=(const async_result&) = delete; 1765 1766 return_type get() { return std::move(_M_future); } 1767 1768 private: 1769 return_type _M_future; 1770 }; 1771 1772 template<typename _Result, typename _Executor> 1773 struct __use_future_ex 1774 { 1775 template<typename _Handler> 1776 __use_future_ex(const _Handler& __h, _Executor __ex) 1777 : _M_t(__h._M_promise, __ex) 1778 { } 1779 1780 template<typename _Fn, typename _Alloc> 1781 void 1782 dispatch(_Fn&& __fn) 1783 { 1784 __try 1785 { 1786 std::get<1>(_M_t).dispatch(std::forward<_Fn>(__fn)); 1787 } 1788 __catch(__cxxabiv1::__forced_unwind&) 1789 { 1790 __throw_exception_again; 1791 } 1792 __catch(...) 1793 { 1794 std::get<0>(_M_t).set_exception(std::current_exception()); 1795 } 1796 } 1797 1798 template<typename _Fn, typename _Alloc> 1799 void 1800 post(_Fn&& __fn) 1801 { 1802 __try 1803 { 1804 std::get<1>(_M_t).post(std::forward<_Fn>(__fn)); 1805 } 1806 __catch(__cxxabiv1::__forced_unwind&) 1807 { 1808 __throw_exception_again; 1809 } 1810 __catch(...) 1811 { 1812 std::get<0>(_M_t).set_exception(std::current_exception()); 1813 } 1814 } 1815 1816 template<typename _Fn, typename _Alloc> 1817 void 1818 defer(_Fn&& __fn) 1819 { 1820 __try 1821 { 1822 std::get<1>(_M_t).defer(std::forward<_Fn>(__fn)); 1823 } 1824 __catch(__cxxabiv1::__forced_unwind&) 1825 { 1826 __throw_exception_again; 1827 } 1828 __catch(...) 1829 { 1830 std::get<0>(_M_t).set_exception(std::current_exception()); 1831 } 1832 } 1833 1834 private: 1835 tuple<promise<_Result>&, _Executor> _M_t; 1836 }; 1837 1838 template<typename _Func, typename... _Args, typename _Executor> 1839 struct associated_executor<__use_future_ch<_Func, _Args...>, _Executor> 1840 { 1841 private: 1842 using __handler = __use_future_ch<_Func, _Args...>; 1843 1844 using type = __use_future_ex<typename __handler::__result, _Executor>; 1845 1846 static type 1847 get(const __handler& __h, const _Executor& __ex) 1848 { return { __h, __ex }; } 1849 }; 1850 1851#if 0 1852 1853 // [async.use.future.traits] 1854 template<typename _Allocator, typename _Ret, typename... _Args> 1855 class handler_type<use_future_t<_Allocator>, _Ret(_Args...)> // TODO uglify name 1856 { 1857 template<typename... _Args> 1858 struct __is_error_result : false_type { }; 1859 1860 template<typename... _Args> 1861 struct __is_error_result<error_code, _Args...> : true_type { }; 1862 1863 template<typename... _Args> 1864 struct __is_error_result<exception_ptr, _Args...> : true_type { }; 1865 1866 static exception_ptr 1867 _S_exptr(exception_ptr& __ex) 1868 { return std::move(__ex); } 1869 1870 static exception_ptr 1871 _S_exptr(const error_code& __ec) 1872 { return make_exception_ptr(system_error(__ec)); } 1873 1874 template<bool _IsError, typename... _UArgs> 1875 struct _Type; 1876 1877 // N == 0 1878 template<bool _IsError> 1879 struct _Type<_IsError> 1880 { 1881 std::promise<void> _M_promise; 1882 1883 void 1884 operator()() 1885 { 1886 _M_promise.set_value(); 1887 } 1888 }; 1889 1890 // N == 1, U0 is error_code or exception_ptr 1891 template<typename _UArg0> 1892 struct _Type<true, _UArg0> 1893 { 1894 std::promise<void> _M_promise; 1895 1896 template<typename _Arg0> 1897 void 1898 operator()(_Arg0&& __a0) 1899 { 1900 if (__a0) 1901 _M_promise.set_exception(_S_exptr(__a0)); 1902 else 1903 _M_promise.set_value(); 1904 } 1905 }; 1906 1907 // N == 1, U0 is not error_code or exception_ptr 1908 template<typename _UArg0> 1909 struct _Type<false, _UArg0> 1910 { 1911 std::promise<_UArg0> _M_promise; 1912 1913 template<typename _Arg0> 1914 void 1915 operator()(_Arg0&& __a0) 1916 { 1917 _M_promise.set_value(std::forward<_Arg0>(__a0)); 1918 } 1919 }; 1920 1921 // N == 2, U0 is error_code or exception_ptr 1922 template<typename _UArg0, typename _UArg1> 1923 struct _Type<true, _UArg0, _UArg1> 1924 { 1925 std::promise<_UArg1> _M_promise; 1926 1927 template<typename _Arg0, typename _Arg1> 1928 void 1929 operator()(_Arg0&& __a0, _Arg1&& __a1) 1930 { 1931 if (__a0) 1932 _M_promise.set_exception(_S_exptr(__a0)); 1933 else 1934 _M_promise.set_value(std::forward<_Arg1>(__a1)); 1935 } 1936 }; 1937 1938 // N >= 2, U0 is not error_code or exception_ptr 1939 template<typename... _UArgs> 1940 struct _Type<false, _UArgs...> 1941 { 1942 static_assert(sizeof...(_UArgs) > 1, "wrong partial specialization"); 1943 1944 std::promise<tuple<_UArgs...>> _M_promise; 1945 1946 template<typename... _Args> 1947 void 1948 operator()(_Args&&... __args) 1949 { 1950 _M_promise.set_value( 1951 std::forward_as_tuple(std::forward<_Args>(__args)...)); 1952 } 1953 }; 1954 1955 // N > 2, U0 is error_code or exception_ptr 1956 template<typename _UArg0, typename... _UArgs> 1957 struct _Type<true, _UArg0, _UArgs...> 1958 { 1959 static_assert(sizeof...(_UArgs) > 1, "wrong partial specialization"); 1960 1961 std::promise<tuple<_UArgs...>> _M_promise; 1962 1963 template<typename _Arg0, typename... _Args> 1964 void 1965 operator()(_Arg0&& __a0, _Args&&... __args) 1966 { 1967 if (__a0) 1968 _M_promise.set_exception(_S_exptr(__a0)); 1969 else 1970 _M_promise.set_value( 1971 std::forward_as_tuple(std::forward<_Args>(__args)...)); 1972 } 1973 }; 1974 1975 public: 1976 using type = 1977 _Type<__is_error_result<_Args...>::value, decay_t<_Args>...>; 1978 }; 1979 1980 1981 template<typename _Alloc, typename _Ret, typename... _Args> 1982 struct async_result<use_future_t<_Alloc>, _Ret(_Args...)> 1983 { 1984 using completion_handler_type 1985 = typename handler_type<use_future_t<_Alloc>, _Ret(_Args...)>::type; 1986 1987 using return_type = void; // XXX TODO ???; 1988 1989 explicit 1990 async_result(completion_handler_type& __h) : _M_handler(__h) { } 1991 1992 auto get() { return _M_handler._M_provider.get_future(); } 1993 1994 async_result(const async_result&) = delete; 1995 async_result& operator=(const async_result&) = delete; 1996 1997 return_type get() { return _M_handler._M_promise.get_future(); } 1998 1999 private: 2000 completion_handler_type& _M_handler; 2001 }; 2002 2003 // TODO specialize associated_executor for 2004 // async_result<use_future_t<A>, Sig>::completion_handler_type 2005 // to use a __use_future_ex 2006 // (probably need to move _Type outside of handler_type so we don't have 2007 // a non-deduced context) 2008 2009#endif 2010 2011 // [async.packaged.task.specializations] 2012 template<typename _Ret, typename... _Args, typename _Signature> 2013 class async_result<packaged_task<_Ret(_Args...)>, _Signature> 2014 { 2015 public: 2016 using completion_handler_type = packaged_task<_Ret(_Args...)>; 2017 using return_type = future<_Ret>; 2018 2019 explicit 2020 async_result(completion_handler_type& __h) 2021 : _M_future(__h.get_future()) { } 2022 2023 async_result(const async_result&) = delete; 2024 async_result& operator=(const async_result&) = delete; 2025 2026 return_type get() { return std::move(_M_future); } 2027 2028 private: 2029 return_type _M_future; 2030 }; 2031 2032#endif // _GLIBCXX_HAS_GTHREADS 2033 2034 /// @} 2035 2036} // namespace v1 2037} // namespace net 2038} // namespace experimental 2039 2040 template<typename _Alloc> 2041 struct uses_allocator<experimental::net::executor, _Alloc> 2042 : true_type {}; 2043 2044_GLIBCXX_END_NAMESPACE_VERSION 2045} // namespace std 2046 2047#endif // C++14 2048 2049#endif // _GLIBCXX_EXPERIMENTAL_EXECUTOR 2050