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 throw std::system_error(
303 std::error_code( errno, std::system_category() ),
304 "getcontext() failed");
305 }
306 record->uctx.uc_stack.ss_sp = stack_bottom;
307 // 64byte gap between control structure and stack top
308 record->uctx.uc_stack.ss_size = reinterpret_cast< uintptr_t >( storage) -
309 reinterpret_cast< uintptr_t >( stack_bottom) - static_cast< uintptr_t >( 64);
310 record->uctx.uc_link = nullptr;
311 ::makecontext( & record->uctx, ( void (*)() ) & fiber_entry_func< capture_t >, 1, record);
312 #if defined(BOOST_USE_ASAN)
313 record->stack_bottom = record->uctx.uc_stack.ss_sp;
314 record->stack_size = record->uctx.uc_stack.ss_size;
315 #endif
316 return record;
317 }
318
319 template< typename Ctx, typename StackAlloc, typename Fn >
create_fiber2(preallocated palloc,StackAlloc && salloc,Fn && fn)320 static fiber_activation_record * create_fiber2( preallocated palloc, StackAlloc && salloc, Fn && fn) {
321 typedef fiber_capture_record< Ctx, StackAlloc, Fn > capture_t;
322
323 // reserve space for control structure
324 void * storage = reinterpret_cast< void * >(
325 ( reinterpret_cast< uintptr_t >( palloc.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
326 & ~ static_cast< uintptr_t >( 0xff) );
327 // placment new for control structure on context stack
328 capture_t * record = new ( storage) capture_t{
329 palloc.sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
330 // stack bottom
331 void * stack_bottom = reinterpret_cast< void * >(
332 reinterpret_cast< uintptr_t >( palloc.sctx.sp) - static_cast< uintptr_t >( palloc.sctx.size) );
333 // create user-context
334 if ( BOOST_UNLIKELY( 0 != ::getcontext( & record->uctx) ) ) {
335 throw std::system_error(
336 std::error_code( errno, std::system_category() ),
337 "getcontext() failed");
338 }
339 record->uctx.uc_stack.ss_sp = stack_bottom;
340 // 64byte gap between control structure and stack top
341 record->uctx.uc_stack.ss_size = reinterpret_cast< uintptr_t >( storage) -
342 reinterpret_cast< uintptr_t >( stack_bottom) - static_cast< uintptr_t >( 64);
343 record->uctx.uc_link = nullptr;
344 ::makecontext( & record->uctx, ( void (*)() ) & fiber_entry_func< capture_t >, 1, record);
345 #if defined(BOOST_USE_ASAN)
346 record->stack_bottom = record->uctx.uc_stack.ss_sp;
347 record->stack_size = record->uctx.uc_stack.ss_size;
348 #endif
349 return record;
350 }
351
352 }
353
354 class BOOST_CONTEXT_DECL fiber {
355 private:
356 friend struct detail::fiber_activation_record;
357
358 template< typename Ctx, typename StackAlloc, typename Fn >
359 friend class detail::fiber_capture_record;
360
361 template< typename Ctx, typename StackAlloc, typename Fn >
362 friend detail::fiber_activation_record * detail::create_fiber1( StackAlloc &&, Fn &&);
363
364 template< typename Ctx, typename StackAlloc, typename Fn >
365 friend detail::fiber_activation_record * detail::create_fiber2( preallocated, StackAlloc &&, Fn &&);
366
367 template< typename StackAlloc, typename Fn >
368 friend fiber
369 callcc( std::allocator_arg_t, StackAlloc &&, Fn &&);
370
371 template< typename StackAlloc, typename Fn >
372 friend fiber
373 callcc( std::allocator_arg_t, preallocated, StackAlloc &&, Fn &&);
374
375 detail::fiber_activation_record * ptr_{ nullptr };
376
fiber(detail::fiber_activation_record * ptr)377 fiber( detail::fiber_activation_record * ptr) noexcept :
378 ptr_{ ptr } {
379 }
380
381 public:
382 fiber() = default;
383
384 template< typename Fn, typename = detail::disable_overload< fiber, Fn > >
fiber(Fn && fn)385 fiber( Fn && fn) :
386 fiber{
387 std::allocator_arg,
388 #if defined(BOOST_USE_SEGMENTED_STACKS)
389 segmented_stack(),
390 #else
391 fixedsize_stack(),
392 #endif
393 std::forward< Fn >( fn) } {
394 }
395
396 template< typename StackAlloc, typename Fn >
fiber(std::allocator_arg_t,StackAlloc && salloc,Fn && fn)397 fiber( std::allocator_arg_t, StackAlloc && salloc, Fn && fn) :
398 ptr_{ detail::create_fiber1< fiber >(
399 std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) } {
400 }
401
402 template< typename StackAlloc, typename Fn >
fiber(std::allocator_arg_t,preallocated palloc,StackAlloc && salloc,Fn && fn)403 fiber( std::allocator_arg_t, preallocated palloc, StackAlloc && salloc, Fn && fn) :
404 ptr_{ detail::create_fiber2< fiber >(
405 palloc, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) } {
406 }
407
~fiber()408 ~fiber() {
409 if ( BOOST_UNLIKELY( nullptr != ptr_) && ! ptr_->main_ctx) {
410 if ( BOOST_LIKELY( ! ptr_->terminated) ) {
411 ptr_->force_unwind = true;
412 ptr_->resume();
413 BOOST_ASSERT( ptr_->terminated);
414 }
415 ptr_->deallocate();
416 }
417 }
418
419 fiber( fiber const&) = delete;
420 fiber & operator=( fiber const&) = delete;
421
fiber(fiber && other)422 fiber( fiber && other) noexcept {
423 swap( other);
424 }
425
operator =(fiber && other)426 fiber & operator=( fiber && other) noexcept {
427 if ( BOOST_LIKELY( this != & other) ) {
428 fiber tmp = std::move( other);
429 swap( tmp);
430 }
431 return * this;
432 }
433
resume()434 fiber resume() && {
435 BOOST_ASSERT( nullptr != ptr_);
436 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
437 detail::fiber_activation_record * ptr = detail::exchange( ptr_, nullptr)->resume();
438 #else
439 detail::fiber_activation_record * ptr = std::exchange( ptr_, nullptr)->resume();
440 #endif
441 if ( BOOST_UNLIKELY( detail::fiber_activation_record::current()->force_unwind) ) {
442 throw detail::forced_unwind{ ptr};
443 } else if ( BOOST_UNLIKELY( nullptr != detail::fiber_activation_record::current()->ontop) ) {
444 ptr = detail::fiber_activation_record::current()->ontop( ptr);
445 detail::fiber_activation_record::current()->ontop = nullptr;
446 }
447 return { ptr };
448 }
449
450 template< typename Fn >
resume_with(Fn && fn)451 fiber resume_with( Fn && fn) && {
452 BOOST_ASSERT( nullptr != ptr_);
453 #if defined(BOOST_NO_CXX14_STD_EXCHANGE)
454 detail::fiber_activation_record * ptr =
455 detail::exchange( ptr_, nullptr)->resume_with< fiber >( std::forward< Fn >( fn) );
456 #else
457 detail::fiber_activation_record * ptr =
458 std::exchange( ptr_, nullptr)->resume_with< fiber >( std::forward< Fn >( fn) );
459 #endif
460 if ( BOOST_UNLIKELY( detail::fiber_activation_record::current()->force_unwind) ) {
461 throw detail::forced_unwind{ ptr};
462 } else if ( BOOST_UNLIKELY( nullptr != detail::fiber_activation_record::current()->ontop) ) {
463 ptr = detail::fiber_activation_record::current()->ontop( ptr);
464 detail::fiber_activation_record::current()->ontop = nullptr;
465 }
466 return { ptr };
467 }
468
operator bool() const469 explicit operator bool() const noexcept {
470 return nullptr != ptr_ && ! ptr_->terminated;
471 }
472
operator !() const473 bool operator!() const noexcept {
474 return nullptr == ptr_ || ptr_->terminated;
475 }
476
operator <(fiber const & other) const477 bool operator<( fiber const& other) const noexcept {
478 return ptr_ < other.ptr_;
479 }
480
481 template< typename charT, class traitsT >
482 friend std::basic_ostream< charT, traitsT > &
operator <<(std::basic_ostream<charT,traitsT> & os,fiber const & other)483 operator<<( std::basic_ostream< charT, traitsT > & os, fiber const& other) {
484 if ( nullptr != other.ptr_) {
485 return os << other.ptr_;
486 } else {
487 return os << "{not-a-context}";
488 }
489 }
490
swap(fiber & other)491 void swap( fiber & other) noexcept {
492 std::swap( ptr_, other.ptr_);
493 }
494 };
495
496 inline
swap(fiber & l,fiber & r)497 void swap( fiber & l, fiber & r) noexcept {
498 l.swap( r);
499 }
500
501 typedef fiber fiber_context;
502
503 }}
504
505 #ifdef BOOST_HAS_ABI_HEADERS
506 # include BOOST_ABI_SUFFIX
507 #endif
508
509 #endif // BOOST_CONTEXT_FIBER_H
510