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 <boost/predef.h>
11 #if BOOST_OS_MACOS
12 #define _XOPEN_SOURCE 600
13 #endif
14
15 extern "C" {
16 #include <ucontext.h>
17 }
18
19 #include <boost/context/detail/config.hpp>
20
21 #include <algorithm>
22 #include <cstddef>
23 #include <cstdint>
24 #include <cstdlib>
25 #include <cstring>
26 #include <functional>
27 #include <memory>
28 #include <ostream>
29 #include <system_error>
30 #include <tuple>
31 #include <utility>
32
33 #include <boost/assert.hpp>
34 #include <boost/config.hpp>
35
36 #include <boost/context/detail/disable_overload.hpp>
37 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
38 #include <boost/context/detail/exchange.hpp>
39 #endif
40 #include <boost/context/detail/externc.hpp>
41 #if defined(BOOST_NO_CXX17_STD_INVOKE)
42 #include <boost/context/detail/invoke.hpp>
43 #endif
44 #include <boost/context/fixedsize_stack.hpp>
45 #include <boost/context/flags.hpp>
46 #include <boost/context/preallocated.hpp>
47 #if defined(BOOST_USE_SEGMENTED_STACKS)
48 #include <boost/context/segmented_stack.hpp>
49 #endif
50 #include <boost/context/stack_context.hpp>
51
52 #ifdef BOOST_HAS_ABI_HEADERS
53 # include BOOST_ABI_PREFIX
54 #endif
55
56 namespace boost {
57 namespace context {
58 namespace detail {
59
60 // tampoline function
61 // entered if the execution context
62 // is resumed for the first time
63 template< typename Record >
fiber_entry_func(void * data)64 static void fiber_entry_func( void * data) noexcept {
65 Record * record = static_cast< Record * >( data);
66 BOOST_ASSERT( nullptr != record);
67 // start execution of toplevel context-function
68 record->run();
69 }
70
71 struct BOOST_CONTEXT_DECL fiber_activation_record {
72 ucontext_t uctx{};
73 stack_context sctx{};
74 bool main_ctx{ true };
75 fiber_activation_record * from{ nullptr };
76 std::function< fiber_activation_record*(fiber_activation_record*&) > ontop{};
77 bool terminated{ false };
78 bool force_unwind{ false };
79 #if defined(BOOST_USE_ASAN)
80 void * fake_stack{ nullptr };
81 void * stack_bottom{ nullptr };
82 std::size_t stack_size{ 0 };
83 #endif
84
85 static fiber_activation_record *& current() noexcept;
86
87 // used for toplevel-context
88 // (e.g. main context, thread-entry context)
fiber_activation_recordboost::context::detail::fiber_activation_record89 fiber_activation_record() {
90 if ( BOOST_UNLIKELY( 0 != ::getcontext( & uctx) ) ) {
91 throw std::system_error(
92 std::error_code( errno, std::system_category() ),
93 "getcontext() failed");
94 }
95 }
96
fiber_activation_recordboost::context::detail::fiber_activation_record97 fiber_activation_record( stack_context sctx_) noexcept :
98 sctx( sctx_ ),
99 main_ctx( false ) {
100 }
101
~fiber_activation_recordboost::context::detail::fiber_activation_record102 virtual ~fiber_activation_record() {
103 }
104
105 fiber_activation_record( fiber_activation_record const&) = delete;
106 fiber_activation_record & operator=( fiber_activation_record const&) = delete;
107
is_main_contextboost::context::detail::fiber_activation_record108 bool is_main_context() const noexcept {
109 return main_ctx;
110 }
111
resumeboost::context::detail::fiber_activation_record112 fiber_activation_record * resume() {
113 from = current();
114 // store `this` in static, thread local pointer
115 // `this` will become the active (running) context
116 current() = this;
117 #if defined(BOOST_USE_SEGMENTED_STACKS)
118 // adjust segmented stack properties
119 __splitstack_getcontext( from->sctx.segments_ctx);
120 __splitstack_setcontext( sctx.segments_ctx);
121 #endif
122 #if defined(BOOST_USE_ASAN)
123 if ( terminated) {
124 __sanitizer_start_switch_fiber( nullptr, stack_bottom, stack_size);
125 } else {
126 __sanitizer_start_switch_fiber( & from->fake_stack, stack_bottom, stack_size);
127 }
128 #endif
129 // context switch from parent context to `this`-context
130 ::swapcontext( & from->uctx, & uctx);
131 #if defined(BOOST_USE_ASAN)
132 __sanitizer_finish_switch_fiber( current()->fake_stack,
133 (const void **) & current()->from->stack_bottom,
134 & current()->from->stack_size);
135 #endif
136 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
137 return exchange( current()->from, nullptr);
138 #else
139 return std::exchange( current()->from, nullptr);
140 #endif
141 }
142
143 template< typename Ctx, typename Fn >
resume_withboost::context::detail::fiber_activation_record144 fiber_activation_record * resume_with( Fn && fn) {
145 from = current();
146 // store `this` in static, thread local pointer
147 // `this` will become the active (running) context
148 // returned by fiber::current()
149 current() = this;
150 #if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)
151 current()->ontop = std::bind(
152 [](typename std::decay< Fn >::type & fn, fiber_activation_record *& ptr){
153 Ctx c{ ptr };
154 c = fn( std::move( c) );
155 if ( ! c) {
156 ptr = nullptr;
157 }
158 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
159 return exchange( c.ptr_, nullptr);
160 #else
161 return std::exchange( c.ptr_, nullptr);
162 #endif
163 },
164 std::forward< Fn >( fn),
165 std::placeholders::_1);
166 #else
167 current()->ontop = [fn=std::forward<Fn>(fn)](fiber_activation_record *& ptr){
168 Ctx c{ ptr };
169 c = fn( std::move( c) );
170 if ( ! c) {
171 ptr = nullptr;
172 }
173 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
174 return exchange( c.ptr_, nullptr);
175 #else
176 return std::exchange( c.ptr_, nullptr);
177 #endif
178 };
179 #endif
180 #if defined(BOOST_USE_SEGMENTED_STACKS)
181 // adjust segmented stack properties
182 __splitstack_getcontext( from->sctx.segments_ctx);
183 __splitstack_setcontext( sctx.segments_ctx);
184 #endif
185 #if defined(BOOST_USE_ASAN)
186 __sanitizer_start_switch_fiber( & from->fake_stack, stack_bottom, stack_size);
187 #endif
188 // context switch from parent context to `this`-context
189 ::swapcontext( & from->uctx, & uctx);
190 #if defined(BOOST_USE_ASAN)
191 __sanitizer_finish_switch_fiber( current()->fake_stack,
192 (const void **) & current()->from->stack_bottom,
193 & current()->from->stack_size);
194 #endif
195 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
196 return exchange( current()->from, nullptr);
197 #else
198 return std::exchange( current()->from, nullptr);
199 #endif
200 }
201
deallocateboost::context::detail::fiber_activation_record202 virtual void deallocate() noexcept {
203 }
204 };
205
206 struct BOOST_CONTEXT_DECL fiber_activation_record_initializer {
207 fiber_activation_record_initializer() noexcept;
208 ~fiber_activation_record_initializer();
209 };
210
211 struct forced_unwind {
212 fiber_activation_record * from{ nullptr };
213 #ifndef BOOST_ASSERT_IS_VOID
214 bool caught{ false };
215 #endif
216
forced_unwindboost::context::detail::forced_unwind217 forced_unwind( fiber_activation_record * from_) noexcept :
218 from{ from_ } {
219 }
220
221 #ifndef BOOST_ASSERT_IS_VOID
~forced_unwindboost::context::detail::forced_unwind222 ~forced_unwind() {
223 BOOST_ASSERT( caught);
224 }
225 #endif
226 };
227
228 template< typename Ctx, typename StackAlloc, typename Fn >
229 class fiber_capture_record : public fiber_activation_record {
230 private:
231 typename std::decay< StackAlloc >::type salloc_;
232 typename std::decay< Fn >::type fn_;
233
destroy(fiber_capture_record * p)234 static void destroy( fiber_capture_record * p) noexcept {
235 typename std::decay< StackAlloc >::type salloc = std::move( p->salloc_);
236 stack_context sctx = p->sctx;
237 // deallocate activation record
238 p->~fiber_capture_record();
239 // destroy stack with stack allocator
240 salloc.deallocate( sctx);
241 }
242
243 public:
fiber_capture_record(stack_context sctx,StackAlloc && salloc,Fn && fn)244 fiber_capture_record( stack_context sctx, StackAlloc && salloc, Fn && fn) noexcept :
245 fiber_activation_record{ sctx },
246 salloc_{ std::forward< StackAlloc >( salloc) },
247 fn_( std::forward< Fn >( fn) ) {
248 }
249
deallocate()250 void deallocate() noexcept override final {
251 BOOST_ASSERT( main_ctx || ( ! main_ctx && terminated) );
252 destroy( this);
253 }
254
run()255 void run() {
256 #if defined(BOOST_USE_ASAN)
257 __sanitizer_finish_switch_fiber( fake_stack,
258 (const void **) & from->stack_bottom,
259 & from->stack_size);
260 #endif
261 Ctx c{ from };
262 try {
263 // invoke context-function
264 #if defined(BOOST_NO_CXX17_STD_INVOKE)
265 c = boost::context::detail::invoke( fn_, std::move( c) );
266 #else
267 c = std::invoke( fn_, std::move( c) );
268 #endif
269 } catch ( forced_unwind const& ex) {
270 c = Ctx{ ex.from };
271 #ifndef BOOST_ASSERT_IS_VOID
272 const_cast< forced_unwind & >( ex).caught = true;
273 #endif
274 }
275 // this context has finished its task
276 from = nullptr;
277 ontop = nullptr;
278 terminated = true;
279 force_unwind = false;
280 std::move( c).resume();
281 BOOST_ASSERT_MSG( false, "fiber already terminated");
282 }
283 };
284
285 template< typename Ctx, typename StackAlloc, typename Fn >
create_fiber1(StackAlloc && salloc,Fn && fn)286 static fiber_activation_record * create_fiber1( StackAlloc && salloc, Fn && fn) {
287 typedef fiber_capture_record< Ctx, StackAlloc, Fn > capture_t;
288
289 auto sctx = salloc.allocate();
290 // reserve space for control structure
291 void * storage = reinterpret_cast< void * >(
292 ( reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
293 & ~ static_cast< uintptr_t >( 0xff) );
294 // placment new for control structure on context stack
295 capture_t * record = new ( storage) capture_t{
296 sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
297 // stack bottom
298 void * stack_bottom = reinterpret_cast< void * >(
299 reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sctx.size) );
300 // create user-context
301 if ( BOOST_UNLIKELY( 0 != ::getcontext( & record->uctx) ) ) {
302 record->~capture_t();
303 salloc.deallocate( sctx);
304 throw std::system_error(
305 std::error_code( errno, std::system_category() ),
306 "getcontext() failed");
307 }
308 record->uctx.uc_stack.ss_sp = stack_bottom;
309 // 64byte gap between control structure and stack top
310 record->uctx.uc_stack.ss_size = reinterpret_cast< uintptr_t >( storage) -
311 reinterpret_cast< uintptr_t >( stack_bottom) - static_cast< uintptr_t >( 64);
312 record->uctx.uc_link = nullptr;
313 ::makecontext( & record->uctx, ( void (*)() ) & fiber_entry_func< capture_t >, 1, record);
314 #if defined(BOOST_USE_ASAN)
315 record->stack_bottom = record->uctx.uc_stack.ss_sp;
316 record->stack_size = record->uctx.uc_stack.ss_size;
317 #endif
318 return record;
319 }
320
321 template< typename Ctx, typename StackAlloc, typename Fn >
create_fiber2(preallocated palloc,StackAlloc && salloc,Fn && fn)322 static fiber_activation_record * create_fiber2( preallocated palloc, StackAlloc && salloc, Fn && fn) {
323 typedef fiber_capture_record< Ctx, StackAlloc, Fn > capture_t;
324
325 // reserve space for control structure
326 void * storage = reinterpret_cast< void * >(
327 ( reinterpret_cast< uintptr_t >( palloc.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
328 & ~ static_cast< uintptr_t >( 0xff) );
329 // placment new for control structure on context stack
330 capture_t * record = new ( storage) capture_t{
331 palloc.sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
332 // stack bottom
333 void * stack_bottom = reinterpret_cast< void * >(
334 reinterpret_cast< uintptr_t >( palloc.sctx.sp) - static_cast< uintptr_t >( palloc.sctx.size) );
335 // create user-context
336 if ( BOOST_UNLIKELY( 0 != ::getcontext( & record->uctx) ) ) {
337 record->~capture_t();
338 salloc.deallocate( palloc.sctx);
339 throw std::system_error(
340 std::error_code( errno, std::system_category() ),
341 "getcontext() failed");
342 }
343 record->uctx.uc_stack.ss_sp = stack_bottom;
344 // 64byte gap between control structure and stack top
345 record->uctx.uc_stack.ss_size = reinterpret_cast< uintptr_t >( storage) -
346 reinterpret_cast< uintptr_t >( stack_bottom) - static_cast< uintptr_t >( 64);
347 record->uctx.uc_link = nullptr;
348 ::makecontext( & record->uctx, ( void (*)() ) & fiber_entry_func< capture_t >, 1, record);
349 #if defined(BOOST_USE_ASAN)
350 record->stack_bottom = record->uctx.uc_stack.ss_sp;
351 record->stack_size = record->uctx.uc_stack.ss_size;
352 #endif
353 return record;
354 }
355
356 }
357
358 class BOOST_CONTEXT_DECL fiber {
359 private:
360 friend struct detail::fiber_activation_record;
361
362 template< typename Ctx, typename StackAlloc, typename Fn >
363 friend class detail::fiber_capture_record;
364
365 template< typename Ctx, typename StackAlloc, typename Fn >
366 friend detail::fiber_activation_record * detail::create_fiber1( StackAlloc &&, Fn &&);
367
368 template< typename Ctx, typename StackAlloc, typename Fn >
369 friend detail::fiber_activation_record * detail::create_fiber2( preallocated, StackAlloc &&, Fn &&);
370
371 template< typename StackAlloc, typename Fn >
372 friend fiber
373 callcc( std::allocator_arg_t, StackAlloc &&, Fn &&);
374
375 template< typename StackAlloc, typename Fn >
376 friend fiber
377 callcc( std::allocator_arg_t, preallocated, StackAlloc &&, Fn &&);
378
379 detail::fiber_activation_record * ptr_{ nullptr };
380
fiber(detail::fiber_activation_record * ptr)381 fiber( detail::fiber_activation_record * ptr) noexcept :
382 ptr_{ ptr } {
383 }
384
385 public:
386 fiber() = default;
387
388 template< typename Fn, typename = detail::disable_overload< fiber, Fn > >
fiber(Fn && fn)389 fiber( Fn && fn) :
390 fiber{
391 std::allocator_arg,
392 #if defined(BOOST_USE_SEGMENTED_STACKS)
393 segmented_stack(),
394 #else
395 fixedsize_stack(),
396 #endif
397 std::forward< Fn >( fn) } {
398 }
399
400 template< typename StackAlloc, typename Fn >
fiber(std::allocator_arg_t,StackAlloc && salloc,Fn && fn)401 fiber( std::allocator_arg_t, StackAlloc && salloc, Fn && fn) :
402 ptr_{ detail::create_fiber1< fiber >(
403 std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) } {
404 }
405
406 template< typename StackAlloc, typename Fn >
fiber(std::allocator_arg_t,preallocated palloc,StackAlloc && salloc,Fn && fn)407 fiber( std::allocator_arg_t, preallocated palloc, StackAlloc && salloc, Fn && fn) :
408 ptr_{ detail::create_fiber2< fiber >(
409 palloc, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) } {
410 }
411
~fiber()412 ~fiber() {
413 if ( BOOST_UNLIKELY( nullptr != ptr_) && ! ptr_->main_ctx) {
414 if ( BOOST_LIKELY( ! ptr_->terminated) ) {
415 ptr_->force_unwind = true;
416 ptr_->resume();
417 BOOST_ASSERT( ptr_->terminated);
418 }
419 ptr_->deallocate();
420 }
421 }
422
423 fiber( fiber const&) = delete;
424 fiber & operator=( fiber const&) = delete;
425
fiber(fiber && other)426 fiber( fiber && other) noexcept {
427 swap( other);
428 }
429
operator =(fiber && other)430 fiber & operator=( fiber && other) noexcept {
431 if ( BOOST_LIKELY( this != & other) ) {
432 fiber tmp = std::move( other);
433 swap( tmp);
434 }
435 return * this;
436 }
437
resume()438 fiber resume() && {
439 BOOST_ASSERT( nullptr != ptr_);
440 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
441 detail::fiber_activation_record * ptr = detail::exchange( ptr_, nullptr)->resume();
442 #else
443 detail::fiber_activation_record * ptr = std::exchange( ptr_, nullptr)->resume();
444 #endif
445 if ( BOOST_UNLIKELY( detail::fiber_activation_record::current()->force_unwind) ) {
446 throw detail::forced_unwind{ ptr};
447 } else if ( BOOST_UNLIKELY( nullptr != detail::fiber_activation_record::current()->ontop) ) {
448 ptr = detail::fiber_activation_record::current()->ontop( ptr);
449 detail::fiber_activation_record::current()->ontop = nullptr;
450 }
451 return { ptr };
452 }
453
454 template< typename Fn >
resume_with(Fn && fn)455 fiber resume_with( Fn && fn) && {
456 BOOST_ASSERT( nullptr != ptr_);
457 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
458 detail::fiber_activation_record * ptr =
459 detail::exchange( ptr_, nullptr)->resume_with< fiber >( std::forward< Fn >( fn) );
460 #else
461 detail::fiber_activation_record * ptr =
462 std::exchange( ptr_, nullptr)->resume_with< fiber >( std::forward< Fn >( fn) );
463 #endif
464 if ( BOOST_UNLIKELY( detail::fiber_activation_record::current()->force_unwind) ) {
465 throw detail::forced_unwind{ ptr};
466 } else if ( BOOST_UNLIKELY( nullptr != detail::fiber_activation_record::current()->ontop) ) {
467 ptr = detail::fiber_activation_record::current()->ontop( ptr);
468 detail::fiber_activation_record::current()->ontop = nullptr;
469 }
470 return { ptr };
471 }
472
operator bool() const473 explicit operator bool() const noexcept {
474 return nullptr != ptr_ && ! ptr_->terminated;
475 }
476
operator !() const477 bool operator!() const noexcept {
478 return nullptr == ptr_ || ptr_->terminated;
479 }
480
operator <(fiber const & other) const481 bool operator<( fiber const& other) const noexcept {
482 return ptr_ < other.ptr_;
483 }
484
485 #if !defined(BOOST_EMBTC)
486
487 template< typename charT, class traitsT >
488 friend std::basic_ostream< charT, traitsT > &
operator <<(std::basic_ostream<charT,traitsT> & os,fiber const & other)489 operator<<( std::basic_ostream< charT, traitsT > & os, fiber const& other) {
490 if ( nullptr != other.ptr_) {
491 return os << other.ptr_;
492 } else {
493 return os << "{not-a-context}";
494 }
495 }
496
497 #else
498
499 template< typename charT, class traitsT >
500 friend std::basic_ostream< charT, traitsT > &
501 operator<<( std::basic_ostream< charT, traitsT > & os, fiber const& other);
502
503 #endif
504
swap(fiber & other)505 void swap( fiber & other) noexcept {
506 std::swap( ptr_, other.ptr_);
507 }
508 };
509
510 #if defined(BOOST_EMBTC)
511
512 template< typename charT, class traitsT >
513 inline std::basic_ostream< charT, traitsT > &
operator <<(std::basic_ostream<charT,traitsT> & os,fiber const & other)514 operator<<( std::basic_ostream< charT, traitsT > & os, fiber const& other) {
515 if ( nullptr != other.ptr_) {
516 return os << other.ptr_;
517 } else {
518 return os << "{not-a-context}";
519 }
520 }
521
522 #endif
523
524 inline
swap(fiber & l,fiber & r)525 void swap( fiber & l, fiber & r) noexcept {
526 l.swap( r);
527 }
528
529 typedef fiber fiber_context;
530
531 }}
532
533 #ifdef BOOST_HAS_ABI_HEADERS
534 # include BOOST_ABI_SUFFIX
535 #endif
536
537 #endif // BOOST_CONTEXT_FIBER_H
538