diff --git a/include/boost/fiber/detail/scheduler.hpp b/include/boost/fiber/detail/scheduler.hpp
index c84bc53b..8f12ce7b 100644
--- a/include/boost/fiber/detail/scheduler.hpp
+++ b/include/boost/fiber/detail/scheduler.hpp
@@ -40,13 +40,13 @@ private:
 
 #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__) || \
     (defined(__ICC) && defined(BOOST_WINDOWS))
-    static __declspec(thread) T         *   t_;
+    static volatile __declspec(thread) T         *   t_;
 #elif defined(__APPLE__) && defined(BOOST_HAS_PTHREADS)
-    static detail::thread_local_ptr< T >    t_;
+    static volatile detail::thread_local_ptr< T >    t_;
 #else
-    static __thread T                   *   t_;
+    static volatile __thread T                   *   t_;
 #endif
-    cleanup_function                        cf_;
+    cleanup_function                                 cf_;
 
 public:
     thread_local_ptr( cleanup_function cf) BOOST_NOEXCEPT :
@@ -55,7 +55,7 @@ public:
 
     BOOST_EXPLICIT_OPERATOR_BOOL();
 
-    T * get() const BOOST_NOEXCEPT
+    volatile T * get() const BOOST_NOEXCEPT volatile
     { return t_; }
 
     bool operator!() const BOOST_NOEXCEPT
@@ -67,21 +67,21 @@ public:
     bool operator!=( thread_local_ptr const& other) BOOST_NOEXCEPT
     { return ! ( * this == other); }
 
-    void reset( T * t) BOOST_NOEXCEPT
+    void reset( T * t) BOOST_NOEXCEPT volatile
     { t_ = t; }
 };
 
 class scheduler : private noncopyable
 {
 private:
-    static thread_local_ptr< fiber_manager > instance_;
+    static volatile thread_local_ptr< fiber_manager > instance_;
 
 public:
     template< typename F >
     static worker_fiber * extract( F const& f) BOOST_NOEXCEPT
     { return f.impl_; }
 
-    static fiber_manager * instance()
+    static volatile fiber_manager * instance()
     {
         if ( ! instance_.get() )
             instance_.reset( new fiber_manager() );
diff --git a/include/boost/fiber/fiber_manager.hpp b/include/boost/fiber/fiber_manager.hpp
index 0a6c134a..595a2c2e 100644
--- a/include/boost/fiber/fiber_manager.hpp
+++ b/include/boost/fiber/fiber_manager.hpp
@@ -52,27 +52,27 @@ struct fiber_manager : private noncopyable
 
     scoped_ptr< sched_algorithm >   def_algo_;
     sched_algorithm             *   sched_algo_;
-    wqueue_t                        wqueue_;
+    volatile wqueue_t                        wqueue_;
 
     clock_type::duration            wait_interval_;
     detail::worker_fiber        *   active_fiber_;
 };
 
-void fm_resume_( fiber_manager *, detail:: worker_fiber *);
+void fm_resume_( volatile fiber_manager *, detail:: worker_fiber *);
 
 inline
-void fm_set_sched_algo( fiber_manager * fm, sched_algorithm * algo)
+void fm_set_sched_algo( volatile fiber_manager * fm, sched_algorithm * algo)
 {
     BOOST_ASSERT( fm);
     
     fm->sched_algo_ = algo;
-    fm->def_algo_.reset();
+    //fm->def_algo_.reset();
 }
 
-void fm_spawn( fiber_manager *, detail::worker_fiber *);
+void fm_spawn( volatile fiber_manager *, detail::worker_fiber *);
 
 inline
-void fm_priority( fiber_manager * fm, detail::worker_fiber * f,
+void fm_priority( volatile fiber_manager * fm, detail::worker_fiber * f,
                   int prio) BOOST_NOEXCEPT
 {
     BOOST_ASSERT( fm);
@@ -81,7 +81,7 @@ void fm_priority( fiber_manager * fm, detail::worker_fiber * f,
 }
 
 template< typename Rep, typename Period >
-void fm_wait_interval( fiber_manager * fm,
+void fm_wait_interval( volatile fiber_manager * fm,
                        chrono::duration< Rep, Period > const& wait_interval) BOOST_NOEXCEPT
 {
     BOOST_ASSERT( fm);
@@ -90,31 +90,31 @@ void fm_wait_interval( fiber_manager * fm,
 }
 
 template< typename Rep, typename Period >
-chrono::duration< Rep, Period > fm_wait_interval( fiber_manager * fm) BOOST_NOEXCEPT
+chrono::duration< Rep, Period > fm_wait_interval( volatile fiber_manager * fm) BOOST_NOEXCEPT
 {
     BOOST_ASSERT( fm);
     
     return fm->wait_interval_;
 }
 
-void fm_join( fiber_manager *, detail::worker_fiber *);
+void fm_join( volatile fiber_manager *, detail::worker_fiber *);
 
 inline
-detail::worker_fiber * fm_active( fiber_manager * fm) BOOST_NOEXCEPT
+detail::worker_fiber * fm_active( volatile fiber_manager * fm) BOOST_NOEXCEPT
 {
     BOOST_ASSERT( fm);
     
     return fm->active_fiber_;
 }
 
-void fm_run( fiber_manager *);
+void fm_run( volatile fiber_manager *);
 
-void fm_wait( fiber_manager *, unique_lock< detail::spinlock > &);
-bool fm_wait_until( fiber_manager *,
+void fm_wait( volatile fiber_manager *, unique_lock< detail::spinlock > &);
+bool fm_wait_until( volatile fiber_manager *,
                     clock_type::time_point const&,
                     unique_lock< detail::spinlock > &);
 template< typename Rep, typename Period >
-bool fm_wait_for( fiber_manager * fm,
+bool fm_wait_for( volatile fiber_manager * fm,
                   chrono::duration< Rep, Period > const& timeout_duration,
                   unique_lock< detail::spinlock > & lk)
 {
@@ -123,11 +123,11 @@ bool fm_wait_for( fiber_manager * fm,
     return wait_until( fm, clock_type::now() + timeout_duration, lk);
 }
 
-void fm_yield( fiber_manager *);
+void fm_yield( volatile fiber_manager *);
 
-clock_type::time_point fm_next_wakeup( fiber_manager *);
+clock_type::time_point fm_next_wakeup( volatile fiber_manager *);
 
-void fm_migrate( fiber_manager *, detail::worker_fiber *);
+void fm_migrate( volatile fiber_manager *, detail::worker_fiber *);
 
 }}
 
diff --git a/src/detail/scheduler.cpp b/src/detail/scheduler.cpp
index 9c505e47..96af8322 100644
--- a/src/detail/scheduler.cpp
+++ b/src/detail/scheduler.cpp
@@ -20,16 +20,16 @@ static void deleter_fn( fiber_manager * mgr) { delete mgr; }
 #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__) || \
     (defined(__ICC) && defined(BOOST_WINDOWS))
 template< typename T >
-__declspec(thread) T * thread_local_ptr< T >::t_ = 0;
+volatile __declspec(thread) T * thread_local_ptr< T >::t_ = 0;
 #elif defined(__APPLE__) && defined(BOOST_HAS_PTHREADS)
 template< typename T >
-detail::thread_local_ptr< T > thread_local_ptr< T >::t_;
+volatile detail::thread_local_ptr< T > thread_local_ptr< T >::t_;
 #else
 template< typename T >
-__thread T * thread_local_ptr< T >::t_ = 0;
+volatile __thread T * thread_local_ptr< T >::t_ = 0;
 #endif
 
-thread_local_ptr< fiber_manager > scheduler::instance_( deleter_fn);
+volatile thread_local_ptr< fiber_manager > scheduler::instance_( deleter_fn);
 
 void
 scheduler::replace( sched_algorithm * other)
diff --git a/src/fiber_manager.cpp b/src/fiber_manager.cpp
index ecba65d9..add0599e 100644
--- a/src/fiber_manager.cpp
+++ b/src/fiber_manager.cpp
@@ -64,7 +64,7 @@ fiber_manager::~fiber_manager() BOOST_NOEXCEPT
         fm_run( this);
 }
 
-void fm_resume_( fiber_manager * fm, detail::worker_fiber * f)
+void fm_resume_( volatile fiber_manager * fm, detail::worker_fiber * f)
 {
     BOOST_ASSERT( fm);
     BOOST_ASSERT( f);
@@ -91,7 +91,7 @@ void fm_resume_( fiber_manager * fm, detail::worker_fiber * f)
     }
 }
 
-clock_type::time_point fm_next_wakeup( fiber_manager * fm)
+clock_type::time_point fm_next_wakeup( volatile fiber_manager * fm)
 {
     BOOST_ASSERT( fm);
 
@@ -106,7 +106,7 @@ clock_type::time_point fm_next_wakeup( fiber_manager * fm)
     }
 }
 
-void fm_spawn( fiber_manager * fm, detail::worker_fiber * f)
+void fm_spawn( volatile fiber_manager * fm, detail::worker_fiber * f)
 {
     BOOST_ASSERT( fm);
     BOOST_ASSERT( f);
@@ -115,7 +115,7 @@ void fm_spawn( fiber_manager * fm, detail::worker_fiber * f)
     fm->sched_algo_->awakened( f);
 }
 
-void fm_run( fiber_manager * fm)
+void fm_run( volatile fiber_manager * fm)
 {
     BOOST_ASSERT( fm);
 
@@ -150,14 +150,14 @@ void fm_run( fiber_manager * fm)
     }
 }
 
-void fm_wait( fiber_manager * fm, unique_lock< detail::spinlock > & lk)
+void fm_wait( volatile fiber_manager * fm, unique_lock< detail::spinlock > & lk)
 {
     BOOST_ASSERT( fm);
 
     fm_wait_until( fm, clock_type::time_point( (clock_type::duration::max)() ), lk);
 }
 
-bool fm_wait_until( fiber_manager * fm,
+bool fm_wait_until( volatile fiber_manager * fm,
                     clock_type::time_point const& timeout_time,
                     unique_lock< detail::spinlock > & lk)
 {
@@ -181,7 +181,7 @@ bool fm_wait_until( fiber_manager * fm,
     return clock_type::now() < timeout_time;
 }
 
-void fm_yield( fiber_manager * fm)
+void fm_yield( volatile fiber_manager * fm)
 {
     BOOST_ASSERT( fm);
     BOOST_ASSERT( fm->active_fiber_);
@@ -195,7 +195,7 @@ void fm_yield( fiber_manager * fm)
     fm_run( fm);
 }
 
-void fm_join( fiber_manager * fm, detail::worker_fiber * f)
+void fm_join( volatile fiber_manager * fm, detail::worker_fiber * f)
 {
     BOOST_ASSERT( fm);
     BOOST_ASSERT( f);
@@ -227,7 +227,7 @@ void fm_join( fiber_manager * fm, detail::worker_fiber * f)
     BOOST_ASSERT( f->is_terminated() );
 }
 
-void fm_migrate( fiber_manager * fm, detail::worker_fiber * f)
+void fm_migrate( volatile fiber_manager * fm, detail::worker_fiber * f)
 {
     BOOST_ASSERT( fm);
     BOOST_ASSERT( f);