bgirgis/cpp-thirdparty
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update boost on linux

Browse Source
This commit is contained in:
Bassem Girgis
2019-08-10 16:06:25 -05:00
parent 76ad52be58
commit 861b918727
5363 changed files with 483306 additions and 116507 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
linx64/include/boost/context/all.hpp
View File

@@ -1,13 +0,0 @@
// Copyright Oliver Kowalke 2016.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <boost/context/continuation.hpp>
#include <boost/context/fixedsize_stack.hpp>
#include <boost/context/pooled_fixedsize_stack.hpp>
#include <boost/context/protected_fixedsize_stack.hpp>
#include <boost/context/segmented_stack.hpp>
#include <boost/context/stack_context.hpp>
#include <boost/context/stack_traits.hpp>

551
linx64/include/boost/context/continuation.hpp
View File

@@ -4,551 +4,10 @@
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_CONTINUATION_H
#define BOOST_CONTEXT_CONTINUATION_H
#include <boost/context/detail/config.hpp>
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <exception>
#include <functional>
#include <memory>
#include <ostream>
#include <tuple>
#include <utility>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/intrusive_ptr.hpp>
#if defined(BOOST_NO_CXX17_STD_APPLY)
#include <boost/context/detail/apply.hpp>
#endif
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
#include <boost/context/detail/exchange.hpp>
#endif
#if defined(BOOST_NO_CXX17_STD_INVOKE)
#include <boost/context/detail/invoke.hpp>
#endif
#include <boost/context/detail/disable_overload.hpp>
#include <boost/context/detail/exception.hpp>
#include <boost/context/detail/fcontext.hpp>
#include <boost/context/detail/tuple.hpp>
#include <boost/context/fixedsize_stack.hpp>
#include <boost/context/flags.hpp>
#include <boost/context/preallocated.hpp>
#include <boost/context/segmented_stack.hpp>
#include <boost/context/stack_context.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4702)
#endif
namespace boost {
namespace context {
namespace detail {
template< int N >
struct helper {
template< typename T >
static T convert( T && t) noexcept {
return std::forward< T >( t);
}
};
template<>
struct helper< 1 > {
template< typename T >
static std::tuple< T > convert( T && t) noexcept {
return std::make_tuple( std::forward< T >( t) );
}
};
inline
transfer_t context_unwind( transfer_t t) {
throw forced_unwind( t.fctx);
return { nullptr, nullptr };
}
template< typename Rec >
transfer_t context_exit( transfer_t t) noexcept {
Rec * rec = static_cast< Rec * >( t.data);
// destroy context stack
rec->deallocate();
return { nullptr, nullptr };
}
template< typename Rec >
void context_entry( transfer_t t_) noexcept {
// transfer control structure to the context-stack
Rec * rec = static_cast< Rec * >( t_.data);
BOOST_ASSERT( nullptr != t_.fctx);
BOOST_ASSERT( nullptr != rec);
transfer_t t = { nullptr, nullptr };
try {
// jump back to `context_create()`
t = jump_fcontext( t_.fctx, nullptr);
// start executing
t = rec->run( t);
} catch ( forced_unwind const& e) {
t = { e.fctx, nullptr };
}
BOOST_ASSERT( nullptr != t.fctx);
// destroy context-stack of `this`context on next context
ontop_fcontext( t.fctx, rec, context_exit< Rec >);
BOOST_ASSERT_MSG( false, "context already terminated");
}
template<
typename Ctx,
typename StackAlloc,
typename Fn
>
class record {
private:
StackAlloc salloc_;
stack_context sctx_;
typename std::decay< Fn >::type fn_;
static void destroy( record * p) noexcept {
StackAlloc salloc = p->salloc_;
stack_context sctx = p->sctx_;
// deallocate record
p->~record();
// destroy stack with stack allocator
salloc.deallocate( sctx);
}
public:
record( stack_context sctx, StackAlloc const& salloc,
Fn && fn) noexcept :
salloc_( salloc),
sctx_( sctx),
fn_( std::forward< Fn >( fn) ) {
}
record( record const&) = delete;
record & operator=( record const&) = delete;
void deallocate() noexcept {
destroy( this);
}
transfer_t run( transfer_t t) {
Ctx from{ t };
// invoke context-function
#if defined(BOOST_NO_CXX17_STD_INVOKE)
Ctx cc = invoke( fn_, std::move( from) );
#if defined(BOOST_USE_UCONTEXT)
#include <boost/context/continuation_ucontext.hpp>
#elif defined(BOOST_USE_WINFIB)
#include <boost/context/continuation_winfib.hpp>
#else
Ctx cc = std::invoke( fn_, std::move( from) );
#include <boost/context/continuation_fcontext.hpp>
#endif
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return { exchange( cc.t_.fctx, nullptr), nullptr };
#else
return { std::exchange( cc.t_.fctx, nullptr), nullptr };
#endif
}
};
template< typename Record, typename StackAlloc, typename Fn >
fcontext_t context_create( StackAlloc salloc, Fn && fn) {
auto sctx = salloc.allocate();
// reserve space for control structure
#if defined(BOOST_NO_CXX11_CONSTEXPR) || defined(BOOST_NO_CXX11_STD_ALIGN)
const std::size_t size = sctx.size - sizeof( Record);
void * sp = static_cast< char * >( sctx.sp) - sizeof( Record);
#else
constexpr std::size_t func_alignment = 64; // alignof( Record);
constexpr std::size_t func_size = sizeof( Record);
// reserve space on stack
void * sp = static_cast< char * >( sctx.sp) - func_size - func_alignment;
// align sp pointer
std::size_t space = func_size + func_alignment;
sp = std::align( func_alignment, func_size, sp, space);
BOOST_ASSERT( nullptr != sp);
// calculate remaining size
const std::size_t size = sctx.size - ( static_cast< char * >( sctx.sp) - static_cast< char * >( sp) );
#endif
// create fast-context
const fcontext_t fctx = make_fcontext( sp, size, & context_entry< Record >);
BOOST_ASSERT( nullptr != fctx);
// placment new for control structure on context-stack
auto rec = ::new ( sp) Record{
sctx, salloc, std::forward< Fn >( fn) };
// transfer control structure to context-stack
return jump_fcontext( fctx, rec).fctx;
}
template< typename Record, typename StackAlloc, typename Fn >
fcontext_t context_create( preallocated palloc, StackAlloc salloc, Fn && fn) {
// reserve space for control structure
#if defined(BOOST_NO_CXX11_CONSTEXPR) || defined(BOOST_NO_CXX11_STD_ALIGN)
const std::size_t size = palloc.size - sizeof( Record);
void * sp = static_cast< char * >( palloc.sp) - sizeof( Record);
#else
constexpr std::size_t func_alignment = 64; // alignof( Record);
constexpr std::size_t func_size = sizeof( Record);
// reserve space on stack
void * sp = static_cast< char * >( palloc.sp) - func_size - func_alignment;
// align sp pointer
std::size_t space = func_size + func_alignment;
sp = std::align( func_alignment, func_size, sp, space);
BOOST_ASSERT( nullptr != sp);
// calculate remaining size
const std::size_t size = palloc.size - ( static_cast< char * >( palloc.sp) - static_cast< char * >( sp) );
#endif
// create fast-context
const fcontext_t fctx = make_fcontext( sp, size, & context_entry< Record >);
BOOST_ASSERT( nullptr != fctx);
// placment new for control structure on context-stack
auto rec = ::new ( sp) Record{
palloc.sctx, salloc, std::forward< Fn >( fn) };
// transfer control structure to context-stack
return jump_fcontext( fctx, rec).fctx;
}
template< typename ... Arg >
struct result_type {
typedef std::tuple< Arg ... > type;
static
type get( detail::transfer_t & t) {
auto p = static_cast< std::tuple< Arg ... > * >( t.data);
return std::move( * p);
}
};
template< typename Arg >
struct result_type< Arg > {
typedef Arg type;
static
type get( detail::transfer_t & t) {
auto p = static_cast< std::tuple< Arg > * >( t.data);
return std::forward< Arg >( std::get< 0 >( * p) );
}
};
}
template< typename Ctx, typename Fn, typename ... Arg >
detail::transfer_t context_ontop( detail::transfer_t t) {
auto p = static_cast< std::tuple< Fn, std::tuple< Arg ... > > * >( t.data);
BOOST_ASSERT( nullptr != p);
typename std::decay< Fn >::type fn = std::forward< Fn >( std::get< 0 >( * p) );
t.data = & std::get< 1 >( * p);
Ctx c{ t };
// execute function, pass continuation via reference
std::get< 1 >( * p) = detail::helper< sizeof ... (Arg) >::convert( fn( std::move( c) ) );
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return { detail::exchange( c.t_.fctx, nullptr), & std::get< 1 >( * p) };
#else
return { std::exchange( c.t_.fctx, nullptr), & std::get< 1 >( * p) };
#endif
}
template< typename Ctx, typename Fn >
detail::transfer_t context_ontop_void( detail::transfer_t t) {
auto p = static_cast< std::tuple< Fn > * >( t.data);
BOOST_ASSERT( nullptr != p);
typename std::decay< Fn >::type fn = std::forward< Fn >( std::get< 0 >( * p) );
Ctx c{ t };
// execute function, pass continuation via reference
fn( std::move( c) );
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return { detail::exchange( c.t_.fctx, nullptr), nullptr };
#else
return { std::exchange( c.t_.fctx, nullptr), nullptr };
#endif
}
class continuation {
private:
template< typename Ctx, typename StackAlloc, typename Fn >
friend class detail::record;
template< typename Ctx, typename Fn, typename ... Arg >
friend detail::transfer_t
context_ontop( detail::transfer_t);
template< typename Ctx, typename Fn >
friend detail::transfer_t
context_ontop_void( detail::transfer_t);
template< typename StackAlloc, typename Fn, typename ... Arg >
friend continuation
callcc( std::allocator_arg_t, StackAlloc, Fn &&, Arg ...);
template< typename StackAlloc, typename Fn, typename ... Arg >
friend continuation
callcc( std::allocator_arg_t, preallocated, StackAlloc, Fn &&, Arg ...);
template< typename StackAlloc, typename Fn >
friend continuation
callcc( std::allocator_arg_t, StackAlloc, Fn &&);
template< typename StackAlloc, typename Fn >
friend continuation
callcc( std::allocator_arg_t, preallocated, StackAlloc, Fn &&);
detail::transfer_t t_{ nullptr, nullptr };
continuation( detail::fcontext_t fctx) noexcept :
t_{ fctx, nullptr } {
}
continuation( detail::transfer_t t) noexcept :
t_{ t.fctx, t.data } {
}
public:
continuation() noexcept = default;
~continuation() {
if ( nullptr != t_.fctx) {
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::ontop_fcontext( detail::exchange( t_.fctx, nullptr), nullptr, detail::context_unwind);
#else
detail::ontop_fcontext( std::exchange( t_.fctx, nullptr), nullptr, detail::context_unwind);
#endif
}
}
continuation( continuation && other) noexcept :
t_{ other.t_.fctx, other.t_.data } {
other.t_ = { nullptr, nullptr };
}
continuation & operator=( continuation && other) noexcept {
if ( this != & other) {
continuation tmp = std::move( other);
swap( tmp);
}
return * this;
}
continuation( continuation const& other) noexcept = delete;
continuation & operator=( continuation const& other) noexcept = delete;
template< typename ... Arg >
continuation resume( Arg ... arg) {
BOOST_ASSERT( nullptr != t_.fctx);
auto tpl = std::make_tuple( std::forward< Arg >( arg) ... );
return detail::jump_fcontext(
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::exchange( t_.fctx, nullptr),
#else
std::exchange( t_.fctx, nullptr),
#endif
& tpl);
}
template< typename Fn, typename ... Arg >
continuation resume_with( Fn && fn, Arg ... arg) {
BOOST_ASSERT( nullptr != t_.fctx);
auto tpl = std::make_tuple( std::forward< Fn >( fn), std::forward< Arg >( arg) ... );
return detail::ontop_fcontext(
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::exchange( t_.fctx, nullptr),
#else
std::exchange( t_.fctx, nullptr),
#endif
& tpl,
context_ontop< continuation, Fn, Arg ... >);
}
continuation resume() {
BOOST_ASSERT( nullptr != t_.fctx);
return detail::jump_fcontext(
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::exchange( t_.fctx, nullptr),
#else
std::exchange( t_.fctx, nullptr),
#endif
nullptr);
}
template< typename Fn >
continuation resume_with( Fn && fn) {
BOOST_ASSERT( nullptr != t_.fctx);
auto p = std::make_tuple( std::forward< Fn >( fn) );
return detail::ontop_fcontext(
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::exchange( t_.fctx, nullptr),
#else
std::exchange( t_.fctx, nullptr),
#endif
& p,
context_ontop_void< continuation, Fn >);
}
bool data_available() noexcept {
return * this && nullptr != t_.data;
}
template< typename ... Arg >
typename detail::result_type< Arg ... >::type get_data() {
BOOST_ASSERT( nullptr != t_.data);
return detail::result_type< Arg ... >::get( t_);
}
explicit operator bool() const noexcept {
return nullptr != t_.fctx;
}
bool operator!() const noexcept {
return nullptr == t_.fctx;
}
bool operator==( continuation const& other) const noexcept {
return t_.fctx == other.t_.fctx;
}
bool operator!=( continuation const& other) const noexcept {
return t_.fctx != other.t_.fctx;
}
bool operator<( continuation const& other) const noexcept {
return t_.fctx < other.t_.fctx;
}
bool operator>( continuation const& other) const noexcept {
return other.t_.fctx < t_.fctx;
}
bool operator<=( continuation const& other) const noexcept {
return ! ( * this > other);
}
bool operator>=( continuation const& other) const noexcept {
return ! ( * this < other);
}
template< typename charT, class traitsT >
friend std::basic_ostream< charT, traitsT > &
operator<<( std::basic_ostream< charT, traitsT > & os, continuation const& other) {
if ( nullptr != other.t_.fctx) {
return os << other.t_.fctx;
} else {
return os << "{not-a-context}";
}
}
void swap( continuation & other) noexcept {
std::swap( t_, other.t_);
}
};
// Arg
template<
typename Fn,
typename ... Arg,
typename = detail::disable_overload< continuation, Fn >
>
continuation
callcc( Fn && fn, Arg ... arg) {
return callcc(
std::allocator_arg, fixedsize_stack(),
std::forward< Fn >( fn), std::forward< Arg >( arg) ...);
}
template<
typename StackAlloc,
typename Fn,
typename ... Arg
>
continuation
callcc( std::allocator_arg_t, StackAlloc salloc, Fn && fn, Arg ... arg) {
using Record = detail::record< continuation, StackAlloc, Fn >;
return continuation{
detail::context_create< Record >(
salloc, std::forward< Fn >( fn) ) }.resume(
std::forward< Arg >( arg) ... );
}
template<
typename StackAlloc,
typename Fn,
typename ... Arg
>
continuation
callcc( std::allocator_arg_t, preallocated palloc, StackAlloc salloc, Fn && fn, Arg ... arg) {
using Record = detail::record< continuation, StackAlloc, Fn >;
return continuation{
detail::context_create< Record >(
palloc, salloc, std::forward< Fn >( fn) ) }.resume(
std::forward< Arg >( arg) ... );
}
// void
template<
typename Fn,
typename = detail::disable_overload< continuation, Fn >
>
continuation
callcc( Fn && fn) {
return callcc(
std::allocator_arg, fixedsize_stack(),
std::forward< Fn >( fn) );
}
template< typename StackAlloc, typename Fn >
continuation
callcc( std::allocator_arg_t, StackAlloc salloc, Fn && fn) {
using Record = detail::record< continuation, StackAlloc, Fn >;
return continuation{
detail::context_create< Record >(
salloc, std::forward< Fn >( fn) ) }.resume();
}
template< typename StackAlloc, typename Fn >
continuation
callcc( std::allocator_arg_t, preallocated palloc, StackAlloc salloc, Fn && fn) {
using Record = detail::record< continuation, StackAlloc, Fn >;
return continuation{
detail::context_create< Record >(
palloc, salloc, std::forward< Fn >( fn) ) }.resume();
}
#if defined(BOOST_USE_SEGMENTED_STACKS)
template<
typename Fn,
typename ... Arg
>
continuation
callcc( std::allocator_arg_t, segmented_stack, Fn &&, Arg ...);
template<
typename StackAlloc,
typename Fn,
typename ... Arg
>
continuation
callcc( std::allocator_arg_t, preallocated, segmented_stack, Fn &&, Arg ...);
#endif
// swap
inline
void swap( continuation & l, continuation & r) noexcept {
l.swap( r);
}
}}
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_CONTINUATION_H

373
linx64/include/boost/context/continuation_fcontext.hpp Normal file
View File

@@ -0,0 +1,373 @@
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_CONTINUATION_H
#define BOOST_CONTEXT_CONTINUATION_H
#include <boost/context/detail/config.hpp>
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <exception>
#include <functional>
#include <memory>
#include <ostream>
#include <tuple>
#include <utility>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/intrusive_ptr.hpp>
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
#include <boost/context/detail/exchange.hpp>
#endif
#if defined(BOOST_NO_CXX17_STD_INVOKE)
#include <boost/context/detail/invoke.hpp>
#endif
#include <boost/context/detail/disable_overload.hpp>
#include <boost/context/detail/exception.hpp>
#include <boost/context/detail/fcontext.hpp>
#include <boost/context/detail/tuple.hpp>
#include <boost/context/fixedsize_stack.hpp>
#include <boost/context/flags.hpp>
#include <boost/context/preallocated.hpp>
#include <boost/context/segmented_stack.hpp>
#include <boost/context/stack_context.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4702)
#endif
namespace boost {
namespace context {
namespace detail {
inline
transfer_t context_unwind( transfer_t t) {
throw forced_unwind( t.fctx);
return { nullptr, nullptr };
}
template< typename Rec >
transfer_t context_exit( transfer_t t) noexcept {
Rec * rec = static_cast< Rec * >( t.data);
// destroy context stack
rec->deallocate();
return { nullptr, nullptr };
}
template< typename Rec >
void context_entry( transfer_t t) noexcept {
// transfer control structure to the context-stack
Rec * rec = static_cast< Rec * >( t.data);
BOOST_ASSERT( nullptr != t.fctx);
BOOST_ASSERT( nullptr != rec);
try {
// jump back to `create_context()`
t = jump_fcontext( t.fctx, nullptr);
// start executing
t.fctx = rec->run( t.fctx);
} catch ( forced_unwind const& ex) {
t = { ex.fctx, nullptr };
#ifndef BOOST_ASSERT_IS_VOID
const_cast< forced_unwind & >( ex).caught = true;
#endif
}
BOOST_ASSERT( nullptr != t.fctx);
// destroy context-stack of `this`context on next context
ontop_fcontext( t.fctx, rec, context_exit< Rec >);
BOOST_ASSERT_MSG( false, "context already terminated");
}
template< typename Ctx, typename Fn >
transfer_t context_ontop( transfer_t t) {
auto p = static_cast< std::tuple< Fn > * >( t.data);
BOOST_ASSERT( nullptr != p);
typename std::decay< Fn >::type fn = std::get< 0 >( * p);
t.data = nullptr;
Ctx c{ t.fctx };
// execute function, pass continuation via reference
c = fn( std::move( c) );
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return { exchange( c.fctx_, nullptr), nullptr };
#else
return { std::exchange( c.fctx_, nullptr), nullptr };
#endif
}
template< typename Ctx, typename StackAlloc, typename Fn >
class record {
private:
stack_context sctx_;
typename std::decay< StackAlloc >::type salloc_;
typename std::decay< Fn >::type fn_;
static void destroy( record * p) noexcept {
typename std::decay< StackAlloc >::type salloc = std::move( p->salloc_);
stack_context sctx = p->sctx_;
// deallocate record
p->~record();
// destroy stack with stack allocator
salloc.deallocate( sctx);
}
public:
record( stack_context sctx, StackAlloc && salloc,
Fn && fn) noexcept :
sctx_( sctx),
salloc_( std::forward< StackAlloc >( salloc)),
fn_( std::forward< Fn >( fn) ) {
}
record( record const&) = delete;
record & operator=( record const&) = delete;
void deallocate() noexcept {
destroy( this);
}
fcontext_t run( fcontext_t fctx) {
Ctx c{ fctx };
// invoke context-function
#if defined(BOOST_NO_CXX17_STD_INVOKE)
c = boost::context::detail::invoke( fn_, std::move( c) );
#else
c = std::invoke( fn_, std::move( c) );
#endif
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( c.fctx_, nullptr);
#else
return std::exchange( c.fctx_, nullptr);
#endif
}
};
template< typename Record, typename StackAlloc, typename Fn >
fcontext_t create_context1( StackAlloc && salloc, Fn && fn) {
auto sctx = salloc.allocate();
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sizeof( Record) ) )
& ~static_cast< uintptr_t >( 0xff) );
// placment new for control structure on context stack
Record * record = new ( storage) Record{
sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
// 64byte gab between control structure and stack top
// should be 16byte aligned
void * stack_top = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( storage) - static_cast< uintptr_t >( 64) );
void * stack_bottom = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sctx.size) );
// create fast-context
const std::size_t size = reinterpret_cast< uintptr_t >( stack_top) - reinterpret_cast< uintptr_t >( stack_bottom);
const fcontext_t fctx = make_fcontext( stack_top, size, & context_entry< Record >);
BOOST_ASSERT( nullptr != fctx);
// transfer control structure to context-stack
return jump_fcontext( fctx, record).fctx;
}
template< typename Record, typename StackAlloc, typename Fn >
fcontext_t create_context2( preallocated palloc, StackAlloc && salloc, Fn && fn) {
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( palloc.sp) - static_cast< uintptr_t >( sizeof( Record) ) )
& ~ static_cast< uintptr_t >( 0xff) );
// placment new for control structure on context-stack
Record * record = new ( storage) Record{
palloc.sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
// 64byte gab between control structure and stack top
void * stack_top = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( storage) - static_cast< uintptr_t >( 64) );
void * stack_bottom = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( palloc.sctx.sp) - static_cast< uintptr_t >( palloc.sctx.size) );
// create fast-context
const std::size_t size = reinterpret_cast< uintptr_t >( stack_top) - reinterpret_cast< uintptr_t >( stack_bottom);
const fcontext_t fctx = make_fcontext( stack_top, size, & context_entry< Record >);
BOOST_ASSERT( nullptr != fctx);
// transfer control structure to context-stack
return jump_fcontext( fctx, record).fctx;
}
}
class continuation {
private:
template< typename Ctx, typename StackAlloc, typename Fn >
friend class detail::record;
template< typename Ctx, typename Fn >
friend detail::transfer_t
detail::context_ontop( detail::transfer_t);
template< typename StackAlloc, typename Fn >
friend continuation
callcc( std::allocator_arg_t, StackAlloc &&, Fn &&);
template< typename StackAlloc, typename Fn >
friend continuation
callcc( std::allocator_arg_t, preallocated, StackAlloc &&, Fn &&);
detail::fcontext_t fctx_{ nullptr };
continuation( detail::fcontext_t fctx) noexcept :
fctx_{ fctx } {
}
public:
continuation() noexcept = default;
~continuation() {
if ( BOOST_UNLIKELY( nullptr != fctx_) ) {
detail::ontop_fcontext(
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::exchange( fctx_, nullptr),
#else
std::exchange( fctx_, nullptr),
#endif
nullptr,
detail::context_unwind);
}
}
continuation( continuation && other) noexcept {
swap( other);
}
continuation & operator=( continuation && other) noexcept {
if ( BOOST_LIKELY( this != & other) ) {
continuation tmp = std::move( other);
swap( tmp);
}
return * this;
}
continuation( continuation const& other) noexcept = delete;
continuation & operator=( continuation const& other) noexcept = delete;
continuation resume() & {
return std::move( * this).resume();
}
continuation resume() && {
BOOST_ASSERT( nullptr != fctx_);
return { detail::jump_fcontext(
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::exchange( fctx_, nullptr),
#else
std::exchange( fctx_, nullptr),
#endif
nullptr).fctx };
}
template< typename Fn >
continuation resume_with( Fn && fn) & {
return std::move( * this).resume_with( std::forward< Fn >( fn) );
}
template< typename Fn >
continuation resume_with( Fn && fn) && {
BOOST_ASSERT( nullptr != fctx_);
auto p = std::make_tuple( std::forward< Fn >( fn) );
return { detail::ontop_fcontext(
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::exchange( fctx_, nullptr),
#else
std::exchange( fctx_, nullptr),
#endif
& p,
detail::context_ontop< continuation, Fn >).fctx };
}
explicit operator bool() const noexcept {
return nullptr != fctx_;
}
bool operator!() const noexcept {
return nullptr == fctx_;
}
bool operator<( continuation const& other) const noexcept {
return fctx_ < other.fctx_;
}
template< typename charT, class traitsT >
friend std::basic_ostream< charT, traitsT > &
operator<<( std::basic_ostream< charT, traitsT > & os, continuation const& other) {
if ( nullptr != other.fctx_) {
return os << other.fctx_;
} else {
return os << "{not-a-context}";
}
}
void swap( continuation & other) noexcept {
std::swap( fctx_, other.fctx_);
}
};
template<
typename Fn,
typename = detail::disable_overload< continuation, Fn >
>
continuation
callcc( Fn && fn) {
return callcc(
std::allocator_arg, fixedsize_stack(),
std::forward< Fn >( fn) );
}
template< typename StackAlloc, typename Fn >
continuation
callcc( std::allocator_arg_t, StackAlloc && salloc, Fn && fn) {
using Record = detail::record< continuation, StackAlloc, Fn >;
return continuation{
detail::create_context1< Record >(
std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) }.resume();
}
template< typename StackAlloc, typename Fn >
continuation
callcc( std::allocator_arg_t, preallocated palloc, StackAlloc && salloc, Fn && fn) {
using Record = detail::record< continuation, StackAlloc, Fn >;
return continuation{
detail::create_context2< Record >(
palloc, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) }.resume();
}
#if defined(BOOST_USE_SEGMENTED_STACKS)
template< typename Fn >
continuation
callcc( std::allocator_arg_t, segmented_stack, Fn &&);
template< typename StackAlloc, typename Fn >
continuation
callcc( std::allocator_arg_t, preallocated, segmented_stack, Fn &&);
#endif
inline
void swap( continuation & l, continuation & r) noexcept {
l.swap( r);
}
}}
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_CONTINUATION_H

526
linx64/include/boost/context/continuation_ucontext.hpp Normal file
View File

@@ -0,0 +1,526 @@
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_CONTINUATION_H
#define BOOST_CONTEXT_CONTINUATION_H
#include <boost/predef.h>
#if BOOST_OS_MACOS
#define _XOPEN_SOURCE 600
#endif
extern "C" {
#include <ucontext.h>
}
#include <boost/context/detail/config.hpp>
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <memory>
#include <ostream>
#include <system_error>
#include <tuple>
#include <utility>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/context/detail/disable_overload.hpp>
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
#include <boost/context/detail/exchange.hpp>
#endif
#include <boost/context/detail/externc.hpp>
#if defined(BOOST_NO_CXX17_STD_INVOKE)
#include <boost/context/detail/invoke.hpp>
#endif
#include <boost/context/fixedsize_stack.hpp>
#include <boost/context/flags.hpp>
#include <boost/context/preallocated.hpp>
#if defined(BOOST_USE_SEGMENTED_STACKS)
#include <boost/context/segmented_stack.hpp>
#endif
#include <boost/context/stack_context.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
namespace detail {
// tampoline function
// entered if the execution context
// is resumed for the first time
template< typename Record >
static void entry_func( void * data) noexcept {
Record * record = static_cast< Record * >( data);
BOOST_ASSERT( nullptr != record);
// start execution of toplevel context-function
record->run();
}
struct BOOST_CONTEXT_DECL activation_record {
ucontext_t uctx{};
stack_context sctx{};
bool main_ctx{ true };
activation_record * from{ nullptr };
std::function< activation_record*(activation_record*&) > ontop{};
bool terminated{ false };
bool force_unwind{ false };
#if defined(BOOST_USE_ASAN)
void * fake_stack{ nullptr };
void * stack_bottom{ nullptr };
std::size_t stack_size{ 0 };
#endif
static activation_record *& current() noexcept;
// used for toplevel-context
// (e.g. main context, thread-entry context)
activation_record() {
if ( BOOST_UNLIKELY( 0 != ::getcontext( & uctx) ) ) {
throw std::system_error(
std::error_code( errno, std::system_category() ),
"getcontext() failed");
}
}
activation_record( stack_context sctx_) noexcept :
sctx( sctx_ ),
main_ctx( false ) {
}
virtual ~activation_record() {
}
activation_record( activation_record const&) = delete;
activation_record & operator=( activation_record const&) = delete;
bool is_main_context() const noexcept {
return main_ctx;
}
activation_record * resume() {
from = current();
// store `this` in static, thread local pointer
// `this` will become the active (running) context
current() = this;
#if defined(BOOST_USE_SEGMENTED_STACKS)
// adjust segmented stack properties
__splitstack_getcontext( from->sctx.segments_ctx);
__splitstack_setcontext( sctx.segments_ctx);
#endif
#if defined(BOOST_USE_ASAN)
if ( terminated) {
__sanitizer_start_switch_fiber( nullptr, stack_bottom, stack_size);
} else {
__sanitizer_start_switch_fiber( & from->fake_stack, stack_bottom, stack_size);
}
#endif
// context switch from parent context to `this`-context
::swapcontext( & from->uctx, & uctx);
#if defined(BOOST_USE_ASAN)
__sanitizer_finish_switch_fiber( current()->fake_stack,
(const void **) & current()->from->stack_bottom,
& current()->from->stack_size);
#endif
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( current()->from, nullptr);
#else
return std::exchange( current()->from, nullptr);
#endif
}
template< typename Ctx, typename Fn >
activation_record * resume_with( Fn && fn) {
from = current();
// store `this` in static, thread local pointer
// `this` will become the active (running) context
// returned by continuation::current()
current() = this;
#if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)
current()->ontop = std::bind(
[](typename std::decay< Fn >::type & fn, activation_record *& ptr){
Ctx c{ ptr };
c = fn( std::move( c) );
if ( ! c) {
ptr = nullptr;
}
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( c.ptr_, nullptr);
#else
return std::exchange( c.ptr_, nullptr);
#endif
},
std::forward< Fn >( fn),
std::placeholders::_1);
#else
current()->ontop = [fn=std::forward<Fn>(fn)](activation_record *& ptr){
Ctx c{ ptr };
c = fn( std::move( c) );
if ( ! c) {
ptr = nullptr;
}
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( c.ptr_, nullptr);
#else
return std::exchange( c.ptr_, nullptr);
#endif
};
#endif
#if defined(BOOST_USE_SEGMENTED_STACKS)
// adjust segmented stack properties
__splitstack_getcontext( from->sctx.segments_ctx);
__splitstack_setcontext( sctx.segments_ctx);
#endif
#if defined(BOOST_USE_ASAN)
__sanitizer_start_switch_fiber( & from->fake_stack, stack_bottom, stack_size);
#endif
// context switch from parent context to `this`-context
::swapcontext( & from->uctx, & uctx);
#if defined(BOOST_USE_ASAN)
__sanitizer_finish_switch_fiber( current()->fake_stack,
(const void **) & current()->from->stack_bottom,
& current()->from->stack_size);
#endif
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( current()->from, nullptr);
#else
return std::exchange( current()->from, nullptr);
#endif
}
virtual void deallocate() noexcept {
}
};
struct BOOST_CONTEXT_DECL activation_record_initializer {
activation_record_initializer() noexcept;
~activation_record_initializer();
};
struct forced_unwind {
activation_record * from{ nullptr };
#ifndef BOOST_ASSERT_IS_VOID
bool caught{ false };
#endif
forced_unwind( activation_record * from_) noexcept :
from{ from_ } {
}
#ifndef BOOST_ASSERT_IS_VOID
~forced_unwind() {
BOOST_ASSERT( caught);
}
#endif
};
template< typename Ctx, typename StackAlloc, typename Fn >
class capture_record : public activation_record {
private:
typename std::decay< StackAlloc >::type salloc_;
typename std::decay< Fn >::type fn_;
static void destroy( capture_record * p) noexcept {
typename std::decay< StackAlloc >::type salloc = std::move( p->salloc_);
stack_context sctx = p->sctx;
// deallocate activation record
p->~capture_record();
// destroy stack with stack allocator
salloc.deallocate( sctx);
}
public:
capture_record( stack_context sctx, StackAlloc && salloc, Fn && fn) noexcept :
activation_record{ sctx },
salloc_{ std::forward< StackAlloc >( salloc) },
fn_( std::forward< Fn >( fn) ) {
}
void deallocate() noexcept override final {
BOOST_ASSERT( main_ctx || ( ! main_ctx && terminated) );
destroy( this);
}
void run() {
#if defined(BOOST_USE_ASAN)
__sanitizer_finish_switch_fiber( fake_stack,
(const void **) & from->stack_bottom,
& from->stack_size);
#endif
Ctx c{ from };
try {
// invoke context-function
#if defined(BOOST_NO_CXX17_STD_INVOKE)
c = boost::context::detail::invoke( fn_, std::move( c) );
#else
c = std::invoke( fn_, std::move( c) );
#endif
} catch ( forced_unwind const& ex) {
c = Ctx{ ex.from };
#ifndef BOOST_ASSERT_IS_VOID
const_cast< forced_unwind & >( ex).caught = true;
#endif
}
// this context has finished its task
from = nullptr;
ontop = nullptr;
terminated = true;
force_unwind = false;
c.resume();
BOOST_ASSERT_MSG( false, "continuation already terminated");
}
};
template< typename Ctx, typename StackAlloc, typename Fn >
static activation_record * create_context1( StackAlloc && salloc, Fn && fn) {
typedef capture_record< Ctx, StackAlloc, Fn > capture_t;
auto sctx = salloc.allocate();
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
& ~ static_cast< uintptr_t >( 0xff) );
// placment new for control structure on context stack
capture_t * record = new ( storage) capture_t{
sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
// stack bottom
void * stack_bottom = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sctx.size) );
// create user-context
if ( BOOST_UNLIKELY( 0 != ::getcontext( & record->uctx) ) ) {
record->~capture_t();
salloc.deallocate( sctx);
throw std::system_error(
std::error_code( errno, std::system_category() ),
"getcontext() failed");
}
record->uctx.uc_stack.ss_sp = stack_bottom;
// 64byte gap between control structure and stack top
record->uctx.uc_stack.ss_size = reinterpret_cast< uintptr_t >( storage) -
reinterpret_cast< uintptr_t >( stack_bottom) - static_cast< uintptr_t >( 64);
record->uctx.uc_link = nullptr;
::makecontext( & record->uctx, ( void (*)() ) & entry_func< capture_t >, 1, record);
#if defined(BOOST_USE_ASAN)
record->stack_bottom = record->uctx.uc_stack.ss_sp;
record->stack_size = record->uctx.uc_stack.ss_size;
#endif
return record;
}
template< typename Ctx, typename StackAlloc, typename Fn >
static activation_record * create_context2( preallocated palloc, StackAlloc && salloc, Fn && fn) {
typedef capture_record< Ctx, StackAlloc, Fn > capture_t;
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( palloc.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
& ~ static_cast< uintptr_t >( 0xff) );
// placment new for control structure on context stack
capture_t * record = new ( storage) capture_t{
palloc.sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
// stack bottom
void * stack_bottom = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( palloc.sctx.sp) - static_cast< uintptr_t >( palloc.sctx.size) );
// create user-context
if ( BOOST_UNLIKELY( 0 != ::getcontext( & record->uctx) ) ) {
record->~capture_t();
salloc.deallocate( palloc.sctx);
throw std::system_error(
std::error_code( errno, std::system_category() ),
"getcontext() failed");
}
record->uctx.uc_stack.ss_sp = stack_bottom;
// 64byte gap between control structure and stack top
record->uctx.uc_stack.ss_size = reinterpret_cast< uintptr_t >( storage) -
reinterpret_cast< uintptr_t >( stack_bottom) - static_cast< uintptr_t >( 64);
record->uctx.uc_link = nullptr;
::makecontext( & record->uctx, ( void (*)() ) & entry_func< capture_t >, 1, record);
#if defined(BOOST_USE_ASAN)
record->stack_bottom = record->uctx.uc_stack.ss_sp;
record->stack_size = record->uctx.uc_stack.ss_size;
#endif
return record;
}
}
class BOOST_CONTEXT_DECL continuation {
private:
friend struct detail::activation_record;
template< typename Ctx, typename StackAlloc, typename Fn >
friend class detail::capture_record;
template< typename Ctx, typename StackAlloc, typename Fn >
friend detail::activation_record * detail::create_context1( StackAlloc &&, Fn &&);
template< typename Ctx, typename StackAlloc, typename Fn >
friend detail::activation_record * detail::create_context2( preallocated, StackAlloc &&, Fn &&);
template< typename StackAlloc, typename Fn >
friend continuation
callcc( std::allocator_arg_t, StackAlloc &&, Fn &&);
template< typename StackAlloc, typename Fn >
friend continuation
callcc( std::allocator_arg_t, preallocated, StackAlloc &&, Fn &&);
detail::activation_record * ptr_{ nullptr };
continuation( detail::activation_record * ptr) noexcept :
ptr_{ ptr } {
}
public:
continuation() = default;
~continuation() {
if ( BOOST_UNLIKELY( nullptr != ptr_) && ! ptr_->main_ctx) {
if ( BOOST_LIKELY( ! ptr_->terminated) ) {
ptr_->force_unwind = true;
ptr_->resume();
BOOST_ASSERT( ptr_->terminated);
}
ptr_->deallocate();
}
}
continuation( continuation const&) = delete;
continuation & operator=( continuation const&) = delete;
continuation( continuation && other) noexcept {
swap( other);
}
continuation & operator=( continuation && other) noexcept {
if ( BOOST_LIKELY( this != & other) ) {
continuation tmp = std::move( other);
swap( tmp);
}
return * this;
}
continuation resume() & {
return std::move( * this).resume();
}
continuation resume() && {
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::activation_record * ptr = detail::exchange( ptr_, nullptr)->resume();
#else
detail::activation_record * ptr = std::exchange( ptr_, nullptr)->resume();
#endif
if ( BOOST_UNLIKELY( detail::activation_record::current()->force_unwind) ) {
throw detail::forced_unwind{ ptr};
} else if ( BOOST_UNLIKELY( nullptr != detail::activation_record::current()->ontop) ) {
ptr = detail::activation_record::current()->ontop( ptr);
detail::activation_record::current()->ontop = nullptr;
}
return { ptr };
}
template< typename Fn >
continuation resume_with( Fn && fn) & {
return std::move( * this).resume_with( std::forward< Fn >( fn) );
}
template< typename Fn >
continuation resume_with( Fn && fn) && {
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::activation_record * ptr =
detail::exchange( ptr_, nullptr)->resume_with< continuation >( std::forward< Fn >( fn) );
#else
detail::activation_record * ptr =
std::exchange( ptr_, nullptr)->resume_with< continuation >( std::forward< Fn >( fn) );
#endif
if ( BOOST_UNLIKELY( detail::activation_record::current()->force_unwind) ) {
throw detail::forced_unwind{ ptr};
} else if ( BOOST_UNLIKELY( nullptr != detail::activation_record::current()->ontop) ) {
ptr = detail::activation_record::current()->ontop( ptr);
detail::activation_record::current()->ontop = nullptr;
}
return { ptr };
}
explicit operator bool() const noexcept {
return nullptr != ptr_ && ! ptr_->terminated;
}
bool operator!() const noexcept {
return nullptr == ptr_ || ptr_->terminated;
}
bool operator<( continuation const& other) const noexcept {
return ptr_ < other.ptr_;
}
template< typename charT, class traitsT >
friend std::basic_ostream< charT, traitsT > &
operator<<( std::basic_ostream< charT, traitsT > & os, continuation const& other) {
if ( nullptr != other.ptr_) {
return os << other.ptr_;
} else {
return os << "{not-a-context}";
}
}
void swap( continuation & other) noexcept {
std::swap( ptr_, other.ptr_);
}
};
template<
typename Fn,
typename = detail::disable_overload< continuation, Fn >
>
continuation
callcc( Fn && fn) {
return callcc(
std::allocator_arg,
#if defined(BOOST_USE_SEGMENTED_STACKS)
segmented_stack(),
#else
fixedsize_stack(),
#endif
std::forward< Fn >( fn) );
}
template< typename StackAlloc, typename Fn >
continuation
callcc( std::allocator_arg_t, StackAlloc && salloc, Fn && fn) {
return continuation{
detail::create_context1< continuation >(
std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) }.resume();
}
template< typename StackAlloc, typename Fn >
continuation
callcc( std::allocator_arg_t, preallocated palloc, StackAlloc && salloc, Fn && fn) {
return continuation{
detail::create_context2< continuation >(
palloc, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) }.resume();
}
inline
void swap( continuation & l, continuation & r) noexcept {
l.swap( r);
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_CONTINUATION_H

461
linx64/include/boost/context/continuation_winfib.hpp Normal file
View File

@@ -0,0 +1,461 @@
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_CONTINUATION_H
#define BOOST_CONTEXT_CONTINUATION_H
#include <windows.h>
#include <boost/context/detail/config.hpp>
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <memory>
#include <ostream>
#include <system_error>
#include <tuple>
#include <utility>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/context/detail/disable_overload.hpp>
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
#include <boost/context/detail/exchange.hpp>
#endif
#if defined(BOOST_NO_CXX17_STD_INVOKE)
#include <boost/context/detail/invoke.hpp>
#endif
#include <boost/context/fixedsize_stack.hpp>
#include <boost/context/flags.hpp>
#include <boost/context/preallocated.hpp>
#include <boost/context/stack_context.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4702)
#endif
namespace boost {
namespace context {
namespace detail {
// tampoline function
// entered if the execution context
// is resumed for the first time
template< typename Record >
static VOID WINAPI entry_func( LPVOID data) noexcept {
Record * record = static_cast< Record * >( data);
BOOST_ASSERT( nullptr != record);
// start execution of toplevel context-function
record->run();
}
struct BOOST_CONTEXT_DECL activation_record {
LPVOID fiber{ nullptr };
stack_context sctx{};
bool main_ctx{ true };
activation_record * from{ nullptr };
std::function< activation_record*(activation_record*&) > ontop{};
bool terminated{ false };
bool force_unwind{ false };
static activation_record *& current() noexcept;
// used for toplevel-context
// (e.g. main context, thread-entry context)
activation_record() noexcept {
#if ( _WIN32_WINNT > 0x0600)
if ( ::IsThreadAFiber() ) {
fiber = ::GetCurrentFiber();
} else {
fiber = ::ConvertThreadToFiber( nullptr);
}
#else
fiber = ::ConvertThreadToFiber( nullptr);
if ( BOOST_UNLIKELY( nullptr == fiber) ) {
DWORD err = ::GetLastError();
BOOST_ASSERT( ERROR_ALREADY_FIBER == err);
fiber = ::GetCurrentFiber();
BOOST_ASSERT( nullptr != fiber);
BOOST_ASSERT( reinterpret_cast< LPVOID >( 0x1E00) != fiber);
}
#endif
}
activation_record( stack_context sctx_) noexcept :
sctx{ sctx_ },
main_ctx{ false } {
}
virtual ~activation_record() {
if ( BOOST_UNLIKELY( main_ctx) ) {
::ConvertFiberToThread();
} else {
::DeleteFiber( fiber);
}
}
activation_record( activation_record const&) = delete;
activation_record & operator=( activation_record const&) = delete;
bool is_main_context() const noexcept {
return main_ctx;
}
activation_record * resume() {
from = current();
// store `this` in static, thread local pointer
// `this` will become the active (running) context
current() = this;
// context switch from parent context to `this`-context
// context switch
::SwitchToFiber( fiber);
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return detail::exchange( current()->from, nullptr);
#else
return std::exchange( current()->from, nullptr);
#endif
}
template< typename Ctx, typename Fn >
activation_record * resume_with( Fn && fn) {
from = current();
// store `this` in static, thread local pointer
// `this` will become the active (running) context
// returned by continuation::current()
current() = this;
#if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)
current()->ontop = std::bind(
[](typename std::decay< Fn >::type & fn, activation_record *& ptr){
Ctx c{ ptr };
c = fn( std::move( c) );
if ( ! c) {
ptr = nullptr;
}
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( c.ptr_, nullptr);
#else
return std::exchange( c.ptr_, nullptr);
#endif
},
std::forward< Fn >( fn),
std::placeholders::_1);
#else
current()->ontop = [fn=std::forward<Fn>(fn)](activation_record *& ptr){
Ctx c{ ptr };
c = fn( std::move( c) );
if ( ! c) {
ptr = nullptr;
}
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( c.ptr_, nullptr);
#else
return std::exchange( c.ptr_, nullptr);
#endif
};
#endif
// context switch
::SwitchToFiber( fiber);
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return detail::exchange( current()->from, nullptr);
#else
return std::exchange( current()->from, nullptr);
#endif
}
virtual void deallocate() noexcept {
}
};
struct BOOST_CONTEXT_DECL activation_record_initializer {
activation_record_initializer() noexcept;
~activation_record_initializer();
};
struct forced_unwind {
activation_record * from{ nullptr };
#ifndef BOOST_ASSERT_IS_VOID
bool caught{ false };
#endif
explicit forced_unwind( activation_record * from_) :
from{ from_ } {
}
#ifndef BOOST_ASSERT_IS_VOID
~forced_unwind() {
BOOST_ASSERT( caught);
}
#endif
};
template< typename Ctx, typename StackAlloc, typename Fn >
class capture_record : public activation_record {
private:
typename std::decay< StackAlloc >::type salloc_;
typename std::decay< Fn >::type fn_;
static void destroy( capture_record * p) noexcept {
typename std::decay< StackAlloc >::type salloc = std::move( p->salloc_);
stack_context sctx = p->sctx;
// deallocate activation record
p->~capture_record();
// destroy stack with stack allocator
salloc.deallocate( sctx);
}
public:
capture_record( stack_context sctx, StackAlloc && salloc, Fn && fn) noexcept :
activation_record( sctx),
salloc_( std::forward< StackAlloc >( salloc)),
fn_( std::forward< Fn >( fn) ) {
}
void deallocate() noexcept override final {
BOOST_ASSERT( main_ctx || ( ! main_ctx && terminated) );
destroy( this);
}
void run() {
Ctx c{ from };
try {
// invoke context-function
#if defined(BOOST_NO_CXX17_STD_INVOKE)
c = boost::context::detail::invoke( fn_, std::move( c) );
#else
c = std::invoke( fn_, std::move( c) );
#endif
} catch ( forced_unwind const& ex) {
c = Ctx{ ex.from };
#ifndef BOOST_ASSERT_IS_VOID
const_cast< forced_unwind & >( ex).caught = true;
#endif
}
// this context has finished its task
from = nullptr;
ontop = nullptr;
terminated = true;
force_unwind = false;
c.resume();
BOOST_ASSERT_MSG( false, "continuation already terminated");
}
};
template< typename Ctx, typename StackAlloc, typename Fn >
static activation_record * create_context1( StackAlloc && salloc, Fn && fn) {
typedef capture_record< Ctx, StackAlloc, Fn > capture_t;
auto sctx = salloc.allocate();
BOOST_ASSERT( ( sizeof( capture_t) ) < sctx.size);
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
& ~ static_cast< uintptr_t >( 0xff) );
// placment new for control structure on context stack
capture_t * record = new ( storage) capture_t{
sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
// create user-context
record->fiber = ::CreateFiber( sctx.size, & detail::entry_func< capture_t >, record);
return record;
}
template< typename Ctx, typename StackAlloc, typename Fn >
static activation_record * create_context2( preallocated palloc, StackAlloc && salloc, Fn && fn) {
typedef capture_record< Ctx, StackAlloc, Fn > capture_t;
BOOST_ASSERT( ( sizeof( capture_t) ) < palloc.size);
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( palloc.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
& ~ static_cast< uintptr_t >( 0xff) );
// placment new for control structure on context stack
capture_t * record = new ( storage) capture_t{
palloc.sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
// create user-context
record->fiber = ::CreateFiber( palloc.sctx.size, & detail::entry_func< capture_t >, record);
return record;
}
}
class BOOST_CONTEXT_DECL continuation {
private:
friend struct detail::activation_record;
template< typename Ctx, typename StackAlloc, typename Fn >
friend class detail::capture_record;
template< typename Ctx, typename StackAlloc, typename Fn >
friend detail::activation_record * detail::create_context1( StackAlloc &&, Fn &&);
template< typename Ctx, typename StackAlloc, typename Fn >
friend detail::activation_record * detail::create_context2( preallocated, StackAlloc &&, Fn &&);
template< typename StackAlloc, typename Fn >
friend continuation
callcc( std::allocator_arg_t, StackAlloc &&, Fn &&);
template< typename StackAlloc, typename Fn >
friend continuation
callcc( std::allocator_arg_t, preallocated, StackAlloc &&, Fn &&);
detail::activation_record * ptr_{ nullptr };
continuation( detail::activation_record * ptr) noexcept :
ptr_{ ptr } {
}
public:
continuation() = default;
~continuation() {
if ( BOOST_UNLIKELY( nullptr != ptr_) && ! ptr_->main_ctx) {
if ( BOOST_LIKELY( ! ptr_->terminated) ) {
ptr_->force_unwind = true;
ptr_->resume();
BOOST_ASSERT( ptr_->terminated);
}
ptr_->deallocate();
}
}
continuation( continuation const&) = delete;
continuation & operator=( continuation const&) = delete;
continuation( continuation && other) noexcept {
swap( other);
}
continuation & operator=( continuation && other) noexcept {
if ( BOOST_LIKELY( this != & other) ) {
continuation tmp = std::move( other);
swap( tmp);
}
return * this;
}
continuation resume() & {
return std::move( * this).resume();
}
continuation resume() && {
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::activation_record * ptr = detail::exchange( ptr_, nullptr)->resume();
#else
detail::activation_record * ptr = std::exchange( ptr_, nullptr)->resume();
#endif
if ( BOOST_UNLIKELY( detail::activation_record::current()->force_unwind) ) {
throw detail::forced_unwind{ ptr};
} else if ( BOOST_UNLIKELY( nullptr != detail::activation_record::current()->ontop) ) {
ptr = detail::activation_record::current()->ontop( ptr);
detail::activation_record::current()->ontop = nullptr;
}
return { ptr };
}
template< typename Fn >
continuation resume_with( Fn && fn) & {
return std::move( * this).resume_with( std::forward< Fn >( fn) );
}
template< typename Fn >
continuation resume_with( Fn && fn) && {
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::activation_record * ptr =
detail::exchange( ptr_, nullptr)->resume_with< continuation >( std::forward< Fn >( fn) );
#else
detail::activation_record * ptr =
std::exchange( ptr_, nullptr)->resume_with< continuation >( std::forward< Fn >( fn) );
#endif
if ( BOOST_UNLIKELY( detail::activation_record::current()->force_unwind) ) {
throw detail::forced_unwind{ ptr};
} else if ( BOOST_UNLIKELY( nullptr != detail::activation_record::current()->ontop) ) {
ptr = detail::activation_record::current()->ontop( ptr);
detail::activation_record::current()->ontop = nullptr;
}
return { ptr };
}
explicit operator bool() const noexcept {
return nullptr != ptr_ && ! ptr_->terminated;
}
bool operator!() const noexcept {
return nullptr == ptr_ || ptr_->terminated;
}
bool operator<( continuation const& other) const noexcept {
return ptr_ < other.ptr_;
}
template< typename charT, class traitsT >
friend std::basic_ostream< charT, traitsT > &
operator<<( std::basic_ostream< charT, traitsT > & os, continuation const& other) {
if ( nullptr != other.ptr_) {
return os << other.ptr_;
} else {
return os << "{not-a-context}";
}
}
void swap( continuation & other) noexcept {
std::swap( ptr_, other.ptr_);
}
};
template<
typename Fn,
typename = detail::disable_overload< continuation, Fn >
>
continuation
callcc( Fn && fn) {
return callcc(
std::allocator_arg,
fixedsize_stack(),
std::forward< Fn >( fn) );
}
template< typename StackAlloc, typename Fn >
continuation
callcc( std::allocator_arg_t, StackAlloc && salloc, Fn && fn) {
return continuation{
detail::create_context1< continuation >(
std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) }.resume();
}
template< typename StackAlloc, typename Fn >
continuation
callcc( std::allocator_arg_t, preallocated palloc, StackAlloc && salloc, Fn && fn) {
return continuation{
detail::create_context2< continuation >(
palloc, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) }.resume();
}
inline
void swap( continuation & l, continuation & r) noexcept {
l.swap( r);
}
}}
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_CONTINUATION_H

4
linx64/include/boost/context/detail/apply.hpp
View File

@@ -37,13 +37,13 @@ template< typename Fn, typename Tpl, std::size_t ... I >
auto
apply_impl( Fn && fn, Tpl && tpl, index_sequence< I ... >)
#if defined(BOOST_NO_CXX17_STD_INVOKE)
-> decltype( invoke( std::forward< Fn >( fn), std::get< I >( std::forward< Tpl >( tpl) ) ... ) )
-> decltype( boost::context::detail::invoke( std::forward< Fn >( fn), std::get< I >( std::forward< Tpl >( tpl) ) ... ) )
#else
-> decltype( std::invoke( std::forward< Fn >( fn), std::get< I >( std::forward< Tpl >( tpl) ) ... ) )
#endif
{
#if defined(BOOST_NO_CXX17_STD_INVOKE)
return invoke( std::forward< Fn >( fn), std::get< I >( std::forward< Tpl >( tpl) ) ... );
return boost::context::detail::invoke( std::forward< Fn >( fn), std::get< I >( std::forward< Tpl >( tpl) ) ... );
#else
return std::invoke( std::forward< Fn >( fn), std::get< I >( std::forward< Tpl >( tpl) ) ... );
#endif

20
linx64/include/boost/context/detail/config.hpp
View File

@@ -104,4 +104,24 @@
# endif
#endif
#if ! defined(BOOST_NO_CXX11_CONSTEXPR)
// modern architectures have cachelines with 64byte length
// ARM Cortex-A15 32/64byte, Cortex-A9 16/32/64bytes
// MIPS 74K: 32byte, 4KEc: 16byte
// ist should be safe to use 64byte for all
static constexpr std::size_t cache_alignment{ 64 };
static constexpr std::size_t cacheline_length{ 64 };
// lookahead size for prefetching
static constexpr std::size_t prefetch_stride{ 4 * cacheline_length };
#endif
#if defined(__GLIBCPP__) || defined(__GLIBCXX__)
// GNU libstdc++ 3
# define BOOST_CONTEXT_HAS_CXXABI_H
#endif
#if defined( BOOST_CONTEXT_HAS_CXXABI_H )
# include <cxxabi.h>
#endif
#endif // BOOST_CONTEXT_DETAIL_CONFIG_H

14
linx64/include/boost/context/detail/exception.hpp
View File

@@ -7,6 +7,7 @@
#ifndef BOOST_CONTEXT_DETAIL_EXCEPTION_H
#define BOOST_CONTEXT_DETAIL_EXCEPTION_H
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/context/detail/fcontext.hpp>
@@ -20,11 +21,22 @@ namespace context {
namespace detail {
struct forced_unwind {
fcontext_t fctx;
fcontext_t fctx{ nullptr };
#ifndef BOOST_ASSERT_IS_VOID
bool caught{ false };
#endif
forced_unwind() = default;
forced_unwind( fcontext_t fctx_) :
fctx( fctx_) {
}
#ifndef BOOST_ASSERT_IS_VOID
~forced_unwind() {
BOOST_ASSERT( caught);
}
#endif
};
}}}

23
linx64/include/boost/context/detail/externc.hpp Normal file
View File

@@ -0,0 +1,23 @@
// Copyright Oliver Kowalke 2014.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <boost/config.hpp>
#include <boost/context/detail/config.hpp>
#if defined(BOOST_USE_ASAN)
extern "C" {
void __sanitizer_start_switch_fiber( void **, const void *, size_t);
void __sanitizer_finish_switch_fiber( void *, const void **, size_t *);
}
#endif
#if defined(BOOST_USE_SEGMENTED_STACKS)
extern "C" {
void __splitstack_getcontext( void * [BOOST_CONTEXT_SEGMENTS]);
void __splitstack_setcontext( void * [BOOST_CONTEXT_SEGMENTS]);
}
#endif

68
linx64/include/boost/context/detail/fcontext_arm.hpp
View File

@@ -1,68 +0,0 @@
// Copyright Oliver Kowalke 2009.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_ARM_H
#define BOOST_CONTEXT_DETAIL_FCONTEXT_ARM_H
#include <cstddef>
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/context/detail/config.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
extern "C" {
#define BOOST_CONTEXT_CALLDECL
struct stack_t
{
void * sp;
std::size_t size;
stack_t() :
sp( 0), size( 0)
{}
};
struct fp_t
{
boost::uint32_t fc_freg[16];
fp_t() :
fc_freg()
{}
};
struct fcontext_t
{
boost::uint32_t fc_greg[11];
stack_t fc_stack;
fp_t fc_fp;
fcontext_t() :
fc_greg(),
fc_stack(),
fc_fp()
{}
};
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_ARM_H

70
linx64/include/boost/context/detail/fcontext_arm_mac.hpp
View File

@@ -1,70 +0,0 @@
// Copyright Oliver Kowalke 2009.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_ARM_MAC_H
#define BOOST_CONTEXT_DETAIL_FCONTEXT_ARM_MAC_H
#include <cstddef>
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/context/detail/config.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
extern "C" {
#define BOOST_CONTEXT_CALLDECL
struct stack_t
{
void * sp;
std::size_t size;
stack_t() :
sp( 0), size( 0)
{}
};
struct fp_t
{
boost::uint32_t fc_freg[16];
fp_t() :
fc_freg()
{}
};
struct fcontext_t
{
boost::uint32_t fc_greg[11];
stack_t fc_stack;
fp_t fc_fp;
void * fc_unwind_sjlj;
fcontext_t() :
fc_greg(),
fc_stack(),
fc_fp(),
fc_unwind_sjlj( 0)
{}
};
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_ARM_MAC_H

71
linx64/include/boost/context/detail/fcontext_arm_win.hpp
View File

@@ -1,71 +0,0 @@
// Copyright Oliver Kowalke 2009.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_ARM_WIN_H
#define BOOST_CONTEXT_DETAIL_FCONTEXT_ARM_WIN_H
#include <cstddef>
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/context/detail/config.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
extern "C" {
#define BOOST_CONTEXT_CALLDECL
struct stack_t
{
void * sp;
std::size_t size;
void * limit;
stack_t() :
sp( 0), size( 0), limit( 0)
{}
};
struct fp_t
{
boost::uint32_t fc_freg[16];
fp_t() :
fc_freg()
{}
};
struct fcontext_t
{
boost::uint32_t fc_greg[11];
stack_t fc_stack;
fp_t fc_fp;
boost::uint32_t fc_dealloc;
fcontext_t() :
fc_greg(),
fc_stack(),
fc_fp(),
fc_dealloc( 0)
{}
};
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_ARM_WIN_H

59
linx64/include/boost/context/detail/fcontext_i386.hpp
View File

@@ -1,59 +0,0 @@
// Copyright Oliver Kowalke 2009.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_I386H
#define BOOST_CONTEXT_DETAIL_FCONTEXT_I386H
#include <cstddef>
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/context/detail/config.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
extern "C" {
#define BOOST_CONTEXT_CALLDECL __attribute__((cdecl))
struct stack_t
{
void * sp;
std::size_t size;
stack_t() :
sp( 0), size( 0)
{}
};
struct fcontext_t
{
boost::uint32_t fc_greg[6];
stack_t fc_stack;
boost::uint32_t fc_freg[2];
fcontext_t() :
fc_greg(),
fc_stack(),
fc_freg()
{}
};
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_I386_H

88
linx64/include/boost/context/detail/fcontext_i386_win.hpp
View File

@@ -1,88 +0,0 @@
// Copyright Oliver Kowalke 2009.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_I386H
#define BOOST_CONTEXT_DETAIL_FCONTEXT_I386H
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <cstddef>
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/context/detail/config.hpp>
#if defined(BOOST_MSVC)
#pragma warning(push)
#pragma warning(disable:4351)
#endif
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
extern "C" {
#define BOOST_CONTEXT_CALLDECL __cdecl
struct stack_t
{
void * sp;
std::size_t size;
void * limit;
stack_t() :
sp( 0), size( 0), limit( 0)
{}
};
struct fp_t
{
boost::uint32_t fc_freg[2];
fp_t() :
fc_freg()
{}
};
struct fcontext_t
{
boost::uint32_t fc_greg[6];
stack_t fc_stack;
void * fc_excpt_lst;
void * fc_local_storage;
fp_t fc_fp;
boost::uint32_t fc_dealloc;
fcontext_t() :
fc_greg(),
fc_stack(),
fc_excpt_lst( 0),
fc_local_storage( 0),
fc_fp(),
fc_dealloc( 0)
{}
};
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#if defined(BOOST_MSVC)
#pragma warning(pop)
#endif
#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_I386_H

70
linx64/include/boost/context/detail/fcontext_mips.hpp
View File

@@ -1,70 +0,0 @@
// Copyright Oliver Kowalke 2009.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_MIPS_H
#define BOOST_CONTEXT_DETAIL_FCONTEXT_MIPS_H
#include <cstddef>
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/context/detail/config.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
extern "C" {
#define BOOST_CONTEXT_CALLDECL
// on MIPS we assume 64bit regsiters - even for 32bit ABIs
struct stack_t
{
void * sp;
std::size_t size;
stack_t() :
sp( 0), size( 0)
{}
};
struct fp_t
{
boost::uint64_t fc_freg[6];
fp_t() :
fc_freg()
{}
};
struct fcontext_t
{
boost::uint32_t fc_greg[12];
stack_t fc_stack;
fp_t fc_fp;
fcontext_t() :
fc_greg(),
fc_stack(),
fc_fp()
{}
};
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_MIPS_H

72
linx64/include/boost/context/detail/fcontext_ppc.hpp
View File

@@ -1,72 +0,0 @@
// Copyright Oliver Kowalke 2009.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_PPC_H
#define BOOST_CONTEXT_DETAIL_FCONTEXT_PPC_H
#include <cstddef>
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/context/detail/config.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
extern "C" {
#define BOOST_CONTEXT_CALLDECL
struct stack_t
{
void * sp;
std::size_t size;
stack_t() :
sp( 0), size( 0)
{}
};
struct fp_t
{
boost::uint64_t fc_freg[19];
fp_t() :
fc_freg()
{}
};
struct fcontext_t
{
# if defined(__powerpc64__)
boost::uint64_t fc_greg[23];
# else
boost::uint32_t fc_greg[23];
# endif
stack_t fc_stack;
fp_t fc_fp;
fcontext_t() :
fc_greg(),
fc_stack(),
fc_fp()
{}
};
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_PPC_H

90
linx64/include/boost/context/detail/fcontext_sparc.hpp
View File

@@ -1,90 +0,0 @@
// Copyright Martin Husemann 2012
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CTX_DETAIL_FCONTEXT_SPARC_H
#define BOOST_CTX_DETAIL_FCONTEXT_SPARC_H
#include <cstddef>
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/context/detail/config.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
extern "C" {
#define BOOST_CONTEXT_CALLDECL
// if defined(_LP64) we are compiling for sparc64, otherwise it is 32 bit
// sparc.
struct stack_t
{
void * sp;
std::size_t size;
stack_t() :
sp( 0), size( 0)
{}
};
struct fp_t
{
#ifdef _LP64
boost::uint64_t fp_freg[32];
boost::uint64_t fp_fprs, fp_fsr;
#else
boost::uint64_t fp_freg[16];
boost::uint32_t fp_fsr;
#endif
fp_t() :
fp_freg(),
#ifdef _LP64
fp_fprs(),
#endif
fp_fsr()
{}
}
#ifdef _LP64
__attribute__((__aligned__(64))) // allow VIS instructions to be used
#endif
;
struct fcontext_t
{
fp_t fc_fp; // fpu stuff first, for easier alignement
#ifdef _LP64
boost::uint64_t
#else
boost::uint32_t
#endif
fc_greg[8];
stack_t fc_stack;
fcontext_t() :
fc_fp(),
fc_greg(),
fc_stack()
{}
};
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CTX_DETAIL_FCONTEXT_SPARC_H

68
linx64/include/boost/context/detail/fcontext_x86_64.hpp
View File

@@ -1,68 +0,0 @@
// Copyright Oliver Kowalke 2009.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_X86_64_H
#define BOOST_CONTEXT_DETAIL_FCONTEXT_X86_64_H
#include <cstddef>
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/context/detail/config.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
extern "C" {
#define BOOST_CONTEXT_CALLDECL
struct stack_t
{
void * sp;
std::size_t size;
stack_t() :
sp( 0), size( 0)
{}
};
struct fp_t
{
boost::uint32_t fc_freg[2];
fp_t() :
fc_freg()
{}
};
struct fcontext_t
{
boost::uint64_t fc_greg[8];
stack_t fc_stack;
fp_t fc_fp;
fcontext_t() :
fc_greg(),
fc_stack(),
fc_fp()
{}
};
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_X86_64_H

77
linx64/include/boost/context/detail/fcontext_x86_64_win.hpp
View File

@@ -1,77 +0,0 @@
// Copyright Oliver Kowalke 2009.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_X86_64_H
#define BOOST_CONTEXT_DETAIL_FCONTEXT_X86_64_H
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <cstddef>
#include <boost/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/context/detail/config.hpp>
#if defined(BOOST_MSVC)
#pragma warning(push)
#pragma warning(disable:4351)
#endif
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
extern "C" {
#define BOOST_CONTEXT_CALLDECL
struct stack_t
{
void * sp;
std::size_t size;
void * limit;
stack_t() :
sp( 0), size( 0), limit( 0)
{}
};
struct fcontext_t
{
boost::uint64_t fc_greg[10];
stack_t fc_stack;
void * fc_local_storage;
boost::uint64_t fc_fp[24];
boost::uint64_t fc_dealloc;
fcontext_t() :
fc_greg(),
fc_stack(),
fc_local_storage( 0),
fc_fp(),
fc_dealloc()
{}
};
}
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#if defined(BOOST_MSVC)
#pragma warning(pop)
#endif
#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_X86_64_H

78
linx64/include/boost/context/detail/prefetch.hpp Normal file
View File

@@ -0,0 +1,78 @@
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_DETAIL_PREFETCH_H
#define BOOST_CONTEXT_DETAIL_PREFETCH_H
#include <cstddef>
#include <cstdint>
#include <boost/config.hpp>
#include <boost/predef.h>
#include <boost/context/detail/config.hpp>
#if BOOST_COMP_INTEL || BOOST_COMP_INTEL_EMULATED
#include <immintrin.h>
#endif
#if BOOST_COMP_MSVC
#include <mmintrin.h>
#endif
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
namespace detail {
#if BOOST_COMP_GNUC || BOOST_COMP_CLANG
#define BOOST_HAS_PREFETCH 1
BOOST_FORCEINLINE
void prefetch( void * addr) {
// L1 cache : hint == 1
__builtin_prefetch( addr, 1, 1);
}
#elif BOOST_COMP_INTEL || BOOST_COMP_INTEL_EMULATED
#define BOOST_HAS_PREFETCH 1
BOOST_FORCEINLINE
void prefetch( void * addr) {
// L1 cache : hint == _MM_HINT_T0
_mm_prefetch( (const char *)addr, _MM_HINT_T0);
}
#elif BOOST_COMP_MSVC
#define BOOST_HAS_PREFETCH 1
BOOST_FORCEINLINE
void prefetch( void * addr) {
// L1 cache : hint == _MM_HINT_T0
_mm_prefetch( (const char *)addr, _MM_HINT_T0);
}
#endif
inline
void prefetch_range( void * addr, std::size_t len) {
#if defined(BOOST_HAS_PREFETCH)
void * vp = addr;
void * end = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( addr) + static_cast< uintptr_t >( len) );
while ( vp < end) {
prefetch( vp);
vp = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( vp) + static_cast< uintptr_t >( prefetch_stride) );
}
#endif
}
#undef BOOST_HAS_PREFETCH
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_DETAIL_PREFETCH_H

13
linx64/include/boost/context/execution_context.hpp
View File

@@ -6,14 +6,7 @@
#include <boost/context/detail/config.hpp>
#if ! defined(BOOST_CONTEXT_NO_CXX11)
# if (defined(BOOST_EXECUTION_CONTEXT) && (BOOST_EXECUTION_CONTEXT == 1))
# if !defined(BOOST_NO_CXX11_THREAD_LOCAL)
# include <boost/context/execution_context_v1.hpp>
# else
# error "keyword thread_local not supported"
# endif
# else
# include <boost/context/execution_context_v2.hpp>
# endif
#if !defined(BOOST_NO_CXX11_THREAD_LOCAL)
# include <boost/context/execution_context_v1.hpp>
#endif
#include <boost/context/execution_context_v2.hpp>

144
linx64/include/boost/context/execution_context_v1.hpp
View File

@@ -4,8 +4,8 @@
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_EXECUTION_CONTEXT_H
#define BOOST_CONTEXT_EXECUTION_CONTEXT_H
#ifndef BOOST_CONTEXT_EXECUTION_CONTEXT_V1_H
#define BOOST_CONTEXT_EXECUTION_CONTEXT_V1_H
#include <boost/context/detail/config.hpp>
@@ -28,6 +28,7 @@
#include <boost/context/detail/apply.hpp>
#endif
#include <boost/context/detail/disable_overload.hpp>
#include <boost/context/detail/externc.hpp>
#include <boost/context/detail/fcontext.hpp>
#include <boost/context/fixedsize_stack.hpp>
#include <boost/context/flags.hpp>
@@ -39,31 +40,24 @@
# include BOOST_ABI_PREFIX
#endif
#if defined(BOOST_USE_SEGMENTED_STACKS)
extern "C" {
void __splitstack_getcontext( void * [BOOST_CONTEXT_SEGMENTS]);
void __splitstack_setcontext( void * [BOOST_CONTEXT_SEGMENTS]);
}
#endif
namespace boost {
namespace context {
namespace detail {
template< typename Fn >
transfer_t context_ontop( transfer_t);
transfer_t ecv1_context_ontop( transfer_t);
struct activation_record;
struct ecv1_activation_record;
struct data_t {
activation_record * from;
void * data;
struct ecv1_data_t {
ecv1_activation_record * from;
void * data;
};
struct BOOST_CONTEXT_DECL activation_record {
typedef boost::intrusive_ptr< activation_record > ptr_t;
struct BOOST_CONTEXT_DECL ecv1_activation_record {
typedef boost::intrusive_ptr< ecv1_activation_record > ptr_t;
thread_local static ptr_t current_rec;
static ptr_t & current() noexcept;
std::atomic< std::size_t > use_count{ 0 };
fcontext_t fctx{ nullptr };
@@ -72,15 +66,15 @@ struct BOOST_CONTEXT_DECL activation_record {
// used for toplevel-context
// (e.g. main context, thread-entry context)
activation_record() = default;
ecv1_activation_record() = default;
activation_record( fcontext_t fctx_, stack_context sctx_) noexcept :
ecv1_activation_record( fcontext_t fctx_, stack_context sctx_) noexcept :
fctx{ fctx_ },
sctx( sctx_ ), // sctx{ sctx_ } - clang-3.6: no viable conversion from 'boost::context::stack_context' to 'std::size_t'
main_ctx{ false } {
}
virtual ~activation_record() = default;
virtual ~ecv1_activation_record() = default;
bool is_main_context() const noexcept {
return main_ctx;
@@ -88,20 +82,20 @@ struct BOOST_CONTEXT_DECL activation_record {
void * resume( void * vp) {
// store current activation record in local variable
auto from = current_rec.get();
auto from = current().get();
// store `this` in static, thread local pointer
// `this` will become the active (running) context
// returned by execution_context::current()
current_rec = this;
current() = this;
#if defined(BOOST_USE_SEGMENTED_STACKS)
// adjust segmented stack properties
__splitstack_getcontext( from->sctx.segments_ctx);
__splitstack_setcontext( sctx.segments_ctx);
#endif
data_t d = { from, vp };
ecv1_data_t d = { from, vp };
// context switch from parent context to `this`-context
transfer_t t = jump_fcontext( fctx, & d);
data_t * dp = reinterpret_cast< data_t * >( t.data);
ecv1_data_t * dp = reinterpret_cast< ecv1_data_t * >( t.data);
dp->from->fctx = t.fctx;
// parent context resumed
return dp->data;
@@ -110,22 +104,22 @@ struct BOOST_CONTEXT_DECL activation_record {
template< typename Fn >
void * resume_ontop( void * data, Fn && fn) {
// store current activation record in local variable
activation_record * from = current_rec.get();
ecv1_activation_record * from = current().get();
// store `this` in static, thread local pointer
// `this` will become the active (running) context
// returned by execution_context::current()
current_rec = this;
current() = this;
#if defined(BOOST_USE_SEGMENTED_STACKS)
// adjust segmented stack properties
__splitstack_getcontext( from->sctx.segments_ctx);
__splitstack_setcontext( sctx.segments_ctx);
#endif
std::tuple< void *, Fn > p = std::forward_as_tuple( data, fn);
data_t d = { from, & p };
ecv1_data_t d = { from, & p };
// context switch from parent context to `this`-context
// execute Fn( Tpl) on top of `this`
transfer_t t = ontop_fcontext( fctx, & d, context_ontop< Fn >);
data_t * dp = reinterpret_cast< data_t * >( t.data);
transfer_t t = ontop_fcontext( fctx, & d, ecv1_context_ontop< Fn >);
ecv1_data_t * dp = reinterpret_cast< ecv1_data_t * >( t.data);
dp->from->fctx = t.fctx;
// parent context resumed
return dp->data;
@@ -134,11 +128,11 @@ struct BOOST_CONTEXT_DECL activation_record {
virtual void deallocate() noexcept {
}
friend void intrusive_ptr_add_ref( activation_record * ar) noexcept {
friend void intrusive_ptr_add_ref( ecv1_activation_record * ar) noexcept {
++ar->use_count;
}
friend void intrusive_ptr_release( activation_record * ar) noexcept {
friend void intrusive_ptr_release( ecv1_activation_record * ar) noexcept {
BOOST_ASSERT( nullptr != ar);
if ( 0 == --ar->use_count) {
ar->deallocate();
@@ -146,21 +140,21 @@ struct BOOST_CONTEXT_DECL activation_record {
}
};
struct BOOST_CONTEXT_DECL activation_record_initializer {
activation_record_initializer() noexcept;
~activation_record_initializer();
struct BOOST_CONTEXT_DECL ecv1_activation_record_initializer {
ecv1_activation_record_initializer() noexcept;
~ecv1_activation_record_initializer();
};
template< typename Fn >
transfer_t context_ontop( transfer_t t) {
data_t * dp = reinterpret_cast< data_t * >( t.data);
transfer_t ecv1_context_ontop( transfer_t t) {
ecv1_data_t * dp = reinterpret_cast< ecv1_data_t * >( t.data);
dp->from->fctx = t.fctx;
auto tpl = reinterpret_cast< std::tuple< void *, Fn > * >( dp->data);
BOOST_ASSERT( nullptr != tpl);
auto data = std::get< 0 >( * tpl);
typename std::decay< Fn >::type fn = std::forward< Fn >( std::get< 1 >( * tpl) );
#if defined(BOOST_NO_CXX17_STD_APPLY)
dp->data = apply( fn, std::tie( data) );
dp->data = boost::context::detail::apply( fn, std::tie( data) );
#else
dp->data = std::apply( fn, std::tie( data) );
#endif
@@ -168,29 +162,29 @@ transfer_t context_ontop( transfer_t t) {
}
template< typename StackAlloc, typename Fn, typename ... Args >
class capture_record : public activation_record {
class ecv1_capture_record : public ecv1_activation_record {
private:
StackAlloc salloc_;
typename std::decay< StackAlloc >::type salloc_;
typename std::decay< Fn >::type fn_;
std::tuple< typename std::decay< Args >::type ... > args_;
activation_record * caller_;
ecv1_activation_record * caller_;
static void destroy( capture_record * p) noexcept {
StackAlloc salloc = p->salloc_;
static void destroy( ecv1_capture_record * p) noexcept {
typename std::decay< StackAlloc >::type salloc = std::move( p->salloc_);
stack_context sctx = p->sctx;
// deallocate activation record
p->~capture_record();
p->~ecv1_capture_record();
// destroy stack with stack allocator
salloc.deallocate( sctx);
}
public:
capture_record( stack_context sctx, StackAlloc const& salloc,
ecv1_capture_record( stack_context sctx, StackAlloc && salloc,
fcontext_t fctx,
activation_record * caller,
ecv1_activation_record * caller,
Fn && fn, Args && ... args) noexcept :
activation_record{ fctx, sctx },
salloc_{ salloc },
ecv1_activation_record{ fctx, sctx },
salloc_{ std::forward< StackAlloc >( salloc) },
fn_( std::forward< Fn >( fn) ),
args_( std::forward< Args >( args) ... ),
caller_{ caller } {
@@ -203,7 +197,7 @@ public:
void run() {
auto data = caller_->resume( nullptr);
#if defined(BOOST_NO_CXX17_STD_APPLY)
apply( fn_, std::tuple_cat( args_, std::tie( data) ) );
boost::context::detail::apply( fn_, std::tuple_cat( args_, std::tie( data) ) );
#else
std::apply( fn_, std::tuple_cat( args_, std::tie( data) ) );
#endif
@@ -213,6 +207,8 @@ public:
}
namespace v1 {
class BOOST_CONTEXT_DECL execution_context {
private:
// tampoline function
@@ -220,7 +216,7 @@ private:
// is resumed for the first time
template< typename AR >
static void entry_func( detail::transfer_t t) noexcept {
detail::data_t * dp = reinterpret_cast< detail::data_t * >( t.data);
detail::ecv1_data_t * dp = reinterpret_cast< detail::ecv1_data_t * >( t.data);
AR * ar = static_cast< AR * >( dp->data);
BOOST_ASSERT( nullptr != ar);
dp->from->fctx = t.fctx;
@@ -228,14 +224,14 @@ private:
ar->run();
}
typedef boost::intrusive_ptr< detail::activation_record > ptr_t;
typedef boost::intrusive_ptr< detail::ecv1_activation_record > ptr_t;
ptr_t ptr_;
template< typename StackAlloc, typename Fn, typename ... Args >
static detail::activation_record * create_context( StackAlloc salloc,
static detail::ecv1_activation_record * create_context( StackAlloc && salloc,
Fn && fn, Args && ... args) {
typedef detail::capture_record<
typedef detail::ecv1_capture_record<
StackAlloc, Fn, Args ...
> capture_t;
@@ -263,13 +259,13 @@ private:
auto curr = execution_context::current().ptr_;
// placment new for control structure on fast-context stack
return ::new ( sp) capture_t{
sctx, salloc, fctx, curr.get(), std::forward< Fn >( fn), std::forward< Args >( args) ... };
sctx, std::forward< StackAlloc >( salloc), fctx, curr.get(), std::forward< Fn >( fn), std::forward< Args >( args) ... };
}
template< typename StackAlloc, typename Fn, typename ... Args >
static detail::activation_record * create_context( preallocated palloc, StackAlloc salloc,
static detail::ecv1_activation_record * create_context( preallocated palloc, StackAlloc && salloc,
Fn && fn, Args && ... args) {
typedef detail::capture_record<
typedef detail::ecv1_capture_record<
StackAlloc, Fn, Args ...
> capture_t;
@@ -296,12 +292,12 @@ private:
auto curr = execution_context::current().ptr_;
// placment new for control structure on fast-context stack
return ::new ( sp) capture_t{
palloc.sctx, salloc, fctx, curr.get(), std::forward< Fn >( fn), std::forward< Args >( args) ... };
palloc.sctx, std::forward< StackAlloc >( salloc), fctx, curr.get(), std::forward< Fn >( fn), std::forward< Args >( args) ... };
}
execution_context() noexcept :
// default constructed with current activation_record
ptr_{ detail::activation_record::current_rec } {
// default constructed with current ecv1_activation_record
ptr_{ detail::ecv1_activation_record::current() } {
}
public:
@@ -374,13 +370,13 @@ public:
typename Fn,
typename ... Args
>
execution_context( std::allocator_arg_t, StackAlloc salloc, Fn && fn, Args && ... args) :
execution_context( std::allocator_arg_t, StackAlloc && salloc, Fn && fn, Args && ... args) :
// deferred execution of fn and its arguments
// arguments are stored in std::tuple<>
// non-type template parameter pack via std::index_sequence_for<>
// preserves the number of arguments
// used to extract the function arguments from std::tuple<>
ptr_{ create_context( salloc,
ptr_{ create_context( std::forward< StackAlloc >( salloc),
std::forward< Fn >( fn),
std::forward< Args >( args) ...) } {
ptr_->resume( ptr_.get() );
@@ -390,13 +386,13 @@ public:
typename Fn,
typename ... Args
>
execution_context( std::allocator_arg_t, preallocated palloc, StackAlloc salloc, Fn && fn, Args && ... args) :
execution_context( std::allocator_arg_t, preallocated palloc, StackAlloc && salloc, Fn && fn, Args && ... args) :
// deferred execution of fn and its arguments
// arguments are stored in std::tuple<>
// non-type template parameter pack via std::index_sequence_for<>
// preserves the number of arguments
// used to extract the function arguments from std::tuple<>
ptr_{ create_context( palloc, salloc,
ptr_{ create_context( palloc, std::forward< StackAlloc >( salloc),
std::forward< Fn >( fn),
std::forward< Args >( args) ...) } {
ptr_->resume( ptr_.get() );
@@ -444,30 +440,10 @@ public:
return nullptr == ptr_.get();
}
bool operator==( execution_context const& other) const noexcept {
return ptr_ == other.ptr_;
}
bool operator!=( execution_context const& other) const noexcept {
return ptr_ != other.ptr_;
}
bool operator<( execution_context const& other) const noexcept {
return ptr_ < other.ptr_;
}
bool operator>( execution_context const& other) const noexcept {
return other.ptr_ < ptr_;
}
bool operator<=( execution_context const& other) const noexcept {
return ! ( * this > other);
}
bool operator>=( execution_context const& other) const noexcept {
return ! ( * this < other);
}
template< typename charT, class traitsT >
friend std::basic_ostream< charT, traitsT > &
operator<<( std::basic_ostream< charT, traitsT > & os, execution_context const& other) {
@@ -488,10 +464,10 @@ void swap( execution_context & l, execution_context & r) noexcept {
l.swap( r);
}
}}
}}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_EXECUTION_CONTEXT_H
#endif // BOOST_CONTEXT_EXECUTION_CONTEXT_V1_H

151
linx64/include/boost/context/execution_context_v2.hpp
View File

@@ -4,8 +4,8 @@
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_EXECUTION_CONTEXT_H
#define BOOST_CONTEXT_EXECUTION_CONTEXT_H
#ifndef BOOST_CONTEXT_EXECUTION_CONTEXT_V2_H
#define BOOST_CONTEXT_EXECUTION_CONTEXT_V2_H
#include <boost/context/detail/config.hpp>
@@ -51,51 +51,51 @@ namespace boost {
namespace context {
namespace detail {
transfer_t context_unwind( transfer_t);
transfer_t ecv2_context_unwind( transfer_t);
template< typename Rec >
transfer_t context_exit( transfer_t) noexcept;
transfer_t ecv2_context_exit( transfer_t) noexcept;
template< typename Rec >
void context_entry( transfer_t) noexcept;
void ecv2_context_etry( transfer_t) noexcept;
template< typename Ctx, typename Fn, typename ... Args >
transfer_t context_ontop( transfer_t);
transfer_t ecv2_context_ontop( transfer_t);
template< typename Ctx, typename StackAlloc, typename Fn, typename ... Params >
fcontext_t context_create( StackAlloc, Fn &&, Params && ...);
fcontext_t ecv2_context_create( StackAlloc &&, Fn &&, Params && ...);
template< typename Ctx, typename StackAlloc, typename Fn, typename ... Params >
fcontext_t context_create( preallocated, StackAlloc, Fn &&, Params && ...);
fcontext_t ecv2_context_create( preallocated, StackAlloc &&, Fn &&, Params && ...);
template< typename Ctx, typename StackAlloc, typename Fn, typename ... Params >
class record {
class ecv2_record {
private:
StackAlloc salloc_;
typename std::decay< StackAlloc >::type salloc_;
stack_context sctx_;
typename std::decay< Fn >::type fn_;
std::tuple< typename std::decay< Params >::type ... > params_;
static void destroy( record * p) noexcept {
StackAlloc salloc = p->salloc_;
static void destroy( ecv2_record * p) noexcept {
typename std::decay< StackAlloc >::type salloc = std::move( p->salloc_);
stack_context sctx = p->sctx_;
// deallocate record
p->~record();
// deallocate ecv2_record
p->~ecv2_record();
// destroy stack with stack allocator
salloc.deallocate( sctx);
}
public:
record( stack_context sctx, StackAlloc const& salloc,
ecv2_record( stack_context sctx, StackAlloc && salloc,
Fn && fn, Params && ... params) noexcept :
salloc_( salloc),
salloc_( std::forward< StackAlloc >( salloc)),
sctx_( sctx),
fn_( std::forward< Fn >( fn) ),
params_( std::forward< Params >( params) ... ) {
}
record( record const&) = delete;
record & operator=( record const&) = delete;
ecv2_record( ecv2_record const&) = delete;
ecv2_record & operator=( ecv2_record const&) = delete;
void deallocate() noexcept {
destroy( this);
@@ -110,7 +110,7 @@ public:
std::move( args) );
// invoke context-function
#if defined(BOOST_NO_CXX17_STD_APPLY)
Ctx cc = apply( std::move( fn_), std::move( tpl) );
Ctx cc = boost::context::detail::apply( std::move( fn_), std::move( tpl) );
#else
Ctx cc = std::apply( std::move( fn_), std::move( tpl) );
#endif
@@ -120,6 +120,8 @@ public:
}
inline namespace v2 {
template< typename ... Args >
class execution_context {
private:
@@ -129,10 +131,10 @@ private:
typedef std::tuple< execution_context, typename std::decay< Args >::type ... > ret_tpl_t;
template< typename Ctx, typename StackAlloc, typename Fn, typename ... Params >
friend class detail::record;
friend class detail::ecv2_record;
template< typename Ctx, typename Fn, typename ... ArgsT >
friend detail::transfer_t detail::context_ontop( detail::transfer_t);
friend detail::transfer_t detail::ecv2_context_ontop( detail::transfer_t);
detail::fcontext_t fctx_{ nullptr };
@@ -162,7 +164,7 @@ public:
// non-type template parameter pack via std::index_sequence_for<>
// preserves the number of arguments
// used to extract the function arguments from std::tuple<>
fctx_( detail::context_create< execution_context >(
fctx_( detail::ecv2_context_create< execution_context >(
fixedsize_stack(),
std::forward< Fn >( fn),
std::forward< Params >( params) ... ) ) {
@@ -172,14 +174,14 @@ public:
typename Fn,
typename ... Params
>
execution_context( std::allocator_arg_t, StackAlloc salloc, Fn && fn, Params && ... params) :
execution_context( std::allocator_arg_t, StackAlloc && salloc, Fn && fn, Params && ... params) :
// deferred execution of fn and its arguments
// arguments are stored in std::tuple<>
// non-type template parameter pack via std::index_sequence_for<>
// preserves the number of arguments
// used to extract the function arguments from std::tuple<>
fctx_( detail::context_create< execution_context >(
salloc,
fctx_( detail::ecv2_context_create< execution_context >(
std::forward< StackAlloc >( salloc),
std::forward< Fn >( fn),
std::forward< Params >( params) ... ) ) {
}
@@ -188,14 +190,14 @@ public:
typename Fn,
typename ... Params
>
execution_context( std::allocator_arg_t, preallocated palloc, StackAlloc salloc, Fn && fn, Params && ... params) :
execution_context( std::allocator_arg_t, preallocated palloc, StackAlloc && salloc, Fn && fn, Params && ... params) :
// deferred execution of fn and its arguments
// arguments are stored in std::tuple<>
// non-type template parameter pack via std::index_sequence_for<>
// preserves the number of arguments
// used to extract the function arguments from std::tuple<>
fctx_( detail::context_create< execution_context >(
palloc, salloc,
fctx_( detail::ecv2_context_create< execution_context >(
palloc, std::forward< StackAlloc >( salloc),
std::forward< Fn >( fn),
std::forward< Params >( params) ... ) ) {
}
@@ -203,7 +205,7 @@ public:
~execution_context() {
if ( nullptr != fctx_) {
detail::ontop_fcontext( detail::exchange( fctx_, nullptr), nullptr, detail::context_unwind);
detail::ontop_fcontext( detail::exchange( fctx_, nullptr), nullptr, detail::ecv2_context_unwind);
}
}
@@ -236,30 +238,10 @@ public:
return nullptr == fctx_;
}
bool operator==( execution_context const& other) const noexcept {
return fctx_ == other.fctx_;
}
bool operator!=( execution_context const& other) const noexcept {
return fctx_ != other.fctx_;
}
bool operator<( execution_context const& other) const noexcept {
return fctx_ < other.fctx_;
}
bool operator>( execution_context const& other) const noexcept {
return other.fctx_ < fctx_;
}
bool operator<=( execution_context const& other) const noexcept {
return ! ( * this > other);
}
bool operator>=( execution_context const& other) const noexcept {
return ! ( * this < other);
}
template< typename charT, class traitsT >
friend std::basic_ostream< charT, traitsT > &
operator<<( std::basic_ostream< charT, traitsT > & os, execution_context const& other) {
@@ -322,7 +304,7 @@ execution_context< Args ... >::operator()( exec_ontop_arg_t, Fn && fn, Args ...
detail::transfer_t t = detail::ontop_fcontext(
detail::exchange( fctx_, nullptr),
& p,
detail::context_ontop< execution_context, Fn, Args ... >);
detail::ecv2_context_ontop< execution_context, Fn, Args ... >);
if ( nullptr != t.data) {
auto p = static_cast< std::tuple< std::exception_ptr, args_tpl_t > * >( t.data);
std::exception_ptr eptr = std::get< 0 >( * p);
@@ -338,6 +320,8 @@ execution_context< Args ... >::operator()( exec_ontop_arg_t, Fn && fn, Args ...
return std::tuple_cat( std::forward_as_tuple( execution_context( t.fctx) ), std::move( data) );
}
}
namespace detail {
template< int N >
@@ -357,13 +341,13 @@ struct helper< 1 > {
};
inline
transfer_t context_unwind( transfer_t t) {
transfer_t ecv2_context_unwind( transfer_t t) {
throw forced_unwind( t.fctx);
return { nullptr, nullptr };
}
template< typename Rec >
transfer_t context_exit( transfer_t t) noexcept {
transfer_t ecv2_context_exit( transfer_t t) noexcept {
Rec * rec = static_cast< Rec * >( t.data);
// destroy context stack
rec->deallocate();
@@ -371,27 +355,30 @@ transfer_t context_exit( transfer_t t) noexcept {
}
template< typename Rec >
void context_entry( transfer_t t_) noexcept {
void ecv2_context_etry( transfer_t t_) noexcept {
// transfer control structure to the context-stack
Rec * rec = static_cast< Rec * >( t_.data);
BOOST_ASSERT( nullptr != rec);
transfer_t t = { nullptr, nullptr };
try {
// jump back to `context_create()`
// jump back to `ecv2_context_create()`
t = jump_fcontext( t_.fctx, nullptr);
// start executing
t = rec->run( t);
} catch ( forced_unwind const& e) {
t = { e.fctx, nullptr };
} catch ( forced_unwind const& ex) {
t = { ex.fctx, nullptr };
#ifndef BOOST_ASSERT_IS_VOID
const_cast< forced_unwind & >( ex).caught = true;
#endif
}
BOOST_ASSERT( nullptr != t.fctx);
// destroy context-stack of `this`context on next context
ontop_fcontext( t.fctx, rec, context_exit< Rec >);
ontop_fcontext( t.fctx, rec, ecv2_context_exit< Rec >);
BOOST_ASSERT_MSG( false, "context already terminated");
}
template< typename Ctx, typename Fn, typename ... Args >
transfer_t context_ontop( transfer_t t) {
transfer_t ecv2_context_ontop( transfer_t t) {
auto p = static_cast< std::tuple< Fn, std::tuple< std::exception_ptr, std::tuple< Args ... > > > * >( t.data);
BOOST_ASSERT( nullptr != p);
typename std::decay< Fn >::type fn = std::forward< Fn >( std::get< 0 >( * p) );
@@ -399,9 +386,13 @@ transfer_t context_ontop( transfer_t t) {
try {
// execute function
#if defined(BOOST_NO_CXX17_STD_APPLY)
std::get< 1 >( std::get< 1 >( * p) ) = helper< sizeof ... (Args) >::convert( apply( fn, std::move( args) ) );
std::get< 1 >( std::get< 1 >( * p) ) = helper< sizeof ... (Args) >::convert( boost::context::detail::apply( fn, std::move( args) ) );
#else
std::get< 1 >( std::get< 1 >( * p) ) = helper< sizeof ... (Args) >::convert( std::apply( fn, std::move( args) ) );
#endif
#if defined( BOOST_CONTEXT_HAS_CXXABI_H )
} catch ( abi::__forced_unwind const&) {
throw;
#endif
} catch (...) {
std::get< 0 >( std::get< 1 >( * p) ) = std::current_exception();
@@ -411,17 +402,17 @@ transfer_t context_ontop( transfer_t t) {
}
template< typename Ctx, typename StackAlloc, typename Fn, typename ... Params >
fcontext_t context_create( StackAlloc salloc, Fn && fn, Params && ... params) {
typedef record< Ctx, StackAlloc, Fn, Params ... > record_t;
fcontext_t ecv2_context_create( StackAlloc && salloc, Fn && fn, Params && ... params) {
typedef ecv2_record< Ctx, StackAlloc, Fn, Params ... > ecv2_record_t;
auto sctx = salloc.allocate();
// reserve space for control structure
#if defined(BOOST_NO_CXX11_CONSTEXPR) || defined(BOOST_NO_CXX11_STD_ALIGN)
const std::size_t size = sctx.size - sizeof( record_t);
void * sp = static_cast< char * >( sctx.sp) - sizeof( record_t);
const std::size_t size = sctx.size - sizeof( ecv2_record_t);
void * sp = static_cast< char * >( sctx.sp) - sizeof( ecv2_record_t);
#else
constexpr std::size_t func_alignment = 64; // alignof( record_t);
constexpr std::size_t func_size = sizeof( record_t);
constexpr std::size_t func_alignment = 64; // alignof( ecv2_record_t);
constexpr std::size_t func_size = sizeof( ecv2_record_t);
// reserve space on stack
void * sp = static_cast< char * >( sctx.sp) - func_size - func_alignment;
// align sp pointer
@@ -432,26 +423,26 @@ fcontext_t context_create( StackAlloc salloc, Fn && fn, Params && ... params) {
const std::size_t size = sctx.size - ( static_cast< char * >( sctx.sp) - static_cast< char * >( sp) );
#endif
// create fast-context
const fcontext_t fctx = make_fcontext( sp, size, & context_entry< record_t >);
const fcontext_t fctx = make_fcontext( sp, size, & ecv2_context_etry< ecv2_record_t >);
BOOST_ASSERT( nullptr != fctx);
// placment new for control structure on context-stack
auto rec = ::new ( sp) record_t{
sctx, salloc, std::forward< Fn >( fn), std::forward< Params >( params) ... };
auto rec = ::new ( sp) ecv2_record_t{
sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn), std::forward< Params >( params) ... };
// transfer control structure to context-stack
return jump_fcontext( fctx, rec).fctx;
}
template< typename Ctx, typename StackAlloc, typename Fn, typename ... Params >
fcontext_t context_create( preallocated palloc, StackAlloc salloc, Fn && fn, Params && ... params) {
typedef record< Ctx, StackAlloc, Fn, Params ... > record_t;
fcontext_t ecv2_context_create( preallocated palloc, StackAlloc && salloc, Fn && fn, Params && ... params) {
typedef ecv2_record< Ctx, StackAlloc, Fn, Params ... > ecv2_record_t;
// reserve space for control structure
#if defined(BOOST_NO_CXX11_CONSTEXPR) || defined(BOOST_NO_CXX11_STD_ALIGN)
const std::size_t size = palloc.size - sizeof( record_t);
void * sp = static_cast< char * >( palloc.sp) - sizeof( record_t);
const std::size_t size = palloc.size - sizeof( ecv2_record_t);
void * sp = static_cast< char * >( palloc.sp) - sizeof( ecv2_record_t);
#else
constexpr std::size_t func_alignment = 64; // alignof( record_t);
constexpr std::size_t func_size = sizeof( record_t);
constexpr std::size_t func_alignment = 64; // alignof( ecv2_record_t);
constexpr std::size_t func_size = sizeof( ecv2_record_t);
// reserve space on stack
void * sp = static_cast< char * >( palloc.sp) - func_size - func_alignment;
// align sp pointer
@@ -462,11 +453,11 @@ fcontext_t context_create( preallocated palloc, StackAlloc salloc, Fn && fn, Par
const std::size_t size = palloc.size - ( static_cast< char * >( palloc.sp) - static_cast< char * >( sp) );
#endif
// create fast-context
const fcontext_t fctx = make_fcontext( sp, size, & context_entry< record_t >);
const fcontext_t fctx = make_fcontext( sp, size, & ecv2_context_etry< ecv2_record_t >);
BOOST_ASSERT( nullptr != fctx);
// placment new for control structure on context-stack
auto rec = ::new ( sp) record_t{
palloc.sctx, salloc, std::forward< Fn >( fn), std::forward< Params >( params) ... };
auto rec = ::new ( sp) ecv2_record_t{
palloc.sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn), std::forward< Params >( params) ... };
// transfer control structure to context-stack
return jump_fcontext( fctx, rec).fctx;
}
@@ -475,12 +466,14 @@ fcontext_t context_create( preallocated palloc, StackAlloc salloc, Fn && fn, Par
#include <boost/context/execution_context_v2_void.ipp>
inline namespace v2 {
template< typename ... Args >
void swap( execution_context< Args ... > & l, execution_context< Args ... > & r) noexcept {
l.swap( r);
}
}}
}}}
#if defined(BOOST_MSVC)
# pragma warning(pop)
@@ -490,4 +483,4 @@ void swap( execution_context< Args ... > & l, execution_context< Args ... > & r)
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_EXECUTION_CONTEXT_H
#endif // BOOST_CONTEXT_EXECUTION_CONTEXT_V2_H

94
linx64/include/boost/context/execution_context_v2_void.ipp
View File

@@ -7,42 +7,42 @@
namespace detail {
template< typename Ctx, typename Fn >
transfer_t context_ontop_void( transfer_t);
transfer_t ecv2_context_ontop_void( transfer_t);
template< typename Ctx, typename StackAlloc, typename Fn, typename ... Params >
fcontext_t context_create_void( StackAlloc, Fn &&, Params && ...);
fcontext_t ecv2_context_create_void( StackAlloc &&, Fn &&, Params && ...);
template< typename Ctx, typename StackAlloc, typename Fn, typename ... Params >
fcontext_t context_create_void( preallocated, StackAlloc, Fn &&, Params && ...);
fcontext_t ecv2_context_create_void( preallocated, StackAlloc &&, Fn &&, Params && ...);
template< typename Ctx, typename StackAlloc, typename Fn, typename ... Params >
class record_void {
class ecv2_record_void {
private:
StackAlloc salloc_;
typename std::decay< StackAlloc >::type salloc_;
stack_context sctx_;
typename std::decay< Fn >::type fn_;
std::tuple< typename std::decay< Params >::type ... > params_;
static void destroy( record_void * p) noexcept {
StackAlloc salloc = p->salloc_;
static void destroy( ecv2_record_void * p) noexcept {
typename std::decay< StackAlloc >::type salloc = std::move( p->salloc_);
stack_context sctx = p->sctx_;
// deallocate record
p->~record_void();
p->~ecv2_record_void();
// destroy stack with stack allocator
salloc.deallocate( sctx);
}
public:
record_void( stack_context sctx, StackAlloc const& salloc,
ecv2_record_void( stack_context sctx, StackAlloc && salloc,
Fn && fn, Params && ... params) noexcept :
salloc_( salloc),
salloc_( std::forward< StackAlloc >( salloc) ),
sctx_( sctx),
fn_( std::forward< Fn >( fn) ),
params_( std::forward< Params >( params) ... ) {
}
record_void( record_void const&) = delete;
record_void & operator=( record_void const&) = delete;
ecv2_record_void( ecv2_record_void const&) = delete;
ecv2_record_void & operator=( ecv2_record_void const&) = delete;
void deallocate() noexcept {
destroy( this);
@@ -52,7 +52,7 @@ public:
Ctx from{ t.fctx };
// invoke context-function
#if defined(BOOST_NO_CXX17_STD_APPLY)
Ctx cc = apply( fn_, std::tuple_cat( params_, std::forward_as_tuple( std::move( from) ) ) );
Ctx cc = boost::context::detail::apply( fn_, std::tuple_cat( params_, std::forward_as_tuple( std::move( from) ) ) );
#else
Ctx cc = std::apply( fn_, std::tuple_cat( params_, std::forward_as_tuple( std::move( from) ) ) );
#endif
@@ -62,16 +62,18 @@ public:
}
inline namespace v2 {
template<>
class execution_context< void > {
private:
friend class ontop_error;
template< typename Ctx, typename StackAlloc, typename Fn, typename ... Params >
friend class detail::record_void;
friend class detail::ecv2_record_void;
template< typename Ctx, typename Fn >
friend detail::transfer_t detail::context_ontop_void( detail::transfer_t);
friend detail::transfer_t detail::ecv2_context_ontop_void( detail::transfer_t);
detail::fcontext_t fctx_{ nullptr };
@@ -101,7 +103,7 @@ public:
// non-type template parameter pack via std::index_sequence_for<>
// preserves the number of arguments
// used to extract the function arguments from std::tuple<>
fctx_( detail::context_create_void< execution_context >(
fctx_( detail::ecv2_context_create_void< execution_context >(
fixedsize_stack(),
std::forward< Fn >( fn),
std::forward< Params >( params) ... ) ) {
@@ -111,14 +113,14 @@ public:
typename Fn,
typename ... Params
>
execution_context( std::allocator_arg_t, StackAlloc salloc, Fn && fn, Params && ... params) :
execution_context( std::allocator_arg_t, StackAlloc && salloc, Fn && fn, Params && ... params) :
// deferred execution of fn and its arguments
// arguments are stored in std::tuple<>
// non-type template parameter pack via std::index_sequence_for<>
// preserves the number of arguments
// used to extract the function arguments from std::tuple<>
fctx_( detail::context_create_void< execution_context >(
salloc,
fctx_( detail::ecv2_context_create_void< execution_context >(
std::forward< StackAlloc >( salloc),
std::forward< Fn >( fn),
std::forward< Params >( params) ... ) ) {
}
@@ -127,14 +129,14 @@ public:
typename Fn,
typename ... Params
>
execution_context( std::allocator_arg_t, preallocated palloc, StackAlloc salloc, Fn && fn, Params && ... params) :
execution_context( std::allocator_arg_t, preallocated palloc, StackAlloc && salloc, Fn && fn, Params && ... params) :
// deferred execution of fn and its arguments
// arguments are stored in std::tuple<>
// non-type template parameter pack via std::index_sequence_for<>
// preserves the number of arguments
// used to extract the function arguments from std::tuple<>
fctx_( detail::context_create_void< execution_context >(
palloc, salloc,
fctx_( detail::ecv2_context_create_void< execution_context >(
palloc, std::forward< StackAlloc >( salloc),
std::forward< Fn >( fn),
std::forward< Params >( params) ... ) ) {
}
@@ -142,7 +144,7 @@ public:
~execution_context() {
if ( nullptr != fctx_) {
detail::ontop_fcontext( detail::exchange( fctx_, nullptr), nullptr, detail::context_unwind);
detail::ontop_fcontext( detail::exchange( fctx_, nullptr), nullptr, detail::ecv2_context_unwind);
}
}
@@ -183,7 +185,7 @@ public:
detail::transfer_t t = detail::ontop_fcontext(
detail::exchange( fctx_, nullptr),
& p,
detail::context_ontop_void< execution_context, Fn >);
detail::ecv2_context_ontop_void< execution_context, Fn >);
if ( nullptr != t.data) {
std::exception_ptr * eptr = static_cast< std::exception_ptr * >( t.data);
try {
@@ -203,30 +205,10 @@ public:
return nullptr == fctx_;
}
bool operator==( execution_context const& other) const noexcept {
return fctx_ == other.fctx_;
}
bool operator!=( execution_context const& other) const noexcept {
return fctx_ != other.fctx_;
}
bool operator<( execution_context const& other) const noexcept {
return fctx_ < other.fctx_;
}
bool operator>( execution_context const& other) const noexcept {
return other.fctx_ < fctx_;
}
bool operator<=( execution_context const& other) const noexcept {
return ! ( * this > other);
}
bool operator>=( execution_context const& other) const noexcept {
return ! ( * this < other);
}
template< typename charT, class traitsT >
friend std::basic_ostream< charT, traitsT > &
operator<<( std::basic_ostream< charT, traitsT > & os, execution_context const& other) {
@@ -242,16 +224,22 @@ public:
}
};
}
namespace detail {
template< typename Ctx, typename Fn >
transfer_t context_ontop_void( transfer_t t) {
transfer_t ecv2_context_ontop_void( transfer_t t) {
auto p = static_cast< std::tuple< Fn, std::exception_ptr > * >( t.data);
BOOST_ASSERT( nullptr != p);
typename std::decay< Fn >::type fn = std::forward< Fn >( std::get< 0 >( * p) );
try {
// execute function
fn();
#if defined( BOOST_CONTEXT_HAS_CXXABI_H )
} catch ( abi::__forced_unwind const&) {
throw;
#endif
} catch (...) {
std::get< 1 >( * p) = std::current_exception();
return { t.fctx, & std::get< 1 >( * p ) };
@@ -260,8 +248,8 @@ transfer_t context_ontop_void( transfer_t t) {
}
template< typename Ctx, typename StackAlloc, typename Fn, typename ... Params >
fcontext_t context_create_void( StackAlloc salloc, Fn && fn, Params && ... params) {
typedef record_void< Ctx, StackAlloc, Fn, Params ... > record_t;
fcontext_t ecv2_context_create_void( StackAlloc && salloc, Fn && fn, Params && ... params) {
typedef ecv2_record_void< Ctx, StackAlloc, Fn, Params ... > record_t;
auto sctx = salloc.allocate();
// reserve space for control structure
@@ -281,18 +269,18 @@ fcontext_t context_create_void( StackAlloc salloc, Fn && fn, Params && ... param
const std::size_t size = sctx.size - ( static_cast< char * >( sctx.sp) - static_cast< char * >( sp) );
#endif
// create fast-context
const fcontext_t fctx = make_fcontext( sp, size, & context_entry< record_t >);
const fcontext_t fctx = make_fcontext( sp, size, & ecv2_context_etry< record_t >);
BOOST_ASSERT( nullptr != fctx);
// placment new for control structure on context-stack
auto rec = ::new ( sp) record_t{
sctx, salloc, std::forward< Fn >( fn), std::forward< Params >( params) ... };
sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn), std::forward< Params >( params) ... };
// transfer control structure to context-stack
return jump_fcontext( fctx, rec).fctx;
}
template< typename Ctx, typename StackAlloc, typename Fn, typename ... Params >
fcontext_t context_create_void( preallocated palloc, StackAlloc salloc, Fn && fn, Params && ... params) {
typedef record_void< Ctx, StackAlloc, Fn, Params ... > record_t;
fcontext_t ecv2_context_create_void( preallocated palloc, StackAlloc && salloc, Fn && fn, Params && ... params) {
typedef ecv2_record_void< Ctx, StackAlloc, Fn, Params ... > record_t;
// reserve space for control structure
#if defined(BOOST_NO_CXX11_CONSTEXPR) || defined(BOOST_NO_CXX11_STD_ALIGN)
@@ -311,11 +299,11 @@ fcontext_t context_create_void( preallocated palloc, StackAlloc salloc, Fn && fn
const std::size_t size = palloc.size - ( static_cast< char * >( palloc.sp) - static_cast< char * >( sp) );
#endif
// create fast-context
const fcontext_t fctx = make_fcontext( sp, size, & context_entry< record_t >);
const fcontext_t fctx = make_fcontext( sp, size, & ecv2_context_etry< record_t >);
BOOST_ASSERT( nullptr != fctx);
// placment new for control structure on context-stack
auto rec = ::new ( sp) record_t{
palloc.sctx, salloc, std::forward< Fn >( fn), std::forward< Params >( params) ... };
palloc.sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn), std::forward< Params >( params) ... };
// transfer control structure to context-stack
return jump_fcontext( fctx, rec).fctx;
}

13
linx64/include/boost/context/fiber.hpp Normal file
View File

@@ -0,0 +1,13 @@
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#if defined(BOOST_USE_UCONTEXT)
#include <boost/context/fiber_ucontext.hpp>
#elif defined(BOOST_USE_WINFIB)
#include <boost/context/fiber_winfib.hpp>
#else
#include <boost/context/fiber_fcontext.hpp>
#endif

349
linx64/include/boost/context/fiber_fcontext.hpp Normal file
View File

@@ -0,0 +1,349 @@
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_FIBER_H
#define BOOST_CONTEXT_FIBER_H
#include <boost/context/detail/config.hpp>
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <exception>
#include <functional>
#include <memory>
#include <ostream>
#include <tuple>
#include <utility>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/intrusive_ptr.hpp>
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
#include <boost/context/detail/exchange.hpp>
#endif
#if defined(BOOST_NO_CXX17_STD_INVOKE)
#include <boost/context/detail/invoke.hpp>
#endif
#include <boost/context/detail/disable_overload.hpp>
#include <boost/context/detail/exception.hpp>
#include <boost/context/detail/fcontext.hpp>
#include <boost/context/detail/tuple.hpp>
#include <boost/context/fixedsize_stack.hpp>
#include <boost/context/flags.hpp>
#include <boost/context/preallocated.hpp>
#include <boost/context/segmented_stack.hpp>
#include <boost/context/stack_context.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4702)
#endif
namespace boost {
namespace context {
namespace detail {
inline
transfer_t fiber_unwind( transfer_t t) {
throw forced_unwind( t.fctx);
return { nullptr, nullptr };
}
template< typename Rec >
transfer_t fiber_exit( transfer_t t) noexcept {
Rec * rec = static_cast< Rec * >( t.data);
// destroy context stack
rec->deallocate();
return { nullptr, nullptr };
}
template< typename Rec >
void fiber_entry( transfer_t t) noexcept {
// transfer control structure to the context-stack
Rec * rec = static_cast< Rec * >( t.data);
BOOST_ASSERT( nullptr != t.fctx);
BOOST_ASSERT( nullptr != rec);
try {
// jump back to `create_context()`
t = jump_fcontext( t.fctx, nullptr);
// start executing
t.fctx = rec->run( t.fctx);
} catch ( forced_unwind const& ex) {
t = { ex.fctx, nullptr };
#ifndef BOOST_ASSERT_IS_VOID
const_cast< forced_unwind & >( ex).caught = true;
#endif
}
BOOST_ASSERT( nullptr != t.fctx);
// destroy context-stack of `this`context on next context
ontop_fcontext( t.fctx, rec, fiber_exit< Rec >);
BOOST_ASSERT_MSG( false, "context already terminated");
}
template< typename Ctx, typename Fn >
transfer_t fiber_ontop( transfer_t t) {
BOOST_ASSERT( nullptr != t.data);
auto p = *static_cast< Fn * >( t.data);
t.data = nullptr;
// execute function, pass fiber via reference
Ctx c = p( Ctx{ t.fctx } );
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return { exchange( c.fctx_, nullptr), nullptr };
#else
return { std::exchange( c.fctx_, nullptr), nullptr };
#endif
}
template< typename Ctx, typename StackAlloc, typename Fn >
class fiber_record {
private:
stack_context sctx_;
typename std::decay< StackAlloc >::type salloc_;
typename std::decay< Fn >::type fn_;
static void destroy( fiber_record * p) noexcept {
typename std::decay< StackAlloc >::type salloc = std::move( p->salloc_);
stack_context sctx = p->sctx_;
// deallocate fiber_record
p->~fiber_record();
// destroy stack with stack allocator
salloc.deallocate( sctx);
}
public:
fiber_record( stack_context sctx, StackAlloc && salloc,
Fn && fn) noexcept :
sctx_( sctx),
salloc_( std::forward< StackAlloc >( salloc)),
fn_( std::forward< Fn >( fn) ) {
}
fiber_record( fiber_record const&) = delete;
fiber_record & operator=( fiber_record const&) = delete;
void deallocate() noexcept {
destroy( this);
}
fcontext_t run( fcontext_t fctx) {
// invoke context-function
#if defined(BOOST_NO_CXX17_STD_INVOKE)
Ctx c = boost::context::detail::invoke( fn_, Ctx{ fctx } );
#else
Ctx c = std::invoke( fn_, Ctx{ fctx } );
#endif
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( c.fctx_, nullptr);
#else
return std::exchange( c.fctx_, nullptr);
#endif
}
};
template< typename Record, typename StackAlloc, typename Fn >
fcontext_t create_fiber1( StackAlloc && salloc, Fn && fn) {
auto sctx = salloc.allocate();
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sizeof( Record) ) )
& ~static_cast< uintptr_t >( 0xff) );
// placment new for control structure on context stack
Record * record = new ( storage) Record{
sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
// 64byte gab between control structure and stack top
// should be 16byte aligned
void * stack_top = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( storage) - static_cast< uintptr_t >( 64) );
void * stack_bottom = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sctx.size) );
// create fast-context
const std::size_t size = reinterpret_cast< uintptr_t >( stack_top) - reinterpret_cast< uintptr_t >( stack_bottom);
const fcontext_t fctx = make_fcontext( stack_top, size, & fiber_entry< Record >);
BOOST_ASSERT( nullptr != fctx);
// transfer control structure to context-stack
return jump_fcontext( fctx, record).fctx;
}
template< typename Record, typename StackAlloc, typename Fn >
fcontext_t create_fiber2( preallocated palloc, StackAlloc && salloc, Fn && fn) {
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( palloc.sp) - static_cast< uintptr_t >( sizeof( Record) ) )
& ~ static_cast< uintptr_t >( 0xff) );
// placment new for control structure on context-stack
Record * record = new ( storage) Record{
palloc.sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
// 64byte gab between control structure and stack top
void * stack_top = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( storage) - static_cast< uintptr_t >( 64) );
void * stack_bottom = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( palloc.sctx.sp) - static_cast< uintptr_t >( palloc.sctx.size) );
// create fast-context
const std::size_t size = reinterpret_cast< uintptr_t >( stack_top) - reinterpret_cast< uintptr_t >( stack_bottom);
const fcontext_t fctx = make_fcontext( stack_top, size, & fiber_entry< Record >);
BOOST_ASSERT( nullptr != fctx);
// transfer control structure to context-stack
return jump_fcontext( fctx, record).fctx;
}
}
class fiber {
private:
template< typename Ctx, typename StackAlloc, typename Fn >
friend class detail::fiber_record;
template< typename Ctx, typename Fn >
friend detail::transfer_t
detail::fiber_ontop( detail::transfer_t);
template< typename StackAlloc, typename Fn >
friend fiber
callcc( std::allocator_arg_t, StackAlloc &&, Fn &&);
template< typename StackAlloc, typename Fn >
friend fiber
callcc( std::allocator_arg_t, preallocated, StackAlloc &&, Fn &&);
detail::fcontext_t fctx_{ nullptr };
fiber( detail::fcontext_t fctx) noexcept :
fctx_{ fctx } {
}
public:
fiber() noexcept = default;
template< typename Fn, typename = detail::disable_overload< fiber, Fn > >
fiber( Fn && fn) :
fiber{ std::allocator_arg, fixedsize_stack(), std::forward< Fn >( fn) } {
}
template< typename StackAlloc, typename Fn >
fiber( std::allocator_arg_t, StackAlloc && salloc, Fn && fn) :
fctx_{ detail::create_fiber1< detail::fiber_record< fiber, StackAlloc, Fn > >(
std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) } {
}
template< typename StackAlloc, typename Fn >
fiber( std::allocator_arg_t, preallocated palloc, StackAlloc && salloc, Fn && fn) :
fctx_{ detail::create_fiber2< detail::fiber_record< fiber, StackAlloc, Fn > >(
palloc, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) } {
}
#if defined(BOOST_USE_SEGMENTED_STACKS)
template< typename Fn >
fiber( std::allocator_arg_t, segmented_stack, Fn &&);
template< typename StackAlloc, typename Fn >
fiber( std::allocator_arg_t, preallocated, segmented_stack, Fn &&);
#endif
~fiber() {
if ( BOOST_UNLIKELY( nullptr != fctx_) ) {
detail::ontop_fcontext(
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::exchange( fctx_, nullptr),
#else
std::exchange( fctx_, nullptr),
#endif
nullptr,
detail::fiber_unwind);
}
}
fiber( fiber && other) noexcept {
swap( other);
}
fiber & operator=( fiber && other) noexcept {
if ( BOOST_LIKELY( this != & other) ) {
fiber tmp = std::move( other);
swap( tmp);
}
return * this;
}
fiber( fiber const& other) noexcept = delete;
fiber & operator=( fiber const& other) noexcept = delete;
fiber resume() && {
BOOST_ASSERT( nullptr != fctx_);
return { detail::jump_fcontext(
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::exchange( fctx_, nullptr),
#else
std::exchange( fctx_, nullptr),
#endif
nullptr).fctx };
}
template< typename Fn >
fiber resume_with( Fn && fn) && {
BOOST_ASSERT( nullptr != fctx_);
auto p = std::forward< Fn >( fn);
return { detail::ontop_fcontext(
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::exchange( fctx_, nullptr),
#else
std::exchange( fctx_, nullptr),
#endif
& p,
detail::fiber_ontop< fiber, decltype(p) >).fctx };
}
explicit operator bool() const noexcept {
return nullptr != fctx_;
}
bool operator!() const noexcept {
return nullptr == fctx_;
}
bool operator<( fiber const& other) const noexcept {
return fctx_ < other.fctx_;
}
template< typename charT, class traitsT >
friend std::basic_ostream< charT, traitsT > &
operator<<( std::basic_ostream< charT, traitsT > & os, fiber const& other) {
if ( nullptr != other.fctx_) {
return os << other.fctx_;
} else {
return os << "{not-a-context}";
}
}
void swap( fiber & other) noexcept {
std::swap( fctx_, other.fctx_);
}
};
inline
void swap( fiber & l, fiber & r) noexcept {
l.swap( r);
}
typedef fiber fiber_context;
}}
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_FIBER_H

513
linx64/include/boost/context/fiber_ucontext.hpp Normal file
View File

@@ -0,0 +1,513 @@
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_FIBER_H
#define BOOST_CONTEXT_FIBER_H
#include <boost/predef.h>
#if BOOST_OS_MACOS
#define _XOPEN_SOURCE 600
#endif
extern "C" {
#include <ucontext.h>
}
#include <boost/context/detail/config.hpp>
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <memory>
#include <ostream>
#include <system_error>
#include <tuple>
#include <utility>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/context/detail/disable_overload.hpp>
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
#include <boost/context/detail/exchange.hpp>
#endif
#include <boost/context/detail/externc.hpp>
#if defined(BOOST_NO_CXX17_STD_INVOKE)
#include <boost/context/detail/invoke.hpp>
#endif
#include <boost/context/fixedsize_stack.hpp>
#include <boost/context/flags.hpp>
#include <boost/context/preallocated.hpp>
#if defined(BOOST_USE_SEGMENTED_STACKS)
#include <boost/context/segmented_stack.hpp>
#endif
#include <boost/context/stack_context.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
namespace detail {
// tampoline function
// entered if the execution context
// is resumed for the first time
template< typename Record >
static void fiber_entry_func( void * data) noexcept {
Record * record = static_cast< Record * >( data);
BOOST_ASSERT( nullptr != record);
// start execution of toplevel context-function
record->run();
}
struct BOOST_CONTEXT_DECL fiber_activation_record {
ucontext_t uctx{};
stack_context sctx{};
bool main_ctx{ true };
fiber_activation_record * from{ nullptr };
std::function< fiber_activation_record*(fiber_activation_record*&) > ontop{};
bool terminated{ false };
bool force_unwind{ false };
#if defined(BOOST_USE_ASAN)
void * fake_stack{ nullptr };
void * stack_bottom{ nullptr };
std::size_t stack_size{ 0 };
#endif
static fiber_activation_record *& current() noexcept;
// used for toplevel-context
// (e.g. main context, thread-entry context)
fiber_activation_record() {
if ( BOOST_UNLIKELY( 0 != ::getcontext( & uctx) ) ) {
throw std::system_error(
std::error_code( errno, std::system_category() ),
"getcontext() failed");
}
}
fiber_activation_record( stack_context sctx_) noexcept :
sctx( sctx_ ),
main_ctx( false ) {
}
virtual ~fiber_activation_record() {
}
fiber_activation_record( fiber_activation_record const&) = delete;
fiber_activation_record & operator=( fiber_activation_record const&) = delete;
bool is_main_context() const noexcept {
return main_ctx;
}
fiber_activation_record * resume() {
from = current();
// store `this` in static, thread local pointer
// `this` will become the active (running) context
current() = this;
#if defined(BOOST_USE_SEGMENTED_STACKS)
// adjust segmented stack properties
__splitstack_getcontext( from->sctx.segments_ctx);
__splitstack_setcontext( sctx.segments_ctx);
#endif
#if defined(BOOST_USE_ASAN)
if ( terminated) {
__sanitizer_start_switch_fiber( nullptr, stack_bottom, stack_size);
} else {
__sanitizer_start_switch_fiber( & from->fake_stack, stack_bottom, stack_size);
}
#endif
// context switch from parent context to `this`-context
::swapcontext( & from->uctx, & uctx);
#if defined(BOOST_USE_ASAN)
__sanitizer_finish_switch_fiber( current()->fake_stack,
(const void **) & current()->from->stack_bottom,
& current()->from->stack_size);
#endif
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( current()->from, nullptr);
#else
return std::exchange( current()->from, nullptr);
#endif
}
template< typename Ctx, typename Fn >
fiber_activation_record * resume_with( Fn && fn) {
from = current();
// store `this` in static, thread local pointer
// `this` will become the active (running) context
// returned by fiber::current()
current() = this;
#if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)
current()->ontop = std::bind(
[](typename std::decay< Fn >::type & fn, fiber_activation_record *& ptr){
Ctx c{ ptr };
c = fn( std::move( c) );
if ( ! c) {
ptr = nullptr;
}
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( c.ptr_, nullptr);
#else
return std::exchange( c.ptr_, nullptr);
#endif
},
std::forward< Fn >( fn),
std::placeholders::_1);
#else
current()->ontop = [fn=std::forward<Fn>(fn)](fiber_activation_record *& ptr){
Ctx c{ ptr };
c = fn( std::move( c) );
if ( ! c) {
ptr = nullptr;
}
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( c.ptr_, nullptr);
#else
return std::exchange( c.ptr_, nullptr);
#endif
};
#endif
#if defined(BOOST_USE_SEGMENTED_STACKS)
// adjust segmented stack properties
__splitstack_getcontext( from->sctx.segments_ctx);
__splitstack_setcontext( sctx.segments_ctx);
#endif
#if defined(BOOST_USE_ASAN)
__sanitizer_start_switch_fiber( & from->fake_stack, stack_bottom, stack_size);
#endif
// context switch from parent context to `this`-context
::swapcontext( & from->uctx, & uctx);
#if defined(BOOST_USE_ASAN)
__sanitizer_finish_switch_fiber( current()->fake_stack,
(const void **) & current()->from->stack_bottom,
& current()->from->stack_size);
#endif
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( current()->from, nullptr);
#else
return std::exchange( current()->from, nullptr);
#endif
}
virtual void deallocate() noexcept {
}
};
struct BOOST_CONTEXT_DECL fiber_activation_record_initializer {
fiber_activation_record_initializer() noexcept;
~fiber_activation_record_initializer();
};
struct forced_unwind {
fiber_activation_record * from{ nullptr };
#ifndef BOOST_ASSERT_IS_VOID
bool caught{ false };
#endif
forced_unwind( fiber_activation_record * from_) noexcept :
from{ from_ } {
}
#ifndef BOOST_ASSERT_IS_VOID
~forced_unwind() {
BOOST_ASSERT( caught);
}
#endif
};
template< typename Ctx, typename StackAlloc, typename Fn >
class fiber_capture_record : public fiber_activation_record {
private:
typename std::decay< StackAlloc >::type salloc_;
typename std::decay< Fn >::type fn_;
static void destroy( fiber_capture_record * p) noexcept {
typename std::decay< StackAlloc >::type salloc = std::move( p->salloc_);
stack_context sctx = p->sctx;
// deallocate activation record
p->~fiber_capture_record();
// destroy stack with stack allocator
salloc.deallocate( sctx);
}
public:
fiber_capture_record( stack_context sctx, StackAlloc && salloc, Fn && fn) noexcept :
fiber_activation_record{ sctx },
salloc_{ std::forward< StackAlloc >( salloc) },
fn_( std::forward< Fn >( fn) ) {
}
void deallocate() noexcept override final {
BOOST_ASSERT( main_ctx || ( ! main_ctx && terminated) );
destroy( this);
}
void run() {
#if defined(BOOST_USE_ASAN)
__sanitizer_finish_switch_fiber( fake_stack,
(const void **) & from->stack_bottom,
& from->stack_size);
#endif
Ctx c{ from };
try {
// invoke context-function
#if defined(BOOST_NO_CXX17_STD_INVOKE)
c = boost::context::detail::invoke( fn_, std::move( c) );
#else
c = std::invoke( fn_, std::move( c) );
#endif
} catch ( forced_unwind const& ex) {
c = Ctx{ ex.from };
#ifndef BOOST_ASSERT_IS_VOID
const_cast< forced_unwind & >( ex).caught = true;
#endif
}
// this context has finished its task
from = nullptr;
ontop = nullptr;
terminated = true;
force_unwind = false;
std::move( c).resume();
BOOST_ASSERT_MSG( false, "fiber already terminated");
}
};
template< typename Ctx, typename StackAlloc, typename Fn >
static fiber_activation_record * create_fiber1( StackAlloc && salloc, Fn && fn) {
typedef fiber_capture_record< Ctx, StackAlloc, Fn > capture_t;
auto sctx = salloc.allocate();
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
& ~ static_cast< uintptr_t >( 0xff) );
// placment new for control structure on context stack
capture_t * record = new ( storage) capture_t{
sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
// stack bottom
void * stack_bottom = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sctx.size) );
// create user-context
if ( BOOST_UNLIKELY( 0 != ::getcontext( & record->uctx) ) ) {
record->~capture_t();
salloc.deallocate( sctx);
throw std::system_error(
std::error_code( errno, std::system_category() ),
"getcontext() failed");
}
record->uctx.uc_stack.ss_sp = stack_bottom;
// 64byte gap between control structure and stack top
record->uctx.uc_stack.ss_size = reinterpret_cast< uintptr_t >( storage) -
reinterpret_cast< uintptr_t >( stack_bottom) - static_cast< uintptr_t >( 64);
record->uctx.uc_link = nullptr;
::makecontext( & record->uctx, ( void (*)() ) & fiber_entry_func< capture_t >, 1, record);
#if defined(BOOST_USE_ASAN)
record->stack_bottom = record->uctx.uc_stack.ss_sp;
record->stack_size = record->uctx.uc_stack.ss_size;
#endif
return record;
}
template< typename Ctx, typename StackAlloc, typename Fn >
static fiber_activation_record * create_fiber2( preallocated palloc, StackAlloc && salloc, Fn && fn) {
typedef fiber_capture_record< Ctx, StackAlloc, Fn > capture_t;
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( palloc.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
& ~ static_cast< uintptr_t >( 0xff) );
// placment new for control structure on context stack
capture_t * record = new ( storage) capture_t{
palloc.sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
// stack bottom
void * stack_bottom = reinterpret_cast< void * >(
reinterpret_cast< uintptr_t >( palloc.sctx.sp) - static_cast< uintptr_t >( palloc.sctx.size) );
// create user-context
if ( BOOST_UNLIKELY( 0 != ::getcontext( & record->uctx) ) ) {
record->~capture_t();
salloc.deallocate( palloc.sctx);
throw std::system_error(
std::error_code( errno, std::system_category() ),
"getcontext() failed");
}
record->uctx.uc_stack.ss_sp = stack_bottom;
// 64byte gap between control structure and stack top
record->uctx.uc_stack.ss_size = reinterpret_cast< uintptr_t >( storage) -
reinterpret_cast< uintptr_t >( stack_bottom) - static_cast< uintptr_t >( 64);
record->uctx.uc_link = nullptr;
::makecontext( & record->uctx, ( void (*)() ) & fiber_entry_func< capture_t >, 1, record);
#if defined(BOOST_USE_ASAN)
record->stack_bottom = record->uctx.uc_stack.ss_sp;
record->stack_size = record->uctx.uc_stack.ss_size;
#endif
return record;
}
}
class BOOST_CONTEXT_DECL fiber {
private:
friend struct detail::fiber_activation_record;
template< typename Ctx, typename StackAlloc, typename Fn >
friend class detail::fiber_capture_record;
template< typename Ctx, typename StackAlloc, typename Fn >
friend detail::fiber_activation_record * detail::create_fiber1( StackAlloc &&, Fn &&);
template< typename Ctx, typename StackAlloc, typename Fn >
friend detail::fiber_activation_record * detail::create_fiber2( preallocated, StackAlloc &&, Fn &&);
template< typename StackAlloc, typename Fn >
friend fiber
callcc( std::allocator_arg_t, StackAlloc &&, Fn &&);
template< typename StackAlloc, typename Fn >
friend fiber
callcc( std::allocator_arg_t, preallocated, StackAlloc &&, Fn &&);
detail::fiber_activation_record * ptr_{ nullptr };
fiber( detail::fiber_activation_record * ptr) noexcept :
ptr_{ ptr } {
}
public:
fiber() = default;
template< typename Fn, typename = detail::disable_overload< fiber, Fn > >
fiber( Fn && fn) :
fiber{
std::allocator_arg,
#if defined(BOOST_USE_SEGMENTED_STACKS)
segmented_stack(),
#else
fixedsize_stack(),
#endif
std::forward< Fn >( fn) } {
}
template< typename StackAlloc, typename Fn >
fiber( std::allocator_arg_t, StackAlloc && salloc, Fn && fn) :
ptr_{ detail::create_fiber1< fiber >(
std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) } {
}
template< typename StackAlloc, typename Fn >
fiber( std::allocator_arg_t, preallocated palloc, StackAlloc && salloc, Fn && fn) :
ptr_{ detail::create_fiber2< fiber >(
palloc, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) } {
}
~fiber() {
if ( BOOST_UNLIKELY( nullptr != ptr_) && ! ptr_->main_ctx) {
if ( BOOST_LIKELY( ! ptr_->terminated) ) {
ptr_->force_unwind = true;
ptr_->resume();
BOOST_ASSERT( ptr_->terminated);
}
ptr_->deallocate();
}
}
fiber( fiber const&) = delete;
fiber & operator=( fiber const&) = delete;
fiber( fiber && other) noexcept {
swap( other);
}
fiber & operator=( fiber && other) noexcept {
if ( BOOST_LIKELY( this != & other) ) {
fiber tmp = std::move( other);
swap( tmp);
}
return * this;
}
fiber resume() && {
BOOST_ASSERT( nullptr != ptr_);
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::fiber_activation_record * ptr = detail::exchange( ptr_, nullptr)->resume();
#else
detail::fiber_activation_record * ptr = std::exchange( ptr_, nullptr)->resume();
#endif
if ( BOOST_UNLIKELY( detail::fiber_activation_record::current()->force_unwind) ) {
throw detail::forced_unwind{ ptr};
} else if ( BOOST_UNLIKELY( nullptr != detail::fiber_activation_record::current()->ontop) ) {
ptr = detail::fiber_activation_record::current()->ontop( ptr);
detail::fiber_activation_record::current()->ontop = nullptr;
}
return { ptr };
}
template< typename Fn >
fiber resume_with( Fn && fn) && {
BOOST_ASSERT( nullptr != ptr_);
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::fiber_activation_record * ptr =
detail::exchange( ptr_, nullptr)->resume_with< fiber >( std::forward< Fn >( fn) );
#else
detail::fiber_activation_record * ptr =
std::exchange( ptr_, nullptr)->resume_with< fiber >( std::forward< Fn >( fn) );
#endif
if ( BOOST_UNLIKELY( detail::fiber_activation_record::current()->force_unwind) ) {
throw detail::forced_unwind{ ptr};
} else if ( BOOST_UNLIKELY( nullptr != detail::fiber_activation_record::current()->ontop) ) {
ptr = detail::fiber_activation_record::current()->ontop( ptr);
detail::fiber_activation_record::current()->ontop = nullptr;
}
return { ptr };
}
explicit operator bool() const noexcept {
return nullptr != ptr_ && ! ptr_->terminated;
}
bool operator!() const noexcept {
return nullptr == ptr_ || ptr_->terminated;
}
bool operator<( fiber const& other) const noexcept {
return ptr_ < other.ptr_;
}
template< typename charT, class traitsT >
friend std::basic_ostream< charT, traitsT > &
operator<<( std::basic_ostream< charT, traitsT > & os, fiber const& other) {
if ( nullptr != other.ptr_) {
return os << other.ptr_;
} else {
return os << "{not-a-context}";
}
}
void swap( fiber & other) noexcept {
std::swap( ptr_, other.ptr_);
}
};
inline
void swap( fiber & l, fiber & r) noexcept {
l.swap( r);
}
typedef fiber fiber_context;
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_FIBER_H

446
linx64/include/boost/context/fiber_winfib.hpp Normal file
View File

@@ -0,0 +1,446 @@
// Copyright Oliver Kowalke 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_FIBER_H
#define BOOST_CONTEXT_FIBER_H
#include <windows.h>
#include <boost/context/detail/config.hpp>
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <memory>
#include <ostream>
#include <system_error>
#include <tuple>
#include <utility>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/context/detail/disable_overload.hpp>
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
#include <boost/context/detail/exchange.hpp>
#endif
#if defined(BOOST_NO_CXX17_STD_INVOKE)
#include <boost/context/detail/invoke.hpp>
#endif
#include <boost/context/fixedsize_stack.hpp>
#include <boost/context/flags.hpp>
#include <boost/context/preallocated.hpp>
#include <boost/context/stack_context.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4702)
#endif
namespace boost {
namespace context {
namespace detail {
// tampoline function
// entered if the execution context
// is resumed for the first time
template< typename Record >
static VOID WINAPI fiber_entry_func( LPVOID data) noexcept {
Record * record = static_cast< Record * >( data);
BOOST_ASSERT( nullptr != record);
// start execution of toplevel context-function
record->run();
}
struct BOOST_CONTEXT_DECL fiber_activation_record {
LPVOID fiber{ nullptr };
stack_context sctx{};
bool main_ctx{ true };
fiber_activation_record * from{ nullptr };
std::function< fiber_activation_record*(fiber_activation_record*&) > ontop{};
bool terminated{ false };
bool force_unwind{ false };
static fiber_activation_record *& current() noexcept;
// used for toplevel-context
// (e.g. main context, thread-entry context)
fiber_activation_record() noexcept {
#if ( _WIN32_WINNT > 0x0600)
if ( ::IsThreadAFiber() ) {
fiber = ::GetCurrentFiber();
} else {
fiber = ::ConvertThreadToFiber( nullptr);
}
#else
fiber = ::ConvertThreadToFiber( nullptr);
if ( BOOST_UNLIKELY( nullptr == fiber) ) {
BOOST_ASSERT( ERROR_ALREADY_FIBER == ::GetLastError());
fiber = ::GetCurrentFiber();
BOOST_ASSERT( nullptr != fiber);
BOOST_ASSERT( reinterpret_cast< LPVOID >( 0x1E00) != fiber);
}
#endif
}
fiber_activation_record( stack_context sctx_) noexcept :
sctx{ sctx_ },
main_ctx{ false } {
}
virtual ~fiber_activation_record() {
if ( BOOST_UNLIKELY( main_ctx) ) {
::ConvertFiberToThread();
} else {
::DeleteFiber( fiber);
}
}
fiber_activation_record( fiber_activation_record const&) = delete;
fiber_activation_record & operator=( fiber_activation_record const&) = delete;
bool is_main_context() const noexcept {
return main_ctx;
}
fiber_activation_record * resume() {
from = current();
// store `this` in static, thread local pointer
// `this` will become the active (running) context
current() = this;
// context switch from parent context to `this`-context
// context switch
::SwitchToFiber( fiber);
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return detail::exchange( current()->from, nullptr);
#else
return std::exchange( current()->from, nullptr);
#endif
}
template< typename Ctx, typename Fn >
fiber_activation_record * resume_with( Fn && fn) {
from = current();
// store `this` in static, thread local pointer
// `this` will become the active (running) context
// returned by fiber::current()
current() = this;
#if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS)
current()->ontop = std::bind(
[](typename std::decay< Fn >::type & fn, fiber_activation_record *& ptr){
Ctx c{ ptr };
c = fn( std::move( c) );
if ( ! c) {
ptr = nullptr;
}
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( c.ptr_, nullptr);
#else
return std::exchange( c.ptr_, nullptr);
#endif
},
std::forward< Fn >( fn),
std::placeholders::_1);
#else
current()->ontop = [fn=std::forward<Fn>(fn)](fiber_activation_record *& ptr){
Ctx c{ ptr };
c = fn( std::move( c) );
if ( ! c) {
ptr = nullptr;
}
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return exchange( c.ptr_, nullptr);
#else
return std::exchange( c.ptr_, nullptr);
#endif
};
#endif
// context switch
::SwitchToFiber( fiber);
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
return detail::exchange( current()->from, nullptr);
#else
return std::exchange( current()->from, nullptr);
#endif
}
virtual void deallocate() noexcept {
}
};
struct BOOST_CONTEXT_DECL fiber_activation_record_initializer {
fiber_activation_record_initializer() noexcept;
~fiber_activation_record_initializer();
};
struct forced_unwind {
fiber_activation_record * from{ nullptr };
#ifndef BOOST_ASSERT_IS_VOID
bool caught{ false };
#endif
explicit forced_unwind( fiber_activation_record * from_) :
from{ from_ } {
}
#ifndef BOOST_ASSERT_IS_VOID
~forced_unwind() {
BOOST_ASSERT( caught);
}
#endif
};
template< typename Ctx, typename StackAlloc, typename Fn >
class fiber_capture_record : public fiber_activation_record {
private:
typename std::decay< StackAlloc >::type salloc_;
typename std::decay< Fn >::type fn_;
static void destroy( fiber_capture_record * p) noexcept {
typename std::decay< StackAlloc >::type salloc = std::move( p->salloc_);
stack_context sctx = p->sctx;
// deallocate activation record
p->~fiber_capture_record();
// destroy stack with stack allocator
salloc.deallocate( sctx);
}
public:
fiber_capture_record( stack_context sctx, StackAlloc && salloc, Fn && fn) noexcept :
fiber_activation_record( sctx),
salloc_( std::forward< StackAlloc >( salloc)),
fn_( std::forward< Fn >( fn) ) {
}
void deallocate() noexcept override final {
BOOST_ASSERT( main_ctx || ( ! main_ctx && terminated) );
destroy( this);
}
void run() {
Ctx c{ from };
try {
// invoke context-function
#if defined(BOOST_NO_CXX17_STD_INVOKE)
c = boost::context::detail::invoke( fn_, std::move( c) );
#else
c = std::invoke( fn_, std::move( c) );
#endif
} catch ( forced_unwind const& ex) {
c = Ctx{ ex.from };
#ifndef BOOST_ASSERT_IS_VOID
const_cast< forced_unwind & >( ex).caught = true;
#endif
}
// this context has finished its task
from = nullptr;
ontop = nullptr;
terminated = true;
force_unwind = false;
std::move( c).resume();
BOOST_ASSERT_MSG( false, "fiber already terminated");
}
};
template< typename Ctx, typename StackAlloc, typename Fn >
static fiber_activation_record * create_fiber1( StackAlloc && salloc, Fn && fn) {
typedef fiber_capture_record< Ctx, StackAlloc, Fn > capture_t;
auto sctx = salloc.allocate();
BOOST_ASSERT( ( sizeof( capture_t) ) < sctx.size);
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( sctx.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
& ~ static_cast< uintptr_t >( 0xff) );
// placment new for control structure on context stack
capture_t * record = new ( storage) capture_t{
sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
// create user-context
record->fiber = ::CreateFiber( sctx.size, & detail::fiber_entry_func< capture_t >, record);
return record;
}
template< typename Ctx, typename StackAlloc, typename Fn >
static fiber_activation_record * create_fiber2( preallocated palloc, StackAlloc && salloc, Fn && fn) {
typedef fiber_capture_record< Ctx, StackAlloc, Fn > capture_t;
BOOST_ASSERT( ( sizeof( capture_t) ) < palloc.size);
// reserve space for control structure
void * storage = reinterpret_cast< void * >(
( reinterpret_cast< uintptr_t >( palloc.sp) - static_cast< uintptr_t >( sizeof( capture_t) ) )
& ~ static_cast< uintptr_t >( 0xff) );
// placment new for control structure on context stack
capture_t * record = new ( storage) capture_t{
palloc.sctx, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) };
// create user-context
record->fiber = ::CreateFiber( palloc.sctx.size, & detail::fiber_entry_func< capture_t >, record);
return record;
}
}
class BOOST_CONTEXT_DECL fiber {
private:
friend struct detail::fiber_activation_record;
template< typename Ctx, typename StackAlloc, typename Fn >
friend class detail::fiber_capture_record;
template< typename Ctx, typename StackAlloc, typename Fn >
friend detail::fiber_activation_record * detail::create_fiber1( StackAlloc &&, Fn &&);
template< typename Ctx, typename StackAlloc, typename Fn >
friend detail::fiber_activation_record * detail::create_fiber2( preallocated, StackAlloc &&, Fn &&);
template< typename StackAlloc, typename Fn >
friend fiber
callcc( std::allocator_arg_t, StackAlloc &&, Fn &&);
template< typename StackAlloc, typename Fn >
friend fiber
callcc( std::allocator_arg_t, preallocated, StackAlloc &&, Fn &&);
detail::fiber_activation_record * ptr_{ nullptr };
fiber( detail::fiber_activation_record * ptr) noexcept :
ptr_{ ptr } {
}
public:
fiber() = default;
template< typename Fn, typename = detail::disable_overload< fiber, Fn > >
fiber( Fn && fn) :
fiber{ std::allocator_arg,
fixedsize_stack(),
std::forward< Fn >( fn) } {
}
template< typename StackAlloc, typename Fn >
fiber( std::allocator_arg_t, StackAlloc && salloc, Fn && fn) :
ptr_{ detail::create_fiber1< fiber >(
std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) } {;
}
template< typename StackAlloc, typename Fn >
fiber( std::allocator_arg_t, preallocated palloc, StackAlloc && salloc, Fn && fn) :
ptr_{ detail::create_fiber2< fiber >(
palloc, std::forward< StackAlloc >( salloc), std::forward< Fn >( fn) ) } {
}
~fiber() {
if ( BOOST_UNLIKELY( nullptr != ptr_) && ! ptr_->main_ctx) {
if ( BOOST_LIKELY( ! ptr_->terminated) ) {
ptr_->force_unwind = true;
ptr_->resume();
BOOST_ASSERT( ptr_->terminated);
}
ptr_->deallocate();
}
}
fiber( fiber const&) = delete;
fiber & operator=( fiber const&) = delete;
fiber( fiber && other) noexcept {
swap( other);
}
fiber & operator=( fiber && other) noexcept {
if ( BOOST_LIKELY( this != & other) ) {
fiber tmp = std::move( other);
swap( tmp);
}
return * this;
}
fiber resume() && {
BOOST_ASSERT( nullptr != ptr_);
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::fiber_activation_record * ptr = detail::exchange( ptr_, nullptr)->resume();
#else
detail::fiber_activation_record * ptr = std::exchange( ptr_, nullptr)->resume();
#endif
if ( BOOST_UNLIKELY( detail::fiber_activation_record::current()->force_unwind) ) {
throw detail::forced_unwind{ ptr};
} else if ( BOOST_UNLIKELY( nullptr != detail::fiber_activation_record::current()->ontop) ) {
ptr = detail::fiber_activation_record::current()->ontop( ptr);
detail::fiber_activation_record::current()->ontop = nullptr;
}
return { ptr };
}
template< typename Fn >
fiber resume_with( Fn && fn) && {
BOOST_ASSERT( nullptr != ptr_);
#if defined(BOOST_NO_CXX14_STD_EXCHANGE)
detail::fiber_activation_record * ptr =
detail::exchange( ptr_, nullptr)->resume_with< fiber >( std::forward< Fn >( fn) );
#else
detail::fiber_activation_record * ptr =
std::exchange( ptr_, nullptr)->resume_with< fiber >( std::forward< Fn >( fn) );
#endif
if ( BOOST_UNLIKELY( detail::fiber_activation_record::current()->force_unwind) ) {
throw detail::forced_unwind{ ptr};
} else if ( BOOST_UNLIKELY( nullptr != detail::fiber_activation_record::current()->ontop) ) {
ptr = detail::fiber_activation_record::current()->ontop( ptr);
detail::fiber_activation_record::current()->ontop = nullptr;
}
return { ptr };
}
explicit operator bool() const noexcept {
return nullptr != ptr_ && ! ptr_->terminated;
}
bool operator!() const noexcept {
return nullptr == ptr_ || ptr_->terminated;
}
bool operator<( fiber const& other) const noexcept {
return ptr_ < other.ptr_;
}
template< typename charT, class traitsT >
friend std::basic_ostream< charT, traitsT > &
operator<<( std::basic_ostream< charT, traitsT > & os, fiber const& other) {
if ( nullptr != other.ptr_) {
return os << other.ptr_;
} else {
return os << "{not-a-context}";
}
}
void swap( fiber & other) noexcept {
std::swap( ptr_, other.ptr_);
}
};
inline
void swap( fiber & l, fiber & r) noexcept {
l.swap( r);
}
typedef fiber fiber_context;
}}
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_FIBER_H

75
linx64/include/boost/context/fixedsize_stack.hpp
View File

@@ -4,10 +4,77 @@
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_FIXEDSIZE_H
#define BOOST_CONTEXT_FIXEDSIZE_H
#include <cstddef>
#include <cstdlib>
#include <new>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#if defined(BOOST_WINDOWS)
# include <boost/context/windows/fixedsize_stack.hpp>
#else
# include <boost/context/posix/fixedsize_stack.hpp>
#include <boost/context/detail/config.hpp>
#include <boost/context/stack_context.hpp>
#include <boost/context/stack_traits.hpp>
#if defined(BOOST_USE_VALGRIND)
#include <valgrind/valgrind.h>
#endif
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
template< typename traitsT >
class basic_fixedsize_stack {
private:
std::size_t size_;
public:
typedef traitsT traits_type;
basic_fixedsize_stack( std::size_t size = traits_type::default_size() ) BOOST_NOEXCEPT_OR_NOTHROW :
size_( size) {
}
stack_context allocate() {
void * vp = std::malloc( size_);
if ( ! vp) {
throw std::bad_alloc();
}
stack_context sctx;
sctx.size = size_;
sctx.sp = static_cast< char * >( vp) + sctx.size;
#if defined(BOOST_USE_VALGRIND)
sctx.valgrind_stack_id = VALGRIND_STACK_REGISTER( sctx.sp, vp);
#endif
return sctx;
}
void deallocate( stack_context & sctx) BOOST_NOEXCEPT_OR_NOTHROW {
BOOST_ASSERT( sctx.sp);
#if defined(BOOST_USE_VALGRIND)
VALGRIND_STACK_DEREGISTER( sctx.valgrind_stack_id);
#endif
void * vp = static_cast< char * >( sctx.sp) - sctx.size;
std::free( vp);
}
};
typedef basic_fixedsize_stack< stack_traits > fixedsize_stack;
# if ! defined(BOOST_USE_SEGMENTED_STACKS)
typedef fixedsize_stack default_stack;
# endif
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_FIXEDSIZE_H

1
linx64/include/boost/context/pooled_fixedsize_stack.hpp
View File

@@ -14,6 +14,7 @@
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/intrusive_ptr.hpp>
#include <boost/pool/pool.hpp>
#include <boost/context/detail/config.hpp>

80
linx64/include/boost/context/posix/fixedsize_stack.hpp
View File

@@ -1,80 +0,0 @@
// Copyright Oliver Kowalke 2014.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_FIXEDSIZE_H
#define BOOST_CONTEXT_FIXEDSIZE_H
#include <cstddef>
#include <cstdlib>
#include <new>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/context/detail/config.hpp>
#include <boost/context/stack_context.hpp>
#include <boost/context/stack_traits.hpp>
#if defined(BOOST_USE_VALGRIND)
#include <valgrind/valgrind.h>
#endif
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
template< typename traitsT >
class basic_fixedsize_stack {
private:
std::size_t size_;
public:
typedef traitsT traits_type;
basic_fixedsize_stack( std::size_t size = traits_type::default_size() ) BOOST_NOEXCEPT_OR_NOTHROW :
size_( size) {
}
stack_context allocate() {
void * vp = std::malloc( size_);
if ( ! vp) {
throw std::bad_alloc();
}
stack_context sctx;
sctx.size = size_;
sctx.sp = static_cast< char * >( vp) + sctx.size;
#if defined(BOOST_USE_VALGRIND)
sctx.valgrind_stack_id = VALGRIND_STACK_REGISTER( sctx.sp, vp);
#endif
return sctx;
}
void deallocate( stack_context & sctx) BOOST_NOEXCEPT_OR_NOTHROW {
BOOST_ASSERT( sctx.sp);
#if defined(BOOST_USE_VALGRIND)
VALGRIND_STACK_DEREGISTER( sctx.valgrind_stack_id);
#endif
void * vp = static_cast< char * >( sctx.sp) - sctx.size;
std::free( vp);
}
};
typedef basic_fixedsize_stack< stack_traits > fixedsize_stack;
# if ! defined(BOOST_USE_SEGMENTED_STACKS)
typedef fixedsize_stack default_stack;
# endif
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_FIXEDSIZE_H

14
linx64/include/boost/context/posix/protected_fixedsize_stack.hpp
View File

@@ -49,15 +49,13 @@ public:
}
stack_context allocate() {
// page at bottom will be used as guard-page
const std::size_t pages(
static_cast< std::size_t >(
std::floor(
// calculate how many pages are required
const std::size_t pages(
static_cast< std::size_t >(
std::ceil(
static_cast< float >( size_) / traits_type::page_size() ) ) );
BOOST_ASSERT_MSG( 2 <= pages, "at least two pages must fit into stack (one page is guard-page)");
const std::size_t size__( pages * traits_type::page_size() );
BOOST_ASSERT( 0 != size_ && 0 != size__);
BOOST_ASSERT( size__ <= size_);
// add one page at bottom that will be used as guard-page
const std::size_t size__ = ( pages + 1) * traits_type::page_size();
// conform to POSIX.4 (POSIX.1b-1993, _POSIX_C_SOURCE=199309L)
#if defined(MAP_ANON)

4
linx64/include/boost/context/stack_context.hpp
View File

@@ -21,7 +21,7 @@ namespace boost {
namespace context {
#if ! defined(BOOST_CONTEXT_NO_CXX11)
struct stack_context {
struct BOOST_CONTEXT_DECL stack_context {
# if defined(BOOST_USE_SEGMENTED_STACKS)
typedef void * segments_context[BOOST_CONTEXT_SEGMENTS];
# endif
@@ -36,7 +36,7 @@ struct stack_context {
# endif
};
#else
struct stack_context {
struct BOOST_CONTEXT_DECL stack_context {
# if defined(BOOST_USE_SEGMENTED_STACKS)
typedef void * segments_context[BOOST_CONTEXT_SEGMENTS];
# endif

80
linx64/include/boost/context/windows/fixedsize_stack.hpp
View File

@@ -1,80 +0,0 @@
// Copyright Oliver Kowalke 2014.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_FIXEDSIZE_H
#define BOOST_CONTEXT_FIXEDSIZE_H
extern "C" {
#include <windows.h>
}
#include <cmath>
#include <cstddef>
#include <new>
#include <boost/config.hpp>
#include <boost/context/detail/config.hpp>
#include <boost/context/stack_context.hpp>
#include <boost/context/stack_traits.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
template< typename traitsT >
class basic_fixedsize_stack {
private:
std::size_t size_;
public:
typedef traitsT traits_type;
basic_fixedsize_stack( std::size_t size = traits_type::default_size() ) BOOST_NOEXCEPT_OR_NOTHROW :
size_( size) {
}
stack_context allocate() {
// page at bottom will be used as guard-page
const std::size_t pages(
static_cast< std::size_t >(
std::floor(
static_cast< float >( size_) / traits_type::page_size() ) ) );
BOOST_ASSERT_MSG( 1 <= pages, "at least one page must fit into stack");
const std::size_t size__( pages * traits_type::page_size() );
BOOST_ASSERT( 0 != size_ && 0 != size__);
BOOST_ASSERT( size__ <= size_);
void * vp = ::VirtualAlloc( 0, size__, MEM_COMMIT, PAGE_READWRITE);
if ( ! vp) throw std::bad_alloc();
stack_context sctx;
sctx.size = size__;
sctx.sp = static_cast< char * >( vp) + sctx.size;
return sctx;
}
void deallocate( stack_context & sctx) BOOST_NOEXCEPT_OR_NOTHROW {
BOOST_ASSERT( sctx.sp);
void * vp = static_cast< char * >( sctx.sp) - sctx.size;
::VirtualFree( vp, 0, MEM_RELEASE);
}
};
typedef basic_fixedsize_stack< stack_traits > fixedsize_stack;
typedef fixedsize_stack default_stack;
}}
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_FIXEDSIZE_H

14
linx64/include/boost/context/windows/protected_fixedsize_stack.hpp
View File

@@ -41,15 +41,13 @@ public:
}
stack_context allocate() {
// page at bottom will be used as guard-page
const std::size_t pages(
static_cast< std::size_t >(
std::floor(
// calculate how many pages are required
const std::size_t pages(
static_cast< std::size_t >(
std::ceil(
static_cast< float >( size_) / traits_type::page_size() ) ) );
BOOST_ASSERT_MSG( 2 <= pages, "at least two pages must fit into stack (one page is guard-page)");
const std::size_t size__( pages * traits_type::page_size() );
BOOST_ASSERT( 0 != size_ && 0 != size__);
BOOST_ASSERT( size__ <= size_);
// add one page at bottom that will be used as guard-page
const std::size_t size__ = ( pages + 1) * traits_type::page_size();
void * vp = ::VirtualAlloc( 0, size__, MEM_COMMIT, PAGE_READWRITE);
if ( ! vp) throw std::bad_alloc();