ceph/src/boost/boost/context/fiber_winfib.hpp

   1
   2 //          Copyright Oliver Kowalke 2017.
   3 // Distributed under the Boost Software License, Version 1.0.
   4 //    (See accompanying file LICENSE_1_0.txt or copy at
   5 //          http://www.boost.org/LICENSE_1_0.txt)
   6
   7 #ifndef BOOST_CONTEXT_FIBER_H
   8 #define BOOST_CONTEXT_FIBER_H
   9
  10 #include <windows.h>
  11
  12 #include <boost/context/detail/config.hpp>
  13
  14 #include <algorithm>
  15 #include <cstddef>
  16 #include <cstdint>
  17 #include <cstdlib>
  18 #include <cstring>
  19 #include <functional>
  20 #include <memory>
  21 #include <ostream>
  22 #include <system_error>
  23 #include <tuple>
  24 #include <utility>
  25
  26 #include <boost/assert.hpp>
  27 #include <boost/config.hpp>
  28
  29 #include <boost/context/detail/disable_overload.hpp>
  30 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
  31 #include <boost/context/detail/exchange.hpp>
  32 #endif
  33 #if defined(BOOST_NO_CXX17_STD_INVOKE)
  34 #include <boost/context/detail/invoke.hpp>
  35 #endif
  36 #include <boost/context/fixedsize_stack.hpp>
  37 #include <boost/context/flags.hpp>
  38 #include <boost/context/preallocated.hpp>
  39 #include <boost/context/stack_context.hpp>
  40
  41 #ifdef BOOST_HAS_ABI_HEADERS
  42 # include BOOST_ABI_PREFIX
  43 #endif
  44
  45 #if defined(BOOST_MSVC)
  46 # pragma warning(push)
  47 # pragma warning(disable: 4702)
  48 #endif
  49
  50 namespace boost {
  51 namespace context {
  52 namespace detail {
  53
  54 // tampoline function
  55 // entered if the execution context
  56 // is resumed for the first time
  57 template< typename Record >
  58 static VOID WINAPI fiber_entry_func( LPVOID data) noexcept {
  59     Record * record = static_cast< Record * >( data);
  60     BOOST_ASSERT( nullptr != record);
  61     // start execution of toplevel context-function
  62     record->run();
  63 }
  64
  65 struct BOOST_CONTEXT_DECL fiber_activation_record {
  66     LPVOID                                                      fiber{ nullptr };
  67     stack_context                                               sctx{};
  68     bool                                                        main_ctx{ true };
  69     fiber_activation_record                                       *   from{ nullptr };
  70     std::function< fiber_activation_record*(fiber_activation_record*&) >    ontop{};
  71     bool                                                        terminated{ false };
  72     bool                                                        force_unwind{ false };
  73
  74     static fiber_activation_record *& current() noexcept;
  75
  76     // used for toplevel-context
  77     // (e.g. main context, thread-entry context)
  78     fiber_activation_record() noexcept {
  79 #if ( _WIN32_WINNT > 0x0600)
  80         if ( ::IsThreadAFiber() ) {
  81             fiber = ::GetCurrentFiber();
  82         } else {
  83             fiber = ::ConvertThreadToFiber( nullptr);
  84         }
  85 #else
  86         fiber = ::ConvertThreadToFiber( nullptr);
  87         if ( BOOST_UNLIKELY( nullptr == fiber) ) {
  88             BOOST_ASSERT( ERROR_ALREADY_FIBER == ::GetLastError());
  89             fiber = ::GetCurrentFiber();
  90             BOOST_ASSERT( nullptr != fiber);
  91             BOOST_ASSERT( reinterpret_cast< LPVOID >( 0x1E00) != fiber);
  92         }
  93 #endif
  94     }
  95
  96     fiber_activation_record( stack_context sctx_) noexcept :
  97         sctx{ sctx_ },
  98         main_ctx{ false } {
  99     }
 100
 101     virtual ~fiber_activation_record() {
 102         if ( BOOST_UNLIKELY( main_ctx) ) {
 103             ::ConvertFiberToThread();
 104         } else {
 105             ::DeleteFiber( fiber);
 106         }
 107     }
 108
 109     fiber_activation_record( fiber_activation_record const&) = delete;
 110     fiber_activation_record & operator=( fiber_activation_record const&) = delete;
 111
 112     bool is_main_context() const noexcept {
 113         return main_ctx;
 114     }
 115
 116     fiber_activation_record * resume() {
 117         from = current();
 118         // store `this` in static, thread local pointer
 119         // `this` will become the active (running) context
 120         current() = this;
 121         // context switch from parent context to `this`-context
 122         // context switch
 123         ::SwitchToFiber( fiber);
 124 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
 125         return detail::exchange( current()->from, nullptr);
 126 #else
 127         return std::exchange( current()->from, nullptr);
 128 #endif
 129     }
 130
 131     template< typename Ctx, typename Fn >
 132     fiber_activation_record * resume_with( Fn && fn) {
 133         from = current();
 134         // store `this` in static, thread local pointer
 135         // `this` will become the active (running) context
 136         // returned by fiber::current()
 137         current() = this;
 138 #if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)
 139         current()->ontop = std::bind(
 140                 [](typename std::decay< Fn >::type & fn, fiber_activation_record *& ptr){
 141                     Ctx c{ ptr };
 142                     c = fn( std::move( c) );
 143                     if ( ! c) {
 144                         ptr = nullptr;
 145                     }
 146 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
 147                     return exchange( c.ptr_, nullptr);
 148 #else
 149                     return std::exchange( c.ptr_, nullptr);
 150 #endif
 151                 },
 152                 std::forward< Fn >( fn),
 153                 std::placeholders::_1);
 154 #else
 155         current()->ontop = [fn=std::forward<Fn>(fn)](fiber_activation_record *& ptr){
 156             Ctx c{ ptr };
 157             c = fn( std::move( c) );
 158             if ( ! c) {
 159                 ptr = nullptr;
 160             }
 161 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
 162             return exchange( c.ptr_, nullptr);
 163 #else
 164             return std::exchange( c.ptr_, nullptr);
 165 #endif
 166         };
 167 #endif
 168         // context switch
 169         ::SwitchToFiber( fiber);
 170 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
 171         return detail::exchange( current()->from, nullptr);
 172 #else
 173         return std::exchange( current()->from, nullptr);
 174 #endif
 175     }
 176
 177     virtual void deallocate() noexcept {
 178     }
 179 };
 180
 181 struct BOOST_CONTEXT_DECL fiber_activation_record_initializer {
 182     fiber_activation_record_initializer() noexcept;
 183     ~fiber_activation_record_initializer();
 184 };
 185
 186 struct forced_unwind {
 187     fiber_activation_record  *  from{ nullptr };
 188 #ifndef BOOST_ASSERT_IS_VOID
 189     bool                        caught{ false };
 190 #endif
 191
 192     explicit forced_unwind( fiber_activation_record * from_) :
 193         from{ from_ } {
 194     }
 195
 196 #ifndef BOOST_ASSERT_IS_VOID
 197     ~forced_unwind() {
 198         BOOST_ASSERT( caught);
 199     }
 200 #endif
 201 };
 202
 203 template< typename Ctx, typename StackAlloc, typename Fn >
 204 class fiber_capture_record : public fiber_activation_record {
 205 private:
 206     typename std::decay< StackAlloc >::type             salloc_;
 207     typename std::decay< Fn >::type                     fn_;
 208
 209     static void destroy( fiber_capture_record * p) noexcept {
 210         typename std::decay< StackAlloc >::type salloc = std::move( p->salloc_);
 211         stack_context sctx = p->sctx;
 212         // deallocate activation record
 213         p->~fiber_capture_record();
 214         // destroy stack with stack allocator
 215         salloc.deallocate( sctx);
 216     }
 217
 218 public:
 219     fiber_capture_record( stack_context sctx, StackAlloc && salloc, Fn && fn) noexcept :
 220         fiber_activation_record( sctx),
 221         salloc_( std::forward< StackAlloc >( salloc)),
 222         fn_( std::forward< Fn >( fn) ) {
 223     }
 224
 225     void deallocate() noexcept override final {
 226         BOOST_ASSERT( main_ctx || ( ! main_ctx && terminated) );
 227         destroy( this);
 228     }
 229
 230     void run() {
 231         Ctx c{ from };
 232         try {
 233             // invoke context-function
 234 #if defined(BOOST_NO_CXX17_STD_INVOKE)
 235             c = boost::context::detail::invoke( fn_, std::move( c) );
 236 #else
 237             c = std::invoke( fn_, std::move( c) );
 238 #endif
 239         } catch ( forced_unwind const& ex) {
 240             c = Ctx{ ex.from };
 241 #ifndef BOOST_ASSERT_IS_VOID
 242             const_cast< forced_unwind & >( ex).caught = true;
 243 #endif
 244         }
 245         // this context has finished its task
 246         from = nullptr;
 247         ontop = nullptr;
 248         terminated = true;
 249         force_unwind = false;
 250         std::move( c).resume();
 251         BOOST_ASSERT_MSG( false, "fiber already terminated");
 252     }
 253 };
 254
 255 template< typename Ctx, typename StackAlloc, typename Fn >
 256 static fiber_activation_record * create_fiber1( StackAlloc && salloc, Fn && fn) {
 257     typedef fiber_capture_record< Ctx, StackAlloc, Fn >  capture_t;
 258
 259     auto sctx = salloc.allocate();
 260     BOOST_ASSERT( ( sizeof( capture_t) ) < sctx.size);
 261     // reserve space for control structure
 262     void * storage = reinterpret_cast< void * >(
 263             ( reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
 264             & ~ static_cast< uintptr_t >( 0xff) );
 265     // placment new for control structure on context stack
 266     capture_t * record = new ( storage) capture_t{
 267             sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
 268     // create user-context
 269     record->fiber = ::CreateFiber( sctx.size, & detail::fiber_entry_func< capture_t >, record);
 270     return record;
 271 }
 272
 273 template< typename Ctx, typename StackAlloc, typename Fn >
 274 static fiber_activation_record * create_fiber2( preallocated palloc, StackAlloc && salloc, Fn && fn) {
 275     typedef fiber_capture_record< Ctx, StackAlloc, Fn >  capture_t;
 276
 277     BOOST_ASSERT( ( sizeof( capture_t) ) < palloc.size);
 278     // reserve space for control structure
 279     void * storage = reinterpret_cast< void * >(
 280             ( reinterpret_cast< uintptr_t >( palloc.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
 281             & ~ static_cast< uintptr_t >( 0xff) );
 282     // placment new for control structure on context stack
 283     capture_t * record = new ( storage) capture_t{
 284             palloc.sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
 285     // create user-context
 286     record->fiber = ::CreateFiber( palloc.sctx.size, & detail::fiber_entry_func< capture_t >, record);
 287     return record;
 288 }
 289
 290 }
 291
 292 class BOOST_CONTEXT_DECL fiber {
 293 private:
 294     friend struct detail::fiber_activation_record;
 295
 296     template< typename Ctx, typename StackAlloc, typename Fn >
 297     friend class detail::fiber_capture_record;
 298
 299     template< typename Ctx, typename StackAlloc, typename Fn >
 300     friend detail::fiber_activation_record * detail::create_fiber1( StackAlloc &&, Fn &&);
 301
 302     template< typename Ctx, typename StackAlloc, typename Fn >
 303     friend detail::fiber_activation_record * detail::create_fiber2( preallocated, StackAlloc &&, Fn &&);
 304
 305     template< typename StackAlloc, typename Fn >
 306     friend fiber
 307     callcc( std::allocator_arg_t, StackAlloc &&, Fn &&);
 308
 309     template< typename StackAlloc, typename Fn >
 310     friend fiber
 311     callcc( std::allocator_arg_t, preallocated, StackAlloc &&, Fn &&);
 312
 313     detail::fiber_activation_record   *   ptr_{ nullptr };
 314
 315     fiber( detail::fiber_activation_record * ptr) noexcept :
 316         ptr_{ ptr } {
 317     }
 318
 319 public:
 320     fiber() = default;
 321
 322     template< typename Fn, typename = detail::disable_overload< fiber, Fn > >
 323     fiber( Fn && fn) :
 324         fiber{ std::allocator_arg,
 325                fixedsize_stack(),
 326                std::forward< Fn >( fn) } {
 327     }
 328
 329     template< typename StackAlloc, typename Fn >
 330     fiber( std::allocator_arg_t, StackAlloc && salloc, Fn && fn) :
 331         ptr_{ detail::create_fiber1< fiber >(
 332                 std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) } {;
 333     }
 334
 335     template< typename StackAlloc, typename Fn >
 336     fiber( std::allocator_arg_t, preallocated palloc, StackAlloc && salloc, Fn && fn) :
 337         ptr_{ detail::create_fiber2< fiber >(
 338                 palloc, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) } {
 339     }
 340
 341     ~fiber() {
 342         if ( BOOST_UNLIKELY( nullptr != ptr_) && ! ptr_->main_ctx) {
 343             if ( BOOST_LIKELY( ! ptr_->terminated) ) {
 344                 ptr_->force_unwind = true;
 345                 ptr_->resume();
 346                 BOOST_ASSERT( ptr_->terminated);
 347             }
 348             ptr_->deallocate();
 349         }
 350     }
 351
 352     fiber( fiber const&) = delete;
 353     fiber & operator=( fiber const&) = delete;
 354
 355     fiber( fiber && other) noexcept {
 356         swap( other);
 357     }
 358
 359     fiber & operator=( fiber && other) noexcept {
 360         if ( BOOST_LIKELY( this != & other) ) {
 361             fiber tmp = std::move( other);
 362             swap( tmp);
 363         }
 364         return * this;
 365     }
 366
 367     fiber resume() && {
 368         BOOST_ASSERT( nullptr != ptr_);
 369 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
 370         detail::fiber_activation_record * ptr = detail::exchange( ptr_, nullptr)->resume();
 371 #else
 372         detail::fiber_activation_record * ptr = std::exchange( ptr_, nullptr)->resume();
 373 #endif
 374         if ( BOOST_UNLIKELY( detail::fiber_activation_record::current()->force_unwind) ) {
 375             throw detail::forced_unwind{ ptr};
 376         } else if ( BOOST_UNLIKELY( nullptr != detail::fiber_activation_record::current()->ontop) ) {
 377             ptr = detail::fiber_activation_record::current()->ontop( ptr);
 378             detail::fiber_activation_record::current()->ontop = nullptr;
 379         }
 380         return { ptr };
 381     }
 382
 383     template< typename Fn >
 384     fiber resume_with( Fn && fn) && {
 385         BOOST_ASSERT( nullptr != ptr_);
 386 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
 387         detail::fiber_activation_record * ptr =
 388             detail::exchange( ptr_, nullptr)->resume_with< fiber >( std::forward< Fn >( fn) );
 389 #else
 390         detail::fiber_activation_record * ptr =
 391             std::exchange( ptr_, nullptr)->resume_with< fiber >( std::forward< Fn >( fn) );
 392 #endif
 393         if ( BOOST_UNLIKELY( detail::fiber_activation_record::current()->force_unwind) ) {
 394             throw detail::forced_unwind{ ptr};
 395         } else if ( BOOST_UNLIKELY( nullptr != detail::fiber_activation_record::current()->ontop) ) {
 396             ptr = detail::fiber_activation_record::current()->ontop( ptr);
 397             detail::fiber_activation_record::current()->ontop = nullptr;
 398         }
 399         return { ptr };
 400     }
 401
 402     explicit operator bool() const noexcept {
 403         return nullptr != ptr_ && ! ptr_->terminated;
 404     }
 405
 406     bool operator!() const noexcept {
 407         return nullptr == ptr_ || ptr_->terminated;
 408     }
 409
 410     bool operator<( fiber const& other) const noexcept {
 411         return ptr_ < other.ptr_;
 412     }
 413
 414     #if !defined(BOOST_EMBTC)
 415
 416     template< typename charT, class traitsT >
 417     friend std::basic_ostream< charT, traitsT > &
 418     operator<<( std::basic_ostream< charT, traitsT > & os, fiber const& other) {
 419         if ( nullptr != other.ptr_) {
 420             return os << other.ptr_;
 421         } else {
 422             return os << "{not-a-context}";
 423         }
 424     }
 425
 426     #else
 427
 428     template< typename charT, class traitsT >
 429     friend std::basic_ostream< charT, traitsT > &
 430     operator<<( std::basic_ostream< charT, traitsT > & os, fiber const& other);
 431
 432     #endif
 433
 434     void swap( fiber & other) noexcept {
 435         std::swap( ptr_, other.ptr_);
 436     }
 437 };
 438
 439 #if defined(BOOST_EMBTC)
 440
 441     template< typename charT, class traitsT >
 442     inline std::basic_ostream< charT, traitsT > &
 443     operator<<( std::basic_ostream< charT, traitsT > & os, fiber const& other) {
 444         if ( nullptr != other.ptr_) {
 445             return os << other.ptr_;
 446         } else {
 447             return os << "{not-a-context}";
 448         }
 449     }
 450
 451 #endif
 452
 453 inline
 454 void swap( fiber & l, fiber & r) noexcept {
 455     l.swap( r);
 456 }
 457
 458 typedef fiber fiber_context;
 459
 460 }}
 461
 462 #if defined(BOOST_MSVC)
 463 # pragma warning(pop)
 464 #endif
 465
 466 #ifdef BOOST_HAS_ABI_HEADERS
 467 # include BOOST_ABI_SUFFIX
 468 #endif
 469
 470 #endif // BOOST_CONTEXT_FIBER_H