[Boost-commit] svn:boost r41437 - in sandbox/SOC/2006/coroutine/trunk: boost/coroutine boost/coroutine/detail libs/coroutine/src

From: hartmut.kaiser_at_[hidden]
Date: 2007-11-28 12:20:21

Author: hkaiser
Date: 2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
New Revision: 41437
URL: http://svn.boost.org/trac/boost/changeset/41437

Log:
[Coroutine] Added support for Linux/gcc 64 Bit systems. Fixed a lot of typos in comments, untabified files.
Added:
   sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_linux64.hpp   (contents, props changed)
   sandbox/SOC/2006/coroutine/trunk/libs/coroutine/src/swapcontext32.cpp   (contents, props changed)
   sandbox/SOC/2006/coroutine/trunk/libs/coroutine/src/swapcontext64.cpp   (contents, props changed)
Text files modified: 
   sandbox/SOC/2006/coroutine/trunk/boost/coroutine/coroutine.hpp                   |    62 +++++++++---------                      
   sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_base.hpp         |     8 +-                                      
   sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_linux.hpp        |   131 ++++++++++++++++++++------------------- 
   sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_windows.hpp      |    76 +++++++++++-----------                  
   sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/coroutine_accessor.hpp   |     4                                         
   sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/coroutine_impl.hpp       |    57 ++++++++--------                        
   sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/default_context_impl.hpp |    27 ++++++-                                 
   sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/posix_utility.hpp        |     4                                         
   sandbox/SOC/2006/coroutine/trunk/boost/coroutine/shared_coroutine.hpp            |     2                                         
   sandbox/SOC/2006/coroutine/trunk/libs/coroutine/src/swapcontext.cpp              |    95 ++--------------------------            
   10 files changed, 203 insertions(+), 263 deletions(-)

Modified: sandbox/SOC/2006/coroutine/trunk/boost/coroutine/coroutine.hpp
==============================================================================
--- sandbox/SOC/2006/coroutine/trunk/boost/coroutine/coroutine.hpp	(original)
+++ sandbox/SOC/2006/coroutine/trunk/boost/coroutine/coroutine.hpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -54,8 +54,8 @@
     template<typename T>
     struct optional_result_type : 
       boost::mpl::if_<boost::is_same<T, void>,
-		      void,
-		      boost::optional<T> > { };
+                      void,
+                      boost::optional<T> > { };
 
     template<typename T>
     BOOST_DEDUCED_TYPENAME
@@ -65,12 +65,12 @@
     template<typename T>
     BOOST_DEDUCED_TYPENAME
     boost::disable_if<boost::is_same<T, void>,
-		      BOOST_DEDUCED_TYPENAME
-		      optional_result_type<T>::type
-		      >::type
+                      BOOST_DEDUCED_TYPENAME
+                      optional_result_type<T>::type
+                      >::type
     optional_result() {
       return BOOST_DEDUCED_TYPENAME
-	optional_result_type<T>::type();
+        optional_result_type<T>::type();
     }
   }
 
@@ -84,7 +84,7 @@
   struct is_coroutine<coroutine<Sig, Con> > : boost::mpl::true_{};
 
   template<typename Signature, 
-	   typename ContextImpl = detail::default_context_impl>
+           typename ContextImpl = detail::default_context_impl>
   class coroutine : public movable<coroutine<Signature, ContextImpl> > {
   public:
     typedef coroutine<Signature, ContextImpl> type;
@@ -124,14 +124,14 @@
 
     template<typename Functor>
     coroutine (Functor f, 
-	       std::ptrdiff_t stack_size = detail::default_stack_size,
-	       BOOST_DEDUCED_TYPENAME boost::enable_if<
-	       boost::mpl::and_<
-	       detail::is_callable<Functor>, 
-	       boost::mpl::not_<is_coroutine<Functor> >
-	       > >
-	       ::type * = 0
-	       ) :
+               std::ptrdiff_t stack_size = detail::default_stack_size,
+               BOOST_DEDUCED_TYPENAME boost::enable_if<
+               boost::mpl::and_<
+               detail::is_callable<Functor>, 
+               boost::mpl::not_<is_coroutine<Functor> >
+               > >
+               ::type * = 0
+               ) :
       m_pimpl(impl_type::create(f, stack_size)) {}
  
     coroutine(move_from<coroutine> src) 
@@ -160,15 +160,15 @@
     /**/
 
     BOOST_PP_REPEAT(BOOST_COROUTINE_ARG_MAX,
-		    BOOST_COROUTINE_generate_argument_n_type,
-		    arg_slot_traits);
+                    BOOST_COROUTINE_generate_argument_n_type,
+                    arg_slot_traits);
 
     static const int arity = arg_slot_traits::length;
 
     struct yield_traits {
       BOOST_PP_REPEAT(BOOST_COROUTINE_ARG_MAX,
-		      BOOST_COROUTINE_generate_argument_n_type,
-		      result_slot_traits);
+                      BOOST_COROUTINE_generate_argument_n_type,
+                      result_slot_traits);
       static const int arity = result_slot_traits::length;
     };
 
@@ -184,12 +184,12 @@
     result_type operator()
       (BOOST_PP_ENUM
        (BOOST_COROUTINE_ARG_MAX,
-	BOOST_COROUTINE_param_with_default,
-	arg)) {
+        BOOST_COROUTINE_param_with_default,
+        arg)) {
       return call_impl
-	(arg_slot_type(BOOST_PP_ENUM_PARAMS
-	  (BOOST_COROUTINE_ARG_MAX, 
-	   arg)));
+        (arg_slot_type(BOOST_PP_ENUM_PARAMS
+          (BOOST_COROUTINE_ARG_MAX, 
+           arg)));
     }
 
     BOOST_DEDUCED_TYPENAME
@@ -198,12 +198,12 @@
       (const std::nothrow_t&
        BOOST_PP_ENUM_TRAILING
        (BOOST_COROUTINE_ARG_MAX,
-	BOOST_COROUTINE_param_with_default,
-	arg)) {
+        BOOST_COROUTINE_param_with_default,
+        arg)) {
       return call_impl_nothrow
-	(arg_slot_type(BOOST_PP_ENUM_PARAMS
-	  (BOOST_COROUTINE_ARG_MAX, 
-	   arg)));
+        (arg_slot_type(BOOST_PP_ENUM_PARAMS
+          (BOOST_COROUTINE_ARG_MAX, 
+           arg)));
     }
 
 #   undef BOOST_COROUTINE_param_typedef
@@ -244,7 +244,7 @@
   protected:
 
     // The second parameter is used to avoid calling this constructor
-    // by mistake from other member funcitons (specifically operator=).
+    // by mistake from other member functions (specifically operator=).
     coroutine(impl_type * pimpl, detail::init_from_impl_tag) :
       m_pimpl(pimpl) {}
 
@@ -272,7 +272,7 @@
       result_slot_type * ptr;
       m_pimpl->bind_result_pointer(&ptr);
       if(!m_pimpl->wake_up())
-	return detail::optional_result<result_type>();
+        return detail::optional_result<result_type>();
 
       return detail::fix_result<result_slot_traits>(*m_pimpl->result());
     }

Modified: sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_base.hpp
==============================================================================
--- sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_base.hpp	(original)
+++ sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_base.hpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -205,7 +205,7 @@
     void invoke() {
       BOOST_ASSERT(ready());
       do_invoke();
-      // TODO: could use a bynary or here to eliminate
+      // TODO: could use a binary or here to eliminate
       // shortcut evaluation (and a branch), but maybe the compiler is
       // smart enough to do it anyway as there are no side effects.
       if(m_exit_status || m_state == ctx_waiting) {
@@ -220,7 +220,7 @@
         } else if(m_exit_status == ctx_exited_exit)
           throw coroutine_exited();
               else {
-	  BOOST_ASSERT(0 && "unkonw exit status");
+	  BOOST_ASSERT(0 && "unknown exit status");
         }
       }
     }
@@ -263,7 +263,7 @@
     // The exit_exception would cause the future to be destroyed and
     // an assertion to be generated. Removing an assertion is not a 
     // solution because we would leak the coroutine impl. The callback
-    // bound to the future in fact hold a refrence to it. If the coroutine
+    // bound to the future in fact hold a reference to it. If the coroutine
     // is exited the callback cannot be called.
     void wait(int n) {
       BOOST_ASSERT(!(n<0));
@@ -300,7 +300,7 @@
     // Cause this coroutine to exit.
     // Can only be called on a ready coroutine.
     // Cannot be called if there are pending operations.
-    // It follws that cannot be called from 'this'.
+    // It follows that cannot be called from 'this'.
     // Nothrow.
     void exit() throw(){
       BOOST_ASSERT(!pending());

Modified: sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_linux.hpp
==============================================================================
--- sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_linux.hpp	(original)
+++ sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_linux.hpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -37,7 +37,7 @@
 
 /*
  * Defining BOOST_COROUTINE_INLINE_ASM will enable the inlin3
- * assembler verwsion of swapcontext_stack.
+ * assembler version of swapcontext_stack.
  * The inline asm, with all required clobber flags, is usually no faster
  * than the out-of-line function, and it is not yet clear if
  * it is always reliable (i.e. if the compiler always saves the correct
@@ -109,26 +109,26 @@
 fun_type get_swapper(){
   fun_type ptr;
   asm volatile("mov $0f, %[result]"
-	       "\n\t jmp 1f"
-	       "\n0:"
-	       //"\n\t movl 16(%%edx), %%ecx"
-	       "\n\t pushl %%ebp"
-	       "\n\t pushl %%ebx"
-	       "\n\t pushl %%esi"
-	       "\n\t pushl %%edi"
-	       "\n\t movl %%esp, (%%eax)"
-	       "\n\t movl %%edx, %%esp"
-	       "\n\t popl %%edi"
-	       "\n\t popl %%esi"
-	       "\n\t popl %%ebx"
-	       "\n\t popl %%ebp"
-	       "\n\t popl %%ecx"
-	       "\n\t jmp *%%ecx"
-	       "\n1:"
-	       :
-	       [result] "=g" (ptr) 
-	       :       
-	       );
+               "\n\t jmp 1f"
+               "\n0:"
+               //"\n\t movl 16(%%edx), %%ecx"
+               "\n\t pushl %%ebp"
+               "\n\t pushl %%ebx"
+               "\n\t pushl %%esi"
+               "\n\t pushl %%edi"
+               "\n\t movl %%esp, (%%eax)"
+               "\n\t movl %%edx, %%esp"
+               "\n\t popl %%edi"
+               "\n\t popl %%esi"
+               "\n\t popl %%ebx"
+               "\n\t popl %%ebp"
+               "\n\t popl %%ecx"
+               "\n\t jmp *%%ecx"
+               "\n1:"
+               :
+               [result] "=g" (ptr) 
+               :       
+               );
   return ptr;
 };
 
@@ -167,16 +167,16 @@
       ia32_gcc_context_impl_base() {};
 
       void prefetch() const {
-	__builtin_prefetch (m_sp, 1, 3);
-	__builtin_prefetch (m_sp, 0, 3);
-	__builtin_prefetch ((void**)m_sp+64/4, 1, 3);
-	__builtin_prefetch ((void**)m_sp+64/4, 0, 3);
-	__builtin_prefetch ((void**)m_sp+32/4, 1, 3);
-	__builtin_prefetch ((void**)m_sp+32/4, 0, 3);
-	__builtin_prefetch ((void**)m_sp-32/4, 1, 3);
-	__builtin_prefetch ((void**)m_sp-32/4, 0, 3);
-	__builtin_prefetch ((void**)m_sp-64/4, 1, 3);
-	__builtin_prefetch ((void**)m_sp-64/4, 0, 3);
+        __builtin_prefetch (m_sp, 1, 3);
+        __builtin_prefetch (m_sp, 0, 3);
+        __builtin_prefetch ((void**)m_sp+64/4, 1, 3);
+        __builtin_prefetch ((void**)m_sp+64/4, 0, 3);
+        __builtin_prefetch ((void**)m_sp+32/4, 1, 3);
+        __builtin_prefetch ((void**)m_sp+32/4, 0, 3);
+        __builtin_prefetch ((void**)m_sp-32/4, 1, 3);
+        __builtin_prefetch ((void**)m_sp-32/4, 0, 3);
+        __builtin_prefetch ((void**)m_sp-64/4, 1, 3);
+        __builtin_prefetch ((void**)m_sp-64/4, 0, 3);
       }
 
       /**
@@ -187,29 +187,29 @@
       friend 
       void 
       swap_context(ia32_gcc_context_impl_base& from, 
-		   ia32_gcc_context_impl_base const& to, 
-		   default_hint) {
-	to.prefetch();
-	swapcontext_stack(&from.m_sp, to.m_sp);
+                   ia32_gcc_context_impl_base const& to, 
+                   default_hint) {
+        to.prefetch();
+        swapcontext_stack(&from.m_sp, to.m_sp);
       }
 
 #ifndef BOOST_COROUTINE_NO_SEPARATE_CALL_SITES
       friend 
       void 
       swap_context(ia32_gcc_context_impl_base& from, 
-		   ia32_gcc_context_impl_base const& to,
-		   yield_hint) {
-	to.prefetch();
-	swapcontext_stack2(&from.m_sp, to.m_sp);
+                   ia32_gcc_context_impl_base const& to,
+                   yield_hint) {
+        to.prefetch();
+        swapcontext_stack2(&from.m_sp, to.m_sp);
       }
 
       friend 
       void 
       swap_context(ia32_gcc_context_impl_base& from, 
-		   ia32_gcc_context_impl_base const& to,
-		   yield_to_hint) {
-	to.prefetch();
-	swapcontext_stack2(&from.m_sp, to.m_sp);
+                   ia32_gcc_context_impl_base const& to,
+                   yield_to_hint) {
+        to.prefetch();
+        swapcontext_stack2(&from.m_sp, to.m_sp);
       }
 
 #endif
@@ -226,41 +226,42 @@
       typedef ia32_gcc_context_impl_base context_impl_base;
 
       ia32_gcc_context_impl() :
-	m_stack(0) {}
+        m_stack(0) {}
       /**
        * Create a context that on restore invokes Functor on
        *  a new stack. The stack size can be optionally specified.
        */
       template<typename Functor>
-	  ia32_gcc_context_impl(Functor& cb, std::ptrdiff_t stack_size = -1) :
-	m_stack_size(stack_size == -1? default_stack_size: stack_size),
-	m_stack(posix::alloc_stack(m_stack_size)) {
-	m_sp = ((void**)m_stack + (m_stack_size/sizeof(void*))),
-	BOOST_ASSERT(m_stack);
-	typedef void fun(Functor*);
-	fun * funp = trampoline;
+          ia32_gcc_context_impl(Functor& cb, std::ptrdiff_t stack_size = -1) :
+        m_stack_size(stack_size == -1? default_stack_size: stack_size),
+        m_stack(posix::alloc_stack(m_stack_size)) 
+      {
+        m_sp = ((void**)m_stack + (m_stack_size/sizeof(void*)));
+        BOOST_ASSERT(m_stack);
+        typedef void fun(Functor*);
+        fun * funp = trampoline;
 #ifndef BOOST_COROUTINE_INLINE_ASM
-	*--m_sp = &cb;     // parm 0 of trampoline;
-	*--m_sp = 0;        // dummy return address for trampoline
-	*--m_sp = (void*) funp ;// return addr (here: start addr)  NOTE: the unsafe cast is safe on IA32
-	*--m_sp = 0;       // ebp                                  
-	*--m_sp = 0;       // ebx                                  
-	*--m_sp = 0;       // esi                                  
-	*--m_sp = 0;       // edi        
+        *--m_sp = &cb;     // parm 0 of trampoline;
+        *--m_sp = 0;        // dummy return address for trampoline
+        *--m_sp = (void*) funp ;// return addr (here: start addr)  NOTE: the unsafe cast is safe on IA32
+        *--m_sp = 0;       // ebp                                  
+        *--m_sp = 0;       // ebx                                  
+        *--m_sp = 0;       // esi                                  
+        *--m_sp = 0;       // edi        
 #else
-	*--m_sp = &cb;     // parm 0 of trampoline;
-	*--m_sp = 0;        // dummy return address for trampoline
-	*--m_sp = (void*) funp ;// return addr (here: start addr)  NOTE: the unsafe cast is safe on IA32
+        *--m_sp = &cb;     // parm 0 of trampoline;
+        *--m_sp = 0;        // dummy return address for trampoline
+        *--m_sp = (void*) funp ;// return addr (here: start addr)  NOTE: the unsafe cast is safe on IA32
 #endif
       }
       
       ~ia32_gcc_context_impl() {
-	if(m_stack)
-	  posix::free_stack(m_stack, m_stack_size);
+        if(m_stack)
+          posix::free_stack(m_stack, m_stack_size);
       }
 
     private:
-	  std::ptrdiff_t m_stack_size;
+          std::ptrdiff_t m_stack_size;
       void * m_stack;
     };
     
@@ -269,6 +270,7 @@
 } } }
 
 #elif defined(__linux)
+
 /**
  * For all other linux systems use the standard posix implementation.
  */
@@ -276,6 +278,7 @@
 namespace boost { namespace coroutines { namespace detail { namespace oslinux {
     typedef posix::context_impl context_impl;
 } } } }
+
 #else
 #error This header can only be included when compiling for linux systems.
 #endif

Added: sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_linux64.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_linux64.hpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -0,0 +1,167 @@
+//  Copyright (c) 2007 Robert Perricone
+//  Copyright (c) 2007 Hartmut Kaiser
+//
+//  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_COROUTINE_CONTEXT_LINUX_HPP_20071126
+#define BOOST_COROUTINE_CONTEXT_LINUX_HPP_20071126
+
+#if defined(__GNUC__) && defined(__x86_64__) && !defined(BOOST_COROUTINE_NO_ASM)
+#include <cstdlib>
+#include <cstddef>
+#include <boost/coroutine/detail/posix_utility.hpp>
+#include <boost/coroutine/detail/swap_context.hpp>
+
+/* 
+ * Defining BOOST_COROUTINE_NO_SEPARATE_CALL_SITES will disable separate 
+ * invoke, yield and yield_to swap_context functions. Separate calls sites
+ * increase performance by 25% at least on P4 for invoke+yield back loops
+ * at the cost of a slightly higher instruction cache use and is thus enabled by
+ * default.
+ */
+//#define BOOST_COROUTINE_NO_SEPARATE_CALL_SITES
+
+extern "C" void swapcontext_stack (void***, void**) throw();
+extern "C" void swapcontext_stack2 (void***, void**) throw();
+extern "C" void swapcontext_stack3 (void***, void**) throw();
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace coroutines { namespace detail {
+  namespace oslinux64 
+  {
+    template<typename T>
+    void trampoline(T* fun);
+    
+    template<typename T>
+    inline void
+    trampoline(T* fun) 
+    { 
+      (*fun)();
+      std::abort();
+    }
+
+    class ia64_gcc_context_impl_base 
+    {
+    public:
+      ia64_gcc_context_impl_base() {}
+
+      void prefetch() const 
+      {
+        __builtin_prefetch (m_sp, 1, 3);
+        __builtin_prefetch (m_sp, 0, 3);
+        __builtin_prefetch ((void**)m_sp+64/8, 1, 3);
+        __builtin_prefetch ((void**)m_sp+64/8, 0, 3);
+        __builtin_prefetch ((void**)m_sp+32/8, 1, 3);
+        __builtin_prefetch ((void**)m_sp+32/8, 0, 3);
+        __builtin_prefetch ((void**)m_sp-32/8, 1, 3);
+        __builtin_prefetch ((void**)m_sp-32/8, 0, 3);
+        __builtin_prefetch ((void**)m_sp-64/8, 1, 3);
+        __builtin_prefetch ((void**)m_sp-64/8, 0, 3);
+      }
+
+      /**
+       * Free function. Saves the current context in @p from
+       * and restores the context in @p to.
+       * @note This function is found by ADL.
+       */     
+      friend void 
+      swap_context(ia64_gcc_context_impl_base& from, 
+                   ia64_gcc_context_impl_base const& to, 
+                   default_hint) 
+      {
+        to.prefetch();
+        swapcontext_stack(&from.m_sp, to.m_sp);
+      }
+
+#ifndef BOOST_COROUTINE_NO_SEPARATE_CALL_SITES
+      friend void 
+      swap_context(ia64_gcc_context_impl_base& from, 
+                   ia64_gcc_context_impl_base const& to,
+                   yield_hint) 
+      {
+        to.prefetch();
+        swapcontext_stack2(&from.m_sp, to.m_sp);
+      }
+
+      friend void 
+      swap_context(ia64_gcc_context_impl_base& from, 
+                   ia64_gcc_context_impl_base const& to,
+                   yield_to_hint) 
+      {
+        to.prefetch();
+        swapcontext_stack3(&from.m_sp, to.m_sp);
+      }
+#endif
+
+    protected:
+      void ** m_sp;
+    };
+
+    class ia64_gcc_context_impl : public ia64_gcc_context_impl_base
+    {
+    public:
+      enum { default_stack_size = 8192 };
+      
+      typedef ia64_gcc_context_impl_base context_impl_base;
+
+      ia64_gcc_context_impl() :
+        m_stack(0) {}
+        
+      /**
+       * Create a context that on restore invokes Functor on
+       *  a new stack. The stack size can be optionally specified.
+       */
+      template<typename Functor>
+      ia64_gcc_context_impl(Functor& cb, std::ptrdiff_t stack_size = -1) 
+        : m_stack_size(stack_size == -1 ? default_stack_size : stack_size),
+          m_stack(posix::alloc_stack(m_stack_size)) 
+      {
+        BOOST_ASSERT(m_stack);
+        m_sp = ((void**)m_stack + (m_stack_size/sizeof(void*)));
+        
+        typedef void fun(Functor*);
+        fun * funp = trampoline;
+
+        *--m_sp = &cb;     // parm 0 of trampoline;
+        *--m_sp = 0;       // dummy return address for trampoline
+        *--m_sp = (void*) funp ;// return addr (here: start addr)  NOTE: the unsafe cast is safe on IA64
+        *--m_sp = 0;       // rbp                                  
+        *--m_sp = 0;       // rbx                                  
+        *--m_sp = 0;       // rsi                                  
+        *--m_sp = 0;       // rdi        
+      }
+      
+      ~ia64_gcc_context_impl() 
+      {
+        if(m_stack)
+          posix::free_stack(m_stack, m_stack_size);
+      }
+
+    private:
+      std::ptrdiff_t m_stack_size;
+      void * m_stack;
+    };
+    
+    typedef ia64_gcc_context_impl context_impl;
+  }
+}}}
+
+#elif defined(__linux)
+/**
+ * For all other linux systems use the standard posix implementation.
+ */
+#include <boost/coroutine/detail/context_posix.hpp>
+namespace boost { namespace coroutines { namespace detail { 
+  namespace oslinux64 
+  {
+    typedef posix::context_impl context_impl;
+  } 
+}}}
+#else
+#error This header can only be included when compiling for linux systems.
+#endif
+
+#endif
+

Modified: sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_windows.hpp
==============================================================================
--- sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_windows.hpp	(original)
+++ sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/context_windows.hpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -42,17 +42,17 @@
 
     /*
      * This number (0x1E00) has been sighted in the wild (at least on windows XP systems)
-     * as return value from GetCurrentFiber() on non fibrous threads. This is sowehow related
+     * as return value from GetCurrentFiber() on non fibrous threads. This is somehow related
      * to OS/2 where the current fiber pointer is overloaded as a version field.
      * On non-NT systems, 0 is returned. 
      */
-    fiber_ptr fiber_magic = reinterpret_cast<fiber_ptr>(0x1E00);
-		
+    fiber_ptr const fiber_magic = reinterpret_cast<fiber_ptr>(0x1E00);
+                
     /*
      * Return true if current thread is a fiber.
-     * FIXME: on longhorn shoud use IsThreadAFiber
+     * FIXME: on longhorn should use IsThreadAFiber
      */
-    bool is_fiber() {
+    inline bool is_fiber() {
       fiber_ptr current = GetCurrentFiber();
       return current != 0 && current != fiber_magic;
     }
@@ -71,8 +71,8 @@
        * but can be saved in.
        */
       fibers_context_impl_base() :
-	m_ctx(0) {}
-	
+        m_ctx(0) {}
+        
       /*
        * Free function. Saves the current context in @p from
        * and restores the context in @p to. On windows the from
@@ -89,34 +89,34 @@
       friend 
       void 
       swap_context(fibers_context_impl_base& from, 
-		   const fibers_context_impl_base& to,
-		   default_hint) {
-	if(!is_fiber()) {
-	  BOOST_ASSERT(from.m_ctx == 0);
-	  from.m_ctx = ConvertThreadToFiber(0);
-	  BOOST_ASSERT(from.m_ctx != 0);
-	  
-	  SwitchToFiber(to.m_ctx); 
-	  
-	  BOOL result = ConvertFiberToThread();
-	  BOOST_ASSERT(result);
-	  (void)result;
-	  from.m_ctx = 0;
-	} else {
-	  bool call_from_main = from.m_ctx == 0;
-	  if(call_from_main)
-	    from.m_ctx = GetCurrentFiber();
-	  SwitchToFiber(to.m_ctx); 
-	  if(call_from_main)
-	    from.m_ctx = 0;
-	}
+                   const fibers_context_impl_base& to,
+                   default_hint) {
+        if(!is_fiber()) {
+          BOOST_ASSERT(from.m_ctx == 0);
+          from.m_ctx = ConvertThreadToFiber(0);
+          BOOST_ASSERT(from.m_ctx != 0);
+          
+          SwitchToFiber(to.m_ctx); 
+          
+          BOOL result = ConvertFiberToThread();
+          BOOST_ASSERT(result);
+          (void)result;
+          from.m_ctx = 0;
+        } else {
+          bool call_from_main = from.m_ctx == 0;
+          if(call_from_main)
+            from.m_ctx = GetCurrentFiber();
+          SwitchToFiber(to.m_ctx); 
+          if(call_from_main)
+            from.m_ctx = 0;
+        }
       }
 
       ~fibers_context_impl_base() {}
     protected:
       explicit
       fibers_context_impl_base(fiber_ptr ctx) :
-	m_ctx(ctx) {}
+        m_ctx(ctx) {}
 
       fiber_ptr m_ctx;
     };
@@ -139,24 +139,24 @@
       enum {default_stack_size = 8192};
 
       /**
-       * Create a context that on restore inovkes Functor on
+       * Create a context that on restore invokes Functor on
        *  a new stack. The stack size can be optionally specified.
        */
       template<typename Functor>
       explicit
       fibers_context_impl(Functor& cb, std::ptrdiff_t stack_size) :
-	fibers_context_impl_base
-      (CreateFiber(stack_size== -1? 0 : stack_size,
-		   static_cast<LPFIBER_START_ROUTINE>(&trampoline<Functor>),
-		   static_cast<LPVOID>(&cb)))
+        fibers_context_impl_base
+      (CreateFiber(stack_size== -1? default_stack_size : stack_size,
+                   static_cast<LPFIBER_START_ROUTINE>(&trampoline<Functor>),
+                   static_cast<LPVOID>(&cb)))
       {
-	BOOST_ASSERT(m_ctx);
+        BOOST_ASSERT(m_ctx);
       }
-		  
+                  
       ~fibers_context_impl() {
-	DeleteFiber(m_ctx);
+        DeleteFiber(m_ctx);
       }
-		  
+                  
     private:
     };
 

Modified: sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/coroutine_accessor.hpp
==============================================================================
--- sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/coroutine_accessor.hpp	(original)
+++ sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/coroutine_accessor.hpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -62,11 +62,11 @@
     struct in_place_assign : boost::in_place_factory_base {
 
       in_place_assign(Ctx * ctx) :
-	m_ctx(ctx) {}
+        m_ctx(ctx) {}
 
       template<typename Coroutine>
       void apply(void * memory) const {
-	construct<Coroutine>(m_ctx, memory);
+        construct<Coroutine>(m_ctx, memory);
       }
       Ctx * m_ctx;
     };

Modified: sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/coroutine_impl.hpp
==============================================================================
--- sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/coroutine_impl.hpp	(original)
+++ sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/coroutine_impl.hpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -40,7 +40,7 @@
 #include <boost/coroutine/detail/context_base.hpp>
 
 namespace boost { namespace coroutines { namespace detail {
-	
+        
   // This class augment the contest_base class with
   // the coroutine signature type.
   // This is mostly just a place to put
@@ -64,10 +64,10 @@
     typedef boost::intrusive_ptr<type> pointer;
   
     template<typename DerivedType>
-	coroutine_impl(DerivedType * this_, std::ptrdiff_t stack_size) :
+        coroutine_impl(DerivedType * this_, std::ptrdiff_t stack_size) :
       context_base(*this_, stack_size),
-	m_arg(0),
-	m_result(0){}
+        m_arg(0),
+        m_result(0){}
                 
     arg_slot_type * args() {
       BOOST_ASSERT(m_arg);
@@ -81,8 +81,8 @@
     } 
 
     template<typename Functor>
-	static inline	
-	pointer create(Functor, std::ptrdiff_t);
+        static inline	
+        pointer create(Functor, std::ptrdiff_t);
 
     void bind_args(arg_slot_type* arg) {
       m_arg = arg;
@@ -92,7 +92,7 @@
       *m_result = res;
     }
 
-    // Another level of indirecition is needed to handle
+    // Another level of indirection is needed to handle
     // yield_to correctly.
     void bind_result_pointer(result_slot_type** resp) {
       m_result = resp;
@@ -141,26 +141,25 @@
     typedef coroutine_impl<CoroutineType, ContextImpl> super_type;
 
     typedef FunctorType functor_type;
-	coroutine_impl_wrapper(functor_type f, std::ptrdiff_t stack_size) :
-
-		super_type(this, stack_size),
+        coroutine_impl_wrapper(functor_type f, std::ptrdiff_t stack_size) :
+                super_type(this, stack_size),
       m_fun(f){}
 
     void operator()() {
       typedef typename super_type::context_exit_status
-	context_exit_status;
+        context_exit_status;
       context_exit_status status = super_type::ctx_exited_return;
       std::type_info const* tinfo = 0;
       try {
-	this->check_exit_state();
-	do_call<result_type>();
+        this->check_exit_state();
+        do_call<result_type>();
       } catch (const exit_exception&) {
-	status = super_type::ctx_exited_exit;
+        status = super_type::ctx_exited_exit;
       } catch (std::exception const& e) {
-	status = super_type::ctx_exited_abnormally;
-	tinfo = &typeid(e);
+        status = super_type::ctx_exited_abnormally;
+        tinfo = &typeid(e);
       } catch (...) {
-	status = super_type::ctx_exited_abnormally;
+        status = super_type::ctx_exited_abnormally;
       }
       this->do_return(status, tinfo);	  
     }
@@ -178,16 +177,16 @@
     do_call(dummy<0> = 0) {
       BOOST_ASSERT(this->count() > 0);
       typedef BOOST_DEDUCED_TYPENAME
-	coroutine_type::self self_type;
+        coroutine_type::self self_type;
       boost::optional<self_type> self (coroutine_accessor::in_place(this));
       detail::unpack_ex
-	(m_fun, 
-	 *self, 
-	 *this->args(), 
-	 detail::trait_tag<typename coroutine_type::arg_slot_traits>());
+        (m_fun, 
+         *self, 
+         *this->args(), 
+         detail::trait_tag<typename coroutine_type::arg_slot_traits>());
 
       typedef BOOST_DEDUCED_TYPENAME coroutine_type::result_slot_type 
-	result_slot_type;
+        result_slot_type;
 
       // In this particulare case result_slot_type is guaranteed to be
       // default constructible.
@@ -207,13 +206,13 @@
 
       typedef BOOST_DEDUCED_TYPENAME coroutine_type::arg_slot_traits traits;
       typedef BOOST_DEDUCED_TYPENAME coroutine_type::result_slot_type 
-	result_slot_type;
-	  
+        result_slot_type;
+          
       this->m_result_last = boost::in_place(result_slot_type(detail::unpack_ex
-			   (m_fun, 
-			    *self, 
-			    *this->args(), 
-			    detail::trait_tag<traits>())));      
+                           (m_fun, 
+                            *self, 
+                            *this->args(), 
+                            detail::trait_tag<traits>())));      
       
       this->bind_result(&*this->m_result_last);
     }

Modified: sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/default_context_impl.hpp
==============================================================================
--- sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/default_context_impl.hpp	(original)
+++ sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/default_context_impl.hpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -61,7 +61,7 @@
      context_impl_base must have conform to the ContextImplBase concept:
        
      - DefaultConstructible. A default constructed ContextImplBase is in
-       an unitialized state. 
+       an initialized state. 
        A ContextImpl is an initialized ContextImplBase.
 
      - ContextImplBase is Copyable. A copy of a ContextImplBase holds
@@ -81,33 +81,48 @@
        Postconditions:
        The current context is saved in the 'from' context, and the
        'to' context is restored. 
-       It is undefined behaviour if the 'to' argument is an invalid 
-       (uninitialized) swapcontext.
+       It is undefined behavior if the 'to' argument is an invalid 
+       (uninitialized) swap context.
            
      A ContextImplBase is meant to be used when an empty temporary
      context is needed to store the current context before
      restoring a ContextImpl and no current context is
      available. It could be possible to simply have ContextImpl
-     default constructible, but on destruciton it would need to
+     default constructible, but on destruction it would need to
      check if a stack has been allocated and would slow down the
-     fast invcation path. Also a stackful context could not be
-     make copiable.
+     fast invocation path. Also a stack-full context could not be
+     make copyable.
 */
 
 #if defined(__linux) || defined(linux) || defined(__linux__)
 
+#if defined(__x86_64__)
+// 64 bit systems, use appropriate context switching
+
+#include <boost/coroutine/detail/context_linux64.hpp>
+namespace boost { namespace coroutines { namespace detail {
+  typedef oslinux64::context_impl default_context_impl;
+} } }
+
+#else
+// use 32 bit context switching
+
 #include <boost/coroutine/detail/context_linux.hpp>
 namespace boost { namespace coroutines { namespace detail {
   typedef oslinux::context_impl default_context_impl;
 } } }
 
+#endif
+
 #elif defined(_POSIX_VERSION)
 
 #include <boost/coroutine/detail/context_posix.hpp>
 namespace boost { namespace coroutines { namespace detail {
   typedef posix::context_impl default_context_impl;
 } } }
+
 #elif defined(BOOST_WINDOWS)
+
 #include <boost/coroutine/detail/context_windows.hpp>
 namespace boost { namespace coroutines { namespace detail {
   typedef windows::context_impl default_context_impl;

Modified: sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/posix_utility.hpp
==============================================================================
--- sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/posix_utility.hpp	(original)
+++ sandbox/SOC/2006/coroutine/trunk/boost/coroutine/detail/posix_utility.hpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -58,9 +58,9 @@
    * Better implementations are possible using
    * mmap (might be required on some systems) and/or
    * using a pooling allocator.
-   * NOTE: the SuSv3 documentation explictly allows
+   * NOTE: the SuSv3 documentation explicitly allows
    * the use of malloc to allocate stacks for makectx.
-   * We use free for guaranteed alignment.
+   * We use new/delete for guaranteed alignment.
    */
   inline
   void* alloc_stack(std::size_t size) {

Modified: sandbox/SOC/2006/coroutine/trunk/boost/coroutine/shared_coroutine.hpp
==============================================================================
--- sandbox/SOC/2006/coroutine/trunk/boost/coroutine/shared_coroutine.hpp	(original)
+++ sandbox/SOC/2006/coroutine/trunk/boost/coroutine/shared_coroutine.hpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -31,7 +31,7 @@
 #include <boost/coroutine/coroutine.hpp>
 namespace boost { namespace coroutines {
   // This class is a workaround for the widespread lack of move
-  // semantics support. It is a refrence counted wrapper around 
+  // semantics support. It is a reference counted wrapper around 
   // the coroutine object.
   // FIXME: ATM a shared_coroutine is-a coroutine. This is to avoid
   // inheriting privately and cluttering the code with lots of using

Modified: sandbox/SOC/2006/coroutine/trunk/libs/coroutine/src/swapcontext.cpp
==============================================================================
--- sandbox/SOC/2006/coroutine/trunk/libs/coroutine/src/swapcontext.cpp	(original)
+++ sandbox/SOC/2006/coroutine/trunk/libs/coroutine/src/swapcontext.cpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -1,95 +1,18 @@
-//  Copyright (c) 2006, Giovanni P. Deretta
-//
-//  This code may be used under either of the following two licences:
-//
-//  Permission is hereby granted, free of charge, to any person obtaining a copy 
-//  of this software and associated documentation files (the "Software"), to deal 
-//  in the Software without restriction, including without limitation the rights 
-//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
-//  copies of the Software, and to permit persons to whom the Software is 
-//  furnished to do so, subject to the following conditions:
-//
-//  The above copyright notice and this permission notice shall be included in 
-//  all copies or substantial portions of the Software.
-//
-//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
-//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
-//  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
-//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
-//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
-//  THE SOFTWARE. OF SUCH DAMAGE.
-//
-//  Or:
+//  Copyright (c) 2007 Hartmut Kaiser
 //
 //  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(i386)
-#error This file is for x86 CPUs only.
-#endif
-
 #if !defined(__GNUC__)
-#error This file requires gcc.
+#error This file requires compilation using gcc.
 #endif
 
-/*
- * This file should really be a plain assembler file.
- * Unfortunately Boost.Build v2 doesn't handle asm files (yet).
- * For now resort to inline asm.
- */
-
-
-/* 
-   EAX is &from.sp	
-   EDX is to.sp
-   This is the simplest version of swapcontext
-   It saves registers on the old stack,
-   saves the old stack pointer, 
-   load the new stack pointer,
-   pop registers from the new stack
-   and returns to new caller.
-   EAX is simpy passed to the function it returns to.
-   The first time EAX is the first parameter of the trampoline.
-   Otherwise it is simply discarded.
-   NOTE: This function should work on any IA32 CPU.
-   NOTE: The biggest penality is the last jump that
-   will be always mispredicted (~50 cycles on P4).
-   We try to make its address available as soon as possible
-   to try to reduce the penality. Doing a ret instead of a 
-   'add $4, %esp'
-   'jmp *%ecx'
-   really kills performance.
-   NOTE: popl is slightly better than mov+add to pop registers
-   so is pushl rather than mov+sub.
-   */
-#define BOOST_COROUTINE_swapcontext(name) \
-asm volatile (                            \
-".text \n\t"                              \
-".global " #name "\n\t"                   \
-".type " #name "@function\n\t"            \
-".align 16\n\t"                           \
-#name":\n\t"                              \
-"movl  16(%edx), %ecx\n\t"                \
-"pushl %ebp\n\t"                          \
-"pushl %ebx\n\t"                          \
-"pushl %esi\n\t"                          \
-"pushl %edi\n\t"                          \
-"movl  %esp, (%eax)\n\t"                  \
-"movl  %edx, %esp\n\r"                    \
-"popl  %edi\n\t"                          \
-"popl  %esi\n\t"                          \
-"popl  %ebx\n\t"                          \
-"popl  %ebp\n\t"                          \
-"add   $4, %esp\n\t"                      \
-"jmp   *%ecx\n\t"                         \
-"ud2\n\t")                                \
-/**/
-
-BOOST_COROUTINE_swapcontext(swapcontext_stack);
-BOOST_COROUTINE_swapcontext(swapcontext_stack2);
-BOOST_COROUTINE_swapcontext(swapcontext_stack3);
+#if defined(__i386__)
+#include "swapcontext32.cpp"
+#elif defined(__x86_64__)
+#include "swapcontext64.cpp"
+#else
+#error Undefined platform (should be __386__ or __x86_64__)
+#endif
 
-#undef BOOST_COROUTINE_swapcontext

Added: sandbox/SOC/2006/coroutine/trunk/libs/coroutine/src/swapcontext32.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2006/coroutine/trunk/libs/coroutine/src/swapcontext32.cpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -0,0 +1,95 @@
+//  Copyright (c) 2006, Giovanni P. Deretta
+//
+//  This code may be used under either of the following two licences:
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy 
+//  of this software and associated documentation files (the "Software"), to deal 
+//  in the Software without restriction, including without limitation the rights 
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+//  copies of the Software, and to permit persons to whom the Software is 
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in 
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+//  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
+//  THE SOFTWARE. OF SUCH DAMAGE.
+//
+//  Or:
+//
+//  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(i386)
+#error This file is for x86 CPUs only.
+#endif
+
+#if !defined(__GNUC__)
+#error This file requires gcc.
+#endif
+
+/*
+ * This file should really be a plain assembler file.
+ * Unfortunately Boost.Build v2 doesn't handle asm files (yet).
+ * For now resort to inline asm.
+ */
+
+
+/* 
+   EAX is &from.sp	
+   EDX is to.sp
+   This is the simplest version of swapcontext
+   It saves registers on the old stack,
+   saves the old stack pointer, 
+   load the new stack pointer,
+   pop registers from the new stack
+   and returns to new caller.
+   EAX is simpy passed to the function it returns to.
+   The first time EAX is the first parameter of the trampoline.
+   Otherwise it is simply discarded.
+   NOTE: This function should work on any IA32 CPU.
+   NOTE: The biggest penality is the last jump that
+   will be always mispredicted (~50 cycles on P4).
+   We try to make its address available as soon as possible
+   to try to reduce the penality. Doing a ret instead of a 
+   'add $4, %esp'
+   'jmp *%ecx'
+   really kills performance.
+   NOTE: popl is slightly better than mov+add to pop registers
+   so is pushl rather than mov+sub.
+   */
+#define BOOST_COROUTINE_swapcontext(name) \
+asm volatile (                            \
+".text \n\t"                              \
+".global " #name "\n\t"                   \
+".type " #name "@function\n\t"            \
+".align 16\n\t"                           \
+#name":\n\t"                              \
+"movl  16(%edx), %ecx\n\t"                \
+"pushl %ebp\n\t"                          \
+"pushl %ebx\n\t"                          \
+"pushl %esi\n\t"                          \
+"pushl %edi\n\t"                          \
+"movl  %esp, (%eax)\n\t"                  \
+"movl  %edx, %esp\n\r"                    \
+"popl  %edi\n\t"                          \
+"popl  %esi\n\t"                          \
+"popl  %ebx\n\t"                          \
+"popl  %ebp\n\t"                          \
+"add   $4, %esp\n\t"                      \
+"jmp   *%ecx\n\t"                         \
+"ud2\n\t")                                \
+/**/
+
+BOOST_COROUTINE_swapcontext(swapcontext_stack);
+BOOST_COROUTINE_swapcontext(swapcontext_stack2);
+BOOST_COROUTINE_swapcontext(swapcontext_stack3);
+
+#undef BOOST_COROUTINE_swapcontext

Added: sandbox/SOC/2006/coroutine/trunk/libs/coroutine/src/swapcontext64.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2006/coroutine/trunk/libs/coroutine/src/swapcontext64.cpp	2007-11-28 12:20:20 EST (Wed, 28 Nov 2007)
@@ -0,0 +1,79 @@
+//  Copyright (c) 2007 Robert Perricone
+//  Copyright (c) 2007 Hartmut Kaiser
+//
+//  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(__x86_64__)
+#error This file is for x86 CPUs only.
+#endif
+
+#if !defined(__GNUC__)
+#error This file requires compilation with gcc.
+#endif
+
+/*
+ *  This file should really be a plain assembler file.
+ *  Unfortunately Boost.Build v2 doesn't handle asm files (yet).
+ *  For now resort to inline asm.
+ */
+
+//     RDI is &from.sp	
+//     RSI is to.sp
+//
+//     This is the simplest version of swapcontext
+//     It saves registers on the old stack, saves the old stack pointer,
+//     load the new stack pointer, pop registers from the new stack
+//     and returns to new caller.
+//
+//     RDI is set to be the parameter for the function to be called.
+//     The first time RDI is the first parameter of the trampoline.
+//     Otherwise it is simply discarded.
+//
+//     NOTE: This function should work on any IA64 CPU.
+//     NOTE: The biggest penalty is the last jump that
+//           will be always mis-predicted (~50 cycles on P4).
+//
+//     We try to make its address available as soon as possible
+//     to try to reduce the penalty. Doing a return instead of a
+//
+//        'add $8, %esp'
+//        'jmp *%ecx'
+//
+//     really kills performance.
+//
+//     NOTE: popl is slightly better than mov+add to pop registers
+//           so is pushl rather than mov+sub.
+
+#define BOOST_COROUTINE_SWAPCONTEXT(name)                                     \
+    asm volatile (                                                            \
+        ".text \n\t"                                                          \
+        ".global " #name "\n\t"                                               \
+        ".type " #name ", @function\n\t"                                      \
+        ".align 16\n"                                                         \
+    #name ":\n\t"                                                             \
+        "movq  32(%rsi), %rcx\n\t"                                            \
+        "pushq %rbp\n\t"                                                      \
+        "pushq %rbx\n\t"                                                      \
+        "pushq %rax\n\t"                                                      \
+        "pushq %rdx\n\t"                                                      \
+        "movq  %rsp, (%rdi)\n\t"                                              \
+        "movq  %rsi, %rsp\n\t"                                                \
+        "popq  %rdx\n\t"                                                      \
+        "popq  %rax\n\t"                                                      \
+        "popq  %rbx\n\t"                                                      \
+        "popq  %rbp\n\t"                                                      \
+        "movq 48(%rsi), %rdi\n\t"                                             \
+        "add   $8, %rsp\n\t"                                                  \
+        "jmp   *%rcx\n\t"                                                     \
+        "ud2\n\t"                                                             \
+    )                                                                         \
+/**/
+
+BOOST_COROUTINE_SWAPCONTEXT(swapcontext_stack);
+BOOST_COROUTINE_SWAPCONTEXT(swapcontext_stack2);
+BOOST_COROUTINE_SWAPCONTEXT(swapcontext_stack3);
+
+#undef BOOST_COROUTINE_SWAPCONTEXT
+