|  | Home | Libraries | People | FAQ | More | 
Boost.Context supports usage of a segmented, e. g. the size of the stack grows on demand. The coroutine is created with a minimal stack size and will be increased as required. Class segmented models the stack-allocator concept. In contrast to protected_fixedsize and fixedsize it creates a stack which grows on demand.
| ![[Note]](../../../../../../../doc/src/images/note.png) | Note | 
|---|---|
| Segmented stacks are currently only supported by gcc from version 4.7 clang from version 3.4 onwards. In order to use a __segmented_stack__ Boost.Context must be built with toolset=gcc segmented-stacks=on at b2/bjam command-line. Applications must be compiled with compiler-flags -fsplit-stack -DBOOST_USE_SEGMENTED_STACKS. | 
#include <boost/context/segmented.hpp> template< typename traitsT > struct basic_segmented { typedef traitT traits_type; basic_segmented(std::size_t size = traits_type::default_size()); stack_context allocate(); void deallocate( stack_context &); } typedef basic_segmented< stack_traits > segmented;
stack_context allocate()
        
                traits_type::minimum:size()
                <= size
                and ! traits_type::is_unbounded() &&
                ( traits_type::maximum:size() >=
                size).
              
                Allocates memory of at least size
                Bytes and stores a pointer to the stack and its actual size in sctx. Depending on the architecture
                (the stack grows downwards/upwards) the stored address is the highest/lowest
                address of the stack.
              
void deallocate( stack_context
          & sctx)
        
                sctx.sp is valid, traits_type::minimum:size() <=
                sctx.size and !
                traits_type::is_unbounded()
                && (
                traits_type::maximum:size()
                >= sctx.size).
              
Deallocates the stack space.