Merge branch 'develop'

2026-02-03 09:42:16 +00:00 · 2017-03-03 07:28:59 +01:00 · 2017-02-25 13:57:19 +01:00 · 2017-02-19 11:27:10 +01:00 · 2016-11-06 16:16:03 +01:00 · 2016-11-05 23:39:19 +01:00
49 changed files with 605 additions and 1177 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,365 +0,0 @@
-# Copyright 2016, 2017 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-language: cpp
-
-sudo: false
-
-python: "2.7"
-
-os:
-  - linux
-  - osx
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-#    - os: linux
-#      compiler: g++-4.7
-#      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-4.7
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-4.8
-#      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-4.8
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-4.9
-#      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-4.9
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-5
-#      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++98
-#      addons:
-#        apt:
-#          packages:
-#            - g++-5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-5
-#      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-5
-#      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
-#      addons:
-#        apt:
-#          packages:
-#            - g++-5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-5
-#      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++1z
-#      addons:
-#        apt:
-#          packages:
-#            - g++-5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-6
-#      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++98
-#      addons:
-#        apt:
-#          packages:
-#            - g++-6
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-6
-#      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-6
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-6
-#      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
-#      addons:
-#        apt:
-#          packages:
-#            - g++-6
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-6
-#      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
-#      addons:
-#        apt:
-#          packages:
-#            - g++-6
-#          sources:
-#            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++98
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++1z
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-#    - os: linux
-#      compiler: clang++-3.5
-#      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.5#
-#
-#    - os: linux
-#      compiler: clang++-3.6
-#      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.6
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.6
-#
-#    - os: linux
-#      compiler: clang++-3.7
-#      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.7
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.7
-#
-#    - os: linux
-#      compiler: clang++-3.8
-#      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.8
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.8
-#
-#    - os: linux
-#      compiler: clang++-3.8
-#      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.8
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.8
-#
-#    - os: linux
-#      compiler: clang++-3.8
-#      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.8
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.8
-#
-#    - os: linux
-#      compiler: clang++-3.9
-#      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.9
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.9
-#
-#    - os: linux
-#      compiler: clang++-3.9
-#      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++14
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.9
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.9
-#
-#    - os: linux
-#      compiler: clang++-3.9
-#      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++1z
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.9
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.9
-#
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++98
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++1z
-      addons:
-        apt:
-          packages:
-            - clang-4.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++98
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++1z
-
-install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
-  - cd ..
-  - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - mkdir -p libs/thread
-  - cp -r $TRAVIS_BUILD_DIR/* libs/thread
-  - python tools/boostdep/depinst/depinst.py thread
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - |-
-    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
-  - ./b2 -j3 libs/thread/test toolset=$TOOLSET
-
-notifications:
-  email:
-    on_success: always
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,41 +0,0 @@
-# Copyright 2016, 2017 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-12.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-14.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-
-install:
-  - set BOOST_BRANCH=develop
-  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
-  - cd ..
-  - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/build
-  - git submodule update --init libs/config
-  - git submodule update --init tools/boostdep
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\thread\
-  - python tools/boostdep/depinst/depinst.py thread
-  - cmd /c bootstrap
-  - b2 headers
-
-build: off
-
-test_script:
-  - b2 libs/mp11/test toolset=%TOOLSET%
--- a/doc/changes.qbk
+++ b/doc/changes.qbk
@@ -1,6 +1,6 @@
 [/
  (C) Copyright 2007-11 Anthony Williams.
-  (C) Copyright 2011-17 Vicente J. Botet Escriba.
+  (C) Copyright 2011-16 Vicente J. Botet Escriba.
  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).
@@ -8,49 +8,6 @@

 [section:changes History]

-[heading Version 4.8.0 - boost 1.66]
-
-[*Know Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
-
-* [@http://svn.boost.org/trac/boost/ticket/10964 #10964] future<future<T>>::unwrap().then() Deadlocks
-
-
-Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
-
-Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread master regression test] to see the last regression test snapshot.
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/12949 #12949] using sleep_for in a thread context without including boost/thread/thread.hpp yields incorrect behaviour when BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC is defined
-* [@http://svn.boost.org/trac/boost/ticket/13019 #13019] ABI compatibility for BOOST_THREAD_PROVIDES_INTERRUPTIONS incomplete
-* [@http://svn.boost.org/trac/boost/ticket/13163 #13163] boost::detail::heap_new does not have a variadic variant
-
-* [@https://github.com/boostorg/thread/issues/130 #130] windows: Bug in boost::condition_variable on Windows
-
-[heading Version 4.7.4 - boost 1.65]
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/6787 #6787] boost::thread::sleep() hangs if system time is rolled back
-* [@http://svn.boost.org/trac/boost/ticket/12519 #12519] boost::thread::try_join_for does not return after timeout
-* [@http://svn.boost.org/trac/boost/ticket/12874 #12874] future<> extension constructor must be under BOOST_THREAD_PROVIDES_FUTURE_UNWRAP
-* [@http://svn.boost.org/trac/boost/ticket/12888 #12888] Linking with boost thread does not work on mingw/gcc 4.4
-* [@http://svn.boost.org/trac/boost/ticket/12958 #12958] sync_bounded_queue::wait_pull_front( lve ) might throw
-* [@http://svn.boost.org/trac/boost/ticket/13077 #13077] Linking to static 64bit libboost_thread fails DLL initialization
-* [@http://svn.boost.org/trac/boost/ticket/13155 #13155] log doesn't build on a system with pthreads
-
-* [@https://github.com/boostorg/thread/issues/121 #121] on_tls_prepare is broken under VS2017
-
-[heading Version 4.7.3 - boost 1.64]
-
-[*Fixed Bugs:]
-
-* [@https://github.com/boostorg/thread/issues/113 #113] Add a Thread template on all the scoped thread and thread guard classes
-* [@https://github.com/boostorg/thread/issues/117 #117] loop_executor should block on it's work_queue instead of polling
-* [@https://github.com/boostorg/thread/issues/119 #119] basic_condition_variable::relocker::~relocker can throw an exception
-
 [heading Version 4.7.2 - boost 1.63]

 [*Fixed Bugs:]
@@ -70,7 +27,7 @@ Please define BOOST_THREAD_PATCH to apply the patch that could unfortunately res

 Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.

-Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread master regression test] to see the last regression test snapshot.
+Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread trunk regression test] to see the last regression test snapshot.


 [*Fixed Bugs:]
--- a/doc/future_ref.qbk
+++ b/doc/future_ref.qbk
@@ -358,7 +358,7 @@ The object's `name` virtual function returns a pointer to the string "future".]]
      template<typename F>
      __unique_future__<typename boost::result_of<F(__unique_future__)>::type> 
      then(F&& func); // EXTENSION
-      template<typename Ex, typename F>
+      template<typename S, typename F>
      __unique_future__<typename boost::result_of<F(__unique_future__)>::type> 
      then(Ex& executor, F&& func); // EXTENSION
      template<typename F>
@@ -898,7 +898,7 @@ associated with `*this` is ready for retrieval, __waiting__ otherwise.]]
      template<typename F>
      __unique_future__<typename boost::result_of<F(__unique_future__)>::type> 
      then(F&& func); // EXTENSION
-      template<typename Ex, typename F>
+      template<typename S, typename F>
      __unique_future__<typename boost::result_of<F(__unique_future__)>::type> 
      then(Ex& executor, F&& func); // EXTENSION
      template<typename F>
@@ -1387,7 +1387,7 @@ associated with `*this` is ready for retrieval, __waiting__ otherwise.]]
      template<typename F>
      __unique_future__<typename boost::result_of<F(shared_future)>::type> 
      then(F&& func) const; // EXTENSION
-      template<typename Ex, typename F>
+      template<typename S, typename F>
      __unique_future__<typename boost::result_of<F(shared_future)>::type> 
      then(Ex& executor, F&& func) const; // EXTENSION
      template<typename F>
--- a/doc/thread.qbk
+++ b/doc/thread.qbk
@@ -8,10 +8,10 @@

 [library Thread
    [quickbook 1.5]
-    [version 4.8.0]
+    [version 4.7.2]
    [authors [Williams, Anthony] [Botet Escriba, Vicente J.]]
    [copyright 2007-11 Anthony Williams]
-    [copyright 2011-17 Vicente J. Botet Escriba]
+    [copyright 2011-16 Vicente J. Botet Escriba]
    [purpose C++ Library for launching threads and synchronizing data between them]
    [category text]
    [license
--- a/example/future_then.cpp
+++ b/example/future_then.cpp
@@ -17,7 +17,6 @@
 #include <boost/thread/future.hpp>
 #include <boost/assert.hpp>
 #include <string>
-#include <iostream>
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION

 int p1()
--- a/example/scoped_thread.cpp
+++ b/example/scoped_thread.cpp
@@ -63,7 +63,6 @@ int main()
    else
      do_something_in_current_thread();
  }
-#if 0
  {
    int some_local_state=0;
    boost::thread t(( func(some_local_state) ));
@@ -73,7 +72,6 @@ int main()

    do_something_in_current_thread();
  }
-#endif
  {
    boost::scoped_thread<> g( &f, 1, 2 );
    do_something_in_current_thread();
--- a/example/std_scoped_thread.cpp
+++ b/example/std_scoped_thread.cpp
@@ -84,7 +84,7 @@ int main()
    else
      do_something_in_current_thread();
  }
-#if 0
+#if ! defined __clang__
  try
  {
    int some_local_state=1;
--- a/include/boost/thread/concurrent_queues/sync_bounded_queue.hpp
+++ b/include/boost/thread/concurrent_queues/sync_bounded_queue.hpp
@@ -127,7 +127,7 @@ namespace concurrent
    inline size_type size(lock_guard<mutex>& lk) const BOOST_NOEXCEPT
    {
      if (full(lk)) return capacity(lk);
-      return ((in_+capacity(lk)-out_) % capacity(lk));
+      return ((out_+capacity(lk)-in_) % capacity(lk));
    }

    inline void throw_if_closed(unique_lock<mutex>&);
@@ -484,9 +484,7 @@ namespace concurrent
  queue_op_status sync_bounded_queue<ValueType>::wait_pull_front(ValueType& elem, unique_lock<mutex>& lk)
  {
      if (empty(lk) && closed(lk)) {return queue_op_status::closed;}
-      bool is_closed = false;
-      wait_until_not_empty(lk, is_closed);
-      if (is_closed) {return queue_op_status::closed;}
+      wait_until_not_empty(lk);
      pull_front(elem, lk);
      return queue_op_status::success;
  }
--- a/include/boost/thread/detail/config.hpp
+++ b/include/boost/thread/detail/config.hpp
@@ -12,19 +12,21 @@
 #include <boost/detail/workaround.hpp>
 #include <boost/thread/detail/platform.hpp>

+//#define BOOST_THREAD_USEFIXES_TIMESPEC
 //#define BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
 //#define BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
 // ATTRIBUTE_MAY_ALIAS

-//#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
-#if !defined(BOOST_NO_MAY_ALIAS)
+#if defined(__GNUC__) && !defined(__INTEL_COMPILER)

-  // GCC since 3.3 and some other compilers have may_alias attribute that helps
-  // to alleviate optimizer issues with regard to violation of the strict aliasing rules.
+  // GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with
+  // regard to violation of the strict aliasing rules.

  #define BOOST_THREAD_DETAIL_USE_ATTRIBUTE_MAY_ALIAS
+  #define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__))
+#else
+  #define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS
 #endif
-#define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS BOOST_MAY_ALIAS


 #if defined BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
--- a/include/boost/thread/detail/thread.hpp
+++ b/include/boost/thread/detail/thread.hpp
@@ -155,15 +155,7 @@ namespace boost
        };
 #endif
    }
-namespace thread_detail {
-#ifdef BOOST_THREAD_USES_CHRONO
-#if defined(BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC)
-        typedef chrono::steady_clock internal_clock_t;
-#else
-        typedef chrono::system_clock internal_clock_t;
-#endif
-#endif
-}
+
    class BOOST_THREAD_DECL thread
    {
    public:
@@ -299,7 +291,7 @@ namespace thread_detail {
        template <class F>
        explicit thread(F f
        , typename disable_if_c<
-        boost::thread_detail::is_rv<F>::value // todo as a thread_detail::is_rv
+        boost::thread_detail::is_rv<F>::value // todo ass a thread_detail::is_rv
        //boost::thread_detail::is_convertible<F&,BOOST_THREAD_RV_REF(F)>::value
            //|| is_same<typename decay<F>::type, thread>::value
           , dummy* >::type=0
@@ -491,13 +483,19 @@ namespace thread_detail {
        }
 #endif

+#if defined(BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC) && defined(BOOST_THREAD_USEFIXES_TIMESPEC)
+        typedef chrono::steady_clock my_clock_t;
+#else
+        typedef chrono::system_clock my_clock_t;
+#endif
+
        template <class Clock, class Duration>
        bool try_join_until(const chrono::time_point<Clock, Duration>& t)
        {
          using namespace chrono;
          bool joined= false;
          do {
-            thread_detail::internal_clock_t::time_point     s_now = thread_detail::internal_clock_t::now();
+            my_clock_t::time_point     s_now = my_clock_t::now();
            typename Clock::duration   d = ceil<nanoseconds>(t-Clock::now());
            if (d <= Clock::duration::zero()) return false; // in case the Clock::time_point t is already reached
            joined = try_join_until(s_now + d);
@@ -505,10 +503,10 @@ namespace thread_detail {
          return true;
        }
        template <class Duration>
-        bool try_join_until(const chrono::time_point<thread_detail::internal_clock_t, Duration>& t)
+        bool try_join_until(const chrono::time_point<my_clock_t, Duration>& t)
        {
          using namespace chrono;
-          typedef time_point<thread_detail::internal_clock_t, nanoseconds> nano_sys_tmpt;
+          typedef time_point<my_clock_t, nanoseconds> nano_sys_tmpt;
          return try_join_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
        }
 #endif
@@ -523,7 +521,7 @@ namespace thread_detail {
        //}

 #ifdef BOOST_THREAD_USES_CHRONO
-        bool try_join_until(const chrono::time_point<thread_detail::internal_clock_t, chrono::nanoseconds>& tp)
+        bool try_join_until(const chrono::time_point<my_clock_t, chrono::nanoseconds>& tp)
        {
          chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-chrono::system_clock::now());
          return do_try_join_until(rel_time.count());
@@ -544,7 +542,7 @@ namespace thread_detail {
        }
 #endif
 #ifdef BOOST_THREAD_USES_CHRONO
-        bool try_join_until(const chrono::time_point<thread_detail::internal_clock_t, chrono::nanoseconds>& tp)
+        bool try_join_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
        {
          using namespace chrono;
          nanoseconds d = tp.time_since_epoch();
--- a/include/boost/thread/executors/basic_thread_pool.hpp
+++ b/include/boost/thread/executors/basic_thread_pool.hpp
@@ -86,18 +86,11 @@ namespace executors
        for(;;)
        {
          work task;
-          try
-          {
-            queue_op_status st = work_queue.wait_pull(task);
-            if (st == queue_op_status::closed) {
-              return;
-            }
-            task();
-          }
-          catch (boost::thread_interrupted&)
-          {
+          queue_op_status st = work_queue.wait_pull(task);
+          if (st == queue_op_status::closed) {
            return;
          }
+          task();
        }
      }
      catch (...)
@@ -241,7 +234,6 @@ namespace executors
    {
      for (unsigned i = 0; i < threads.size(); ++i)
      {
-        threads[i].interrupt();
        threads[i].join();
      }
    }
--- a/include/boost/thread/executors/detail/priority_executor_base.hpp
+++ b/include/boost/thread/executors/detail/priority_executor_base.hpp
@@ -57,16 +57,10 @@ namespace detail
      {
        for(;;)
        {
-          try {
-            work task;
-            queue_op_status st = _workq.wait_pull(task);
-            if (st == queue_op_status::closed) return;
-            task();
-          }
-          catch (boost::thread_interrupted&)
-          {
-            return;
-          }
+          work task;
+          queue_op_status st = _workq.wait_pull(task);
+          if (st == queue_op_status::closed) return;
+          task();
        }
      }
      catch (...)
--- a/include/boost/thread/executors/scheduled_thread_pool.hpp
+++ b/include/boost/thread/executors/scheduled_thread_pool.hpp
@@ -32,7 +32,6 @@ namespace executors
    ~scheduled_thread_pool()
    {
      this->close();
-      _workers.interrupt_all();
      _workers.join_all();
    }

--- a/include/boost/thread/executors/scheduler.hpp
+++ b/include/boost/thread/executors/scheduler.hpp
@@ -231,7 +231,6 @@ namespace boost
      ~scheduler()
      {
        this->close();
-        thr.interrupt();
        thr.join();
      }
      template <class Ex>
--- a/include/boost/thread/executors/scheduling_adaptor.hpp
+++ b/include/boost/thread/executors/scheduling_adaptor.hpp
@@ -31,7 +31,6 @@ namespace executors
    ~scheduling_adpator()
    {
      this->close();
-      _scheduler.interrupt();
      _scheduler.join();
    }

--- a/include/boost/thread/future.hpp
+++ b/include/boost/thread/future.hpp
@@ -299,7 +299,7 @@ namespace boost
                }
                do_continuation(lock);
            }
-            void notify_deferred()
+            void make_ready()
            {
              boost::unique_lock<boost::mutex> lock(this->mutex);
              mark_finished_internal(lock);
@@ -1335,7 +1335,7 @@ namespace boost

        bool valid() const BOOST_NOEXCEPT
        {
-            return future_.get() != 0 && future_->valid();
+            return future_ != 0 && future_->valid();
        }

        void wait() const
@@ -1639,9 +1639,7 @@ namespace boost
        base_type(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other))))
        {
        }
-#if defined BOOST_THREAD_PROVIDES_FUTURE_UNWRAP
        inline explicit BOOST_THREAD_FUTURE(BOOST_THREAD_RV_REF(BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R> >) other); // EXTENSION
-#endif

        explicit BOOST_THREAD_FUTURE(BOOST_THREAD_RV_REF(shared_future<R>) other) :
        base_type(boost::move(static_cast<base_type&>(BOOST_THREAD_RV(other))))
@@ -1682,7 +1680,7 @@ namespace boost
        // retrieving the value
        move_dest_type get()
        {
-            if (this->future_.get() == 0)
+            if (this->future_ == 0)
            {
                boost::throw_exception(future_uninitialized());
            }
@@ -1702,7 +1700,7 @@ namespace boost
        get_or(BOOST_THREAD_RV_REF(R2) v)
        {

-            if (this->future_.get() == 0)
+            if (this->future_ == 0)
            {
                boost::throw_exception(future_uninitialized());
            }
@@ -1728,7 +1726,7 @@ namespace boost
        typename boost::disable_if< is_void<R2>, move_dest_type>::type
        get_or(R2 const& v)  // EXTENSION
        {
-            if (this->future_.get() == 0)
+            if (this->future_ == 0)
            {
                boost::throw_exception(future_uninitialized());
            }
@@ -1943,7 +1941,7 @@ namespace boost
            // retrieving the value
            move_dest_type get()
            {
-                if (this->future_.get() == 0)
+                if (this->future_ == 0)
                {
                    boost::throw_exception(future_uninitialized());
                }
@@ -1959,7 +1957,7 @@ namespace boost
            }
            move_dest_type get_or(BOOST_THREAD_RV_REF(R) v) // EXTENSION
            {
-                if (this->future_.get() == 0)
+                if (this->future_ == 0)
                {
                    boost::throw_exception(future_uninitialized());
                }
@@ -1978,7 +1976,7 @@ namespace boost

            move_dest_type get_or(R const& v) // EXTENSION
            {
-                if (this->future_.get() == 0)
+                if (this->future_ == 0)
                {
                    boost::throw_exception(future_uninitialized());
                }
@@ -4749,7 +4747,7 @@ namespace detail {
  inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type>
  BOOST_THREAD_FUTURE<R>::then(launch policy, BOOST_THREAD_FWD_REF(F) func) {
    typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4813,7 +4811,7 @@ namespace detail {
  inline BOOST_THREAD_FUTURE<typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type>
  BOOST_THREAD_FUTURE<R>::then(Ex& ex, BOOST_THREAD_FWD_REF(F) func) {
    typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4837,7 +4835,7 @@ namespace detail {
    return this->then(this->launch_policy(), boost::forward<F>(func));
 #else
    typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4867,7 +4865,7 @@ namespace detail {
  BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >::then(launch policy, BOOST_THREAD_FWD_REF(F) func) {
    typedef BOOST_THREAD_FUTURE<R2> R;
    typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4941,7 +4939,7 @@ namespace detail {
  BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >::then(Ex& ex, BOOST_THREAD_FWD_REF(F) func) {
    typedef BOOST_THREAD_FUTURE<R2> R;
    typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4967,7 +4965,7 @@ namespace detail {
 #else
    typedef BOOST_THREAD_FUTURE<R2> R;
    typedef typename boost::result_of<F(BOOST_THREAD_FUTURE<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4997,7 +4995,7 @@ namespace detail {
  shared_future<R>::then(launch policy, BOOST_THREAD_FWD_REF(F) func)  const
  {
    typedef typename boost::result_of<F(shared_future<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());

    boost::unique_lock<boost::mutex> lock(this->future_->mutex);
    if (underlying_cast<int>(policy) & int(launch::async)) {
@@ -5066,7 +5064,7 @@ namespace detail {
  shared_future<R>::then(Ex& ex, BOOST_THREAD_FWD_REF(F) func)  const
  {
    typedef typename boost::result_of<F(shared_future<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());

    boost::unique_lock<boost::mutex> lock(this->future_->mutex);
    return BOOST_THREAD_MAKE_RV_REF((boost::detail::make_shared_future_executor_continuation_shared_state<Ex, shared_future<R>, future_type>(ex,
@@ -5087,7 +5085,7 @@ namespace detail {
    return this->then(this->launch_policy(), boost::forward<F>(func));
 #else
    typedef typename boost::result_of<F(shared_future<R>)>::type future_type;
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());

    boost::unique_lock<boost::mutex> lock(this->future_->mutex);
    launch policy = this->launch_policy(lock);
@@ -5259,7 +5257,7 @@ namespace detail
  BOOST_THREAD_FUTURE<R2>
  BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >::unwrap()
  {
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
--- a/include/boost/thread/pthread/condition_variable.hpp
+++ b/include/boost/thread/pthread/condition_variable.hpp
@@ -45,17 +45,9 @@ namespace boost
                m_.unlock();
                m=&m_;
            }
-            void deactivate()
+            ~lock_on_exit()
            {
-                if (m)
-                {
-                    m->lock();
-                }
-                m = 0;
-            }
-            ~lock_on_exit() BOOST_NOEXCEPT_IF(false)
-            {
-                if (m)
+                if(m)
                {
                    m->lock();
                }
@@ -78,13 +70,10 @@ namespace boost
            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
            pthread_mutex_t* the_mutex = &internal_mutex;
            guard.activate(m);
-            res = pthread_cond_wait(&cond,the_mutex);
-            check_for_interruption.check();
-            guard.deactivate();
 #else
            pthread_mutex_t* the_mutex = m.mutex()->native_handle();
-            res = pthread_cond_wait(&cond,the_mutex);
 #endif
+            res = pthread_cond_wait(&cond,the_mutex);
        }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
        this_thread::interruption_point();
@@ -112,13 +101,10 @@ namespace boost
            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
            pthread_mutex_t* the_mutex = &internal_mutex;
            guard.activate(m);
-            cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
-            check_for_interruption.check();
-            guard.deactivate();
 #else
            pthread_mutex_t* the_mutex = m.mutex()->native_handle();
-            cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
 #endif
+            cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
        }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
        this_thread::interruption_point();
@@ -190,8 +176,6 @@ namespace boost
 #endif
                guard.activate(m);
                res=pthread_cond_wait(&cond,&internal_mutex);
-                check_for_interruption.check();
-                guard.deactivate();
            }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
            this_thread::interruption_point();
@@ -420,8 +404,6 @@ namespace boost
 #endif
              guard.activate(m);
              res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
-              check_for_interruption.check();
-              guard.deactivate();
          }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
          this_thread::interruption_point();
--- a/include/boost/thread/pthread/condition_variable_fwd.hpp
+++ b/include/boost/thread/pthread/condition_variable_fwd.hpp
@@ -53,9 +53,9 @@ namespace boost
    class condition_variable
    {
    private:
-//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
        pthread_mutex_t internal_mutex;
-//#endif
+#endif
        pthread_cond_t cond;

    public:
@@ -69,8 +69,16 @@ namespace boost
            unique_lock<mutex>& lock,
            struct timespec const &timeout)
        {
-#if defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-            return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now_monotonic()));
+#if ! defined BOOST_THREAD_USEFIXES_TIMESPEC
+            return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now()));
+#elif ! defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
+            //using namespace chrono;
+            //nanoseconds ns = chrono::system_clock::now().time_since_epoch();
+
+            struct timespec ts = boost::detail::timespec_now_realtime();
+            //ts.tv_sec = static_cast<long>(chrono::duration_cast<chrono::seconds>(ns).count());
+            //ts.tv_nsec = static_cast<long>((ns - chrono::duration_cast<chrono::seconds>(ns)).count());
+            return do_wait_until(lock, boost::detail::timespec_plus(timeout, ts));
 #else
            // old behavior was fine for monotonic
            return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now_realtime()));
@@ -82,37 +90,31 @@ namespace boost
        condition_variable()
        {
            int res;
-//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            // Even if it is not used, the internal_mutex exists (see
-            // above) and must be initialized (etc) in case some
-            // compilation units provide interruptions and others
-            // don't.
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
            res=pthread_mutex_init(&internal_mutex,NULL);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread_mutex_init"));
            }
-//#endif
+#endif
            res = detail::monotonic_pthread_cond_init(cond);
            if (res)
            {
-//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-                // ditto
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
-//#endif
+#endif
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in detail::monotonic_pthread_cond_init"));
            }
        }
        ~condition_variable()
        {
            int ret;
-//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            // ditto
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
            do {
              ret = pthread_mutex_destroy(&internal_mutex);
            } while (ret == EINTR);
            BOOST_ASSERT(!ret);
-//#endif
+#endif
            do {
              ret = pthread_cond_destroy(&cond);
            } while (ret == EINTR);
--- a/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp
+++ b/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp
@@ -1,6 +1,6 @@
 #ifndef BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
 #define BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
-//  (C) Copyright 2007-8 Anthony Williams
+//  (C) Copyright 2007-8 Anthony Williams 
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -20,47 +20,41 @@ namespace boost
            pthread_mutex_t* m;
            bool locked;
        public:
-            explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_) BOOST_NOEXCEPT:
+            explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_):
                m(m_),locked(true)
            {
                BOOST_VERIFY(!pthread_mutex_lock(m));
            }
-            void unlock() BOOST_NOEXCEPT
+            void unlock()
            {
                BOOST_VERIFY(!pthread_mutex_unlock(m));
                locked=false;
            }
-            void check() BOOST_NOEXCEPT
-            {
-              if(locked)
-              {
-                  unlock();
-              }
-            }
-            ~pthread_mutex_scoped_lock() BOOST_NOEXCEPT
+            
+            ~pthread_mutex_scoped_lock()
            {
                if(locked)
                {
                    unlock();
                }
            }
-
+            
        };

        class pthread_mutex_scoped_unlock
        {
            pthread_mutex_t* m;
        public:
-            explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_) BOOST_NOEXCEPT:
+            explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_):
                m(m_)
            {
                BOOST_VERIFY(!pthread_mutex_unlock(m));
            }
-            ~pthread_mutex_scoped_unlock() BOOST_NOEXCEPT
+            ~pthread_mutex_scoped_unlock()
            {
                BOOST_VERIFY(!pthread_mutex_lock(m));
            }
-
+            
        };
    }
 }
--- a/include/boost/thread/pthread/shared_mutex.hpp
+++ b/include/boost/thread/pthread/shared_mutex.hpp
@@ -20,6 +20,7 @@
 #include <boost/chrono/ceil.hpp>
 #endif
 #include <boost/thread/detail/delete.hpp>
+#include <boost/assert.hpp>

 #include <boost/config/abi_prefix.hpp>

--- a/include/boost/thread/pthread/thread_data.hpp
+++ b/include/boost/thread/pthread/thread_data.hpp
@@ -50,11 +50,7 @@ namespace boost
        // stack
        void set_stack_size(std::size_t size) BOOST_NOEXCEPT {
          if (size==0) return;
-#ifdef BOOST_THREAD_USES_GETPAGESIZE
          std::size_t page_size = getpagesize();
-#else
-          std::size_t page_size = ::sysconf( _SC_PAGESIZE);
-#endif
 #ifdef PTHREAD_STACK_MIN
          if (size<PTHREAD_STACK_MIN) size=PTHREAD_STACK_MIN;
 #endif
@@ -181,7 +177,6 @@ namespace boost
            thread_data_base* const thread_info;
            pthread_mutex_t* m;
            bool set;
-            bool done;

            void check_for_interruption()
            {
@@ -198,7 +193,7 @@ namespace boost
        public:
            explicit interruption_checker(pthread_mutex_t* cond_mutex,pthread_cond_t* cond):
                thread_info(detail::get_current_thread_data()),m(cond_mutex),
-                set(thread_info && thread_info->interrupt_enabled), done(false)
+                set(thread_info && thread_info->interrupt_enabled)
            {
                if(set)
                {
@@ -213,10 +208,9 @@ namespace boost
                    BOOST_VERIFY(!pthread_mutex_lock(m));
                }
            }
-            void check()
+            ~interruption_checker()
            {
-              if ( ! done) {
-                if (set)
+                if(set)
                {
                    BOOST_VERIFY(!pthread_mutex_unlock(m));
                    lock_guard<mutex> guard(thread_info->data_mutex);
@@ -227,13 +221,6 @@ namespace boost
                {
                    BOOST_VERIFY(!pthread_mutex_unlock(m));
                }
-                done = true;
-              }
-            }
-
-            ~interruption_checker() BOOST_NOEXCEPT_IF(false)
-            {
-                check();
            }
        };
 #endif
@@ -244,12 +231,10 @@ namespace boost
        namespace hidden
        {
          void BOOST_THREAD_DECL sleep_for(const timespec& ts);
-          void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts);
+          void BOOST_THREAD_DECL sleep_until(const timespec& ts);
        }

 #ifdef BOOST_THREAD_USES_CHRONO
-        template <class Rep, class Period>
-        void sleep_for(const chrono::duration<Rep, Period>& d);
 #ifdef BOOST_THREAD_SLEEP_FOR_IS_STEADY

        inline
@@ -265,12 +250,10 @@ namespace boost
          namespace hidden
          {
            void BOOST_THREAD_DECL sleep_for(const timespec& ts);
-            void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts);
+            void BOOST_THREAD_DECL sleep_until(const timespec& ts);
          }

    #ifdef BOOST_THREAD_USES_CHRONO
-          template <class Rep, class Period>
-          void sleep_for(const chrono::duration<Rep, Period>& d);
    #ifdef BOOST_THREAD_SLEEP_FOR_IS_STEADY

          inline
@@ -292,7 +275,7 @@ namespace boost
 #endif
        inline void sleep(system_time const& abs_time)
        {
-          return boost::this_thread::hidden::sleep_until_realtime(boost::detail::to_timespec(abs_time));
+          return boost::this_thread::hidden::sleep_until(boost::detail::to_timespec(abs_time));
        }

        template<typename TimeDuration>
--- a/include/boost/thread/pthread/thread_heap_alloc.hpp
+++ b/include/boost/thread/pthread/thread_heap_alloc.hpp
@@ -16,13 +16,8 @@ namespace boost
        {
            return new T();
        }
-#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) && ! defined (BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template<typename T,typename... Args>
-        inline T* heap_new(Args&&... args)
-        {
-            return new T(static_cast<Args&&>(args)...);
-        }
-#elif ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
        template<typename T,typename A1>
        inline T* heap_new(A1&& a1)
        {
@@ -66,31 +61,6 @@ namespace boost
        {
            return new T(a1,a2,a3,a4);
        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
-        {
-            return new T(a1,a2,a3,a4,a5);
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
-        {
-            return new T(a1,a2,a3,a4,a5,a6);
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
-        {
-            return new T(a1,a2,a3,a4,a5,a6,a7);
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
-        {
-            return new T(a1,a2,a3,a4,a5,a6,a7,a8);
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8,typename A9>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
-        {
-            return new T(a1,a2,a3,a4,a5,a6,a7,a8,a9);
-        }

        template<typename T,typename A1>
        inline T* heap_new(A1 const& a1)
--- a/include/boost/thread/pthread/timespec.hpp
+++ b/include/boost/thread/pthread/timespec.hpp
@@ -71,21 +71,32 @@ namespace boost
    {
      return (ts.tv_sec >= 0) || (ts.tv_nsec >= 0);
    }
-#if defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-
-    inline timespec timespec_now_monotonic()
+    inline timespec timespec_now()
    {
      timespec ts;

+#if defined CLOCK_MONOTONIC && defined BOOST_THREAD_USEFIXES_TIMESPEC
      if ( ::clock_gettime( CLOCK_MONOTONIC, &ts ) )
      {
        ts.tv_sec = 0;
        ts.tv_nsec = 0;
        BOOST_ASSERT(0 && "Boost::Thread - Internal Error");
      }
+#elif defined(BOOST_THREAD_TIMESPEC_MAC_API)
+      timeval tv;
+      ::gettimeofday(&tv, 0);
+      ts.tv_sec = tv.tv_sec;
+      ts.tv_nsec = tv.tv_usec * 1000;
+#else
+      if ( ::clock_gettime( CLOCK_REALTIME, &ts ) )
+      {
+        ts.tv_sec = 0;
+        ts.tv_nsec = 0;
+        BOOST_ASSERT(0 && "Boost::Thread - Internal Error");
+      }
+#endif
      return ts;
    }
-#endif

    inline timespec timespec_now_realtime()
    {
--- a/include/boost/thread/win32/basic_recursive_mutex.hpp
+++ b/include/boost/thread/win32/basic_recursive_mutex.hpp
@@ -44,13 +44,13 @@ namespace boost

            bool try_lock() BOOST_NOEXCEPT
            {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=win32::GetCurrentThreadId();
                return try_recursive_lock(current_thread_id) || try_basic_lock(current_thread_id);
            }

            void lock()
            {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=win32::GetCurrentThreadId();
                if(!try_recursive_lock(current_thread_id))
                {
                    mutex.lock();
@@ -61,7 +61,7 @@ namespace boost
 #if defined BOOST_THREAD_USES_DATETIME
            bool timed_lock(::boost::system_time const& target)
            {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=win32::GetCurrentThreadId();
                return try_recursive_lock(current_thread_id) || try_timed_lock(current_thread_id,target);
            }
            template<typename Duration>
@@ -75,13 +75,13 @@ namespace boost
        template <class Rep, class Period>
        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
        {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=win32::GetCurrentThreadId();
                return try_recursive_lock(current_thread_id) || try_timed_lock_for(current_thread_id,rel_time);
        }
        template <class Clock, class Duration>
        bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
        {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=win32::GetCurrentThreadId();
                return try_recursive_lock(current_thread_id) || try_timed_lock_until(current_thread_id,t);
        }
 #endif
--- a/include/boost/thread/win32/basic_timed_mutex.hpp
+++ b/include/boost/thread/win32/basic_timed_mutex.hpp
@@ -55,7 +55,7 @@ namespace boost
 #endif
                if(old_event)
                {
-                    winapi::CloseHandle(old_event);
+                    win32::CloseHandle(old_event);
                }
            }

@@ -81,9 +81,9 @@ namespace boost

                    do
                    {
-                        unsigned const retval(winapi::WaitForSingleObjectEx(sem, ::boost::detail::win32::infinite,0));
+                        unsigned const retval(win32::WaitForSingleObjectEx(sem, ::boost::detail::win32::infinite,0));
                        BOOST_VERIFY(0 == retval || ::boost::detail::win32::wait_abandoned == retval);
-//                        BOOST_VERIFY(winapi::WaitForSingleObject(
+//                        BOOST_VERIFY(win32::WaitForSingleObject(
 //                                         sem,::boost::detail::win32::infinite)==0);
                        clear_waiting_and_try_lock(old_count);
                        lock_acquired=!(old_count&lock_flag_value);
@@ -142,7 +142,7 @@ namespace boost

                    do
                    {
-                        if(winapi::WaitForSingleObjectEx(sem,::boost::detail::get_milliseconds_until(wait_until),0)!=0)
+                        if(win32::WaitForSingleObjectEx(sem,::boost::detail::get_milliseconds_until(wait_until),0)!=0)
                        {
                            BOOST_INTERLOCKED_DECREMENT(&active_count);
                            return false;
@@ -210,7 +210,7 @@ namespace boost
                      }
                      chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-now);

-                      if(winapi::WaitForSingleObjectEx(sem,static_cast<unsigned long>(rel_time.count()),0)!=0)
+                      if(win32::WaitForSingleObjectEx(sem,static_cast<unsigned long>(rel_time.count()),0)!=0)
                      {
                          BOOST_INTERLOCKED_DECREMENT(&active_count);
                          return false;
@@ -232,7 +232,7 @@ namespace boost
                {
                    if(!win32::interlocked_bit_test_and_set(&active_count,event_set_flag_bit))
                    {
-                        winapi::SetEvent(get_event());
+                        win32::SetEvent(get_event());
                    }
                }
            }
@@ -256,7 +256,7 @@ namespace boost
 #endif
                    if(old_event!=0)
                    {
-                        winapi::CloseHandle(new_event);
+                        win32::CloseHandle(new_event);
                        return old_event;
                    }
                    else
--- a/include/boost/thread/win32/condition_variable.hpp
+++ b/include/boost/thread/win32/condition_variable.hpp
@@ -76,7 +76,7 @@ namespace boost
            void release(unsigned count_to_release)
            {
                notified=true;
-                detail::winapi::ReleaseSemaphore(semaphore,count_to_release,0);
+                detail::win32::ReleaseSemaphore(semaphore,count_to_release,0);
            }

            void release_waiters()
@@ -96,7 +96,7 @@ namespace boost

            bool woken()
            {
-                unsigned long const woken_result=detail::winapi::WaitForSingleObjectEx(wake_sem,0,0);
+                unsigned long const woken_result=detail::win32::WaitForSingleObjectEx(wake_sem,0,0);
                BOOST_ASSERT((woken_result==detail::win32::timeout) || (woken_result==0));
                return woken_result==0;
            }
@@ -135,45 +135,39 @@ namespace boost
            void wake_waiters(long count_to_wake)
            {
                detail::interlocked_write_release(&total_count,total_count-count_to_wake);
-                detail::winapi::ReleaseSemaphore(wake_sem,count_to_wake,0);
+                detail::win32::ReleaseSemaphore(wake_sem,count_to_wake,0);
            }

            template<typename lock_type>
            struct relocker
            {
                BOOST_THREAD_NO_COPYABLE(relocker)
-                lock_type& _lock;
-                bool _unlocked;
+                lock_type& lock;
+                bool unlocked;

                relocker(lock_type& lock_):
-                    _lock(lock_), _unlocked(false)
+                    lock(lock_),unlocked(false)
                {}
                void unlock()
                {
-                  if ( ! _unlocked )
-                  {
-                    _lock.unlock();
-                    _unlocked=true;
-                  }
+                    lock.unlock();
+                    unlocked=true;
                }
-                void lock()
+                ~relocker()
                {
-                  if ( _unlocked )
-                  {
-                    _lock.lock();
-                    _unlocked=false;
-                  }
-                }
-                ~relocker() BOOST_NOEXCEPT_IF(false)
-                {
-                  lock();
+                    if(unlocked)
+                    {
+                        lock.lock();
+                    }
+
                }
            };


            entry_ptr get_wait_entry()
            {
-                boost::lock_guard<boost::mutex> lk(internal_mutex);
+                boost::lock_guard<boost::mutex> internal_lock(internal_mutex);
+
                if(!wake_sem)
                {
                    wake_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
@@ -196,32 +190,18 @@ namespace boost

            struct entry_manager
            {
-                entry_ptr entry;
+                entry_ptr const entry;
                boost::mutex& internal_mutex;

-
                BOOST_THREAD_NO_COPYABLE(entry_manager)
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-                entry_manager(entry_ptr&& entry_, boost::mutex& mutex_):
-                    entry(static_cast< entry_ptr&& >(entry_)), internal_mutex(mutex_)
-                {}
-#else
                entry_manager(entry_ptr const& entry_, boost::mutex& mutex_):
                    entry(entry_), internal_mutex(mutex_)
                {}
-#endif

-                void remove_waiter_and_reset()
+                ~entry_manager()
                {
-                  if (entry) {
                    boost::lock_guard<boost::mutex> internal_lock(internal_mutex);
                    entry->remove_waiter();
-                    entry.reset();
-                  }
-                }
-                ~entry_manager() BOOST_NOEXCEPT_IF(false)
-                {
-                  remove_waiter_and_reset();
                }

                list_entry* operator->()
@@ -235,24 +215,23 @@ namespace boost
            template<typename lock_type>
            bool do_wait(lock_type& lock,timeout abs_time)
            {
-              relocker<lock_type> locker(lock);
-              entry_manager entry(get_wait_entry(), internal_mutex);
-              locker.unlock();
+                relocker<lock_type> locker(lock);

-              bool woken=false;
-              while(!woken)
-              {
-                  if(!entry->wait(abs_time))
-                  {
-                      return false;
-                  }
+                entry_manager entry(get_wait_entry(), internal_mutex);

-                  woken=entry->woken();
-              }
-              // do it here to avoid throwing on the destructor
-              entry.remove_waiter_and_reset();
-              locker.lock();
-              return woken;
+                locker.unlock();
+
+                bool woken=false;
+                while(!woken)
+                {
+                    if(!entry->wait(abs_time))
+                    {
+                        return false;
+                    }
+
+                    woken=entry->woken();
+                }
+                return woken;
            }

            template<typename lock_type,typename predicate_type>
--- a/include/boost/thread/win32/once.hpp
+++ b/include/boost/thread/win32/once.hpp
@@ -124,7 +124,7 @@ namespace boost
            std::memcpy(mutex_name,fixed_mutex_name,sizeof(fixed_mutex_name));
            detail::int_to_string(reinterpret_cast<std::ptrdiff_t>(flag_address),
                                  mutex_name + once_mutex_name_fixed_length);
-            detail::int_to_string(winapi::GetCurrentProcessId(),
+            detail::int_to_string(win32::GetCurrentProcessId(),
                                  mutex_name + once_mutex_name_fixed_length + sizeof(void*)*2);
        }

@@ -136,9 +136,9 @@ namespace boost
            }

 #ifdef BOOST_NO_ANSI_APIS
-            return ::boost::detail::winapi::OpenEventW(
+            return ::boost::detail::win32::OpenEventW(
 #else
-            return ::boost::detail::winapi::OpenEventA(
+            return ::boost::detail::win32::OpenEventA(
 #endif
                ::boost::detail::win32::synchronize |
                ::boost::detail::win32::event_modify_state,
@@ -186,7 +186,7 @@ namespace boost
            }
            if(ctx.event_handle)
            {
-                ::boost::detail::winapi::ResetEvent(ctx.event_handle);
+                ::boost::detail::win32::ResetEvent(ctx.event_handle);
            }
            return true;
          }
@@ -207,7 +207,7 @@ namespace boost
          }
          if(ctx.event_handle)
          {
-              ::boost::detail::winapi::SetEvent(ctx.event_handle);
+              ::boost::detail::win32::SetEvent(ctx.event_handle);
          }
        }
        inline void rollback_once_region(once_flag& flag, once_context& ctx) BOOST_NOEXCEPT
@@ -219,7 +219,7 @@ namespace boost
          }
          if(ctx.event_handle)
          {
-              ::boost::detail::winapi::SetEvent(ctx.event_handle);
+              ::boost::detail::win32::SetEvent(ctx.event_handle);
          }
        }
    }
@@ -264,7 +264,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite, 0));
        }
    }
@@ -308,7 +308,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -355,7 +355,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -400,7 +400,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -443,7 +443,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -486,7 +486,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -529,7 +529,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -574,7 +574,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -617,7 +617,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -660,7 +660,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -703,7 +703,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -748,7 +748,7 @@ namespace boost
                        continue;
                    }
                }
-                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                                 ctx.event_handle,::boost::detail::win32::infinite,0));
            }
        }
@@ -793,7 +793,7 @@ namespace boost
                        continue;
                    }
                }
-                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                                 ctx.event_handle,::boost::detail::win32::infinite,0));
            }
        }
@@ -839,7 +839,7 @@ namespace boost
                        continue;
                    }
                }
-                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                                 ctx.event_handle,::boost::detail::win32::infinite,0));
            }
        }
@@ -886,7 +886,7 @@ namespace boost
                        continue;
                    }
                }
-                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                                 ctx.event_handle,::boost::detail::win32::infinite,0));
            }
        }
@@ -930,7 +930,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -977,7 +977,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -1024,7 +1024,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -1073,7 +1073,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
--- a/include/boost/thread/win32/shared_mutex.hpp
+++ b/include/boost/thread/win32/shared_mutex.hpp
@@ -67,19 +67,19 @@ namespace boost
        {
            if(old_state.exclusive_waiting)
            {
-                BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[exclusive_sem],1,0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[exclusive_sem],1,0)!=0);
            }

            if(old_state.shared_waiting || old_state.exclusive_waiting)
            {
-                BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
            }
        }
        void release_shared_waiters(state_data old_state)
        {
            if(old_state.shared_waiting || old_state.exclusive_waiting)
            {
-                BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
            }
        }

@@ -107,9 +107,9 @@ namespace boost

        ~shared_mutex()
        {
-            detail::winapi::CloseHandle(upgrade_sem);
-            detail::winapi::CloseHandle(semaphores[unlock_sem]);
-            detail::winapi::CloseHandle(semaphores[exclusive_sem]);
+            detail::win32::CloseHandle(upgrade_sem);
+            detail::win32::CloseHandle(semaphores[unlock_sem]);
+            detail::win32::CloseHandle(semaphores[exclusive_sem]);
        }

        bool try_lock_shared()
@@ -191,7 +191,7 @@ namespace boost
                    return true;
                }

-                unsigned long const res=detail::winapi::WaitForSingleObjectEx(semaphores[unlock_sem],::boost::detail::get_milliseconds_until(wait_until), 0);
+                unsigned long const res=detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],::boost::detail::get_milliseconds_until(wait_until), 0);
                if(res==detail::win32::timeout)
                {
                    for(;;)
@@ -296,7 +296,7 @@ namespace boost
            unsigned long res;
            if (tp>n) {
              chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-n);
-              res=detail::winapi::WaitForSingleObjectEx(semaphores[unlock_sem],
+              res=detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],
                static_cast<unsigned long>(rel_time.count()), 0);
            } else {
              res=detail::win32::timeout;
@@ -375,7 +375,7 @@ namespace boost
                    {
                        if(old_state.upgrade)
                        {
-                            BOOST_VERIFY(detail::winapi::ReleaseSemaphore(upgrade_sem,1,0)!=0);
+                            BOOST_VERIFY(detail::win32::ReleaseSemaphore(upgrade_sem,1,0)!=0);
                        }
                        else
                        {
@@ -474,7 +474,7 @@ namespace boost
                #else
                const bool wait_all = false;
                #endif
-                unsigned long const wait_res=detail::winapi::WaitForMultipleObjectsEx(2,semaphores,wait_all,::boost::detail::get_milliseconds_until(wait_until), 0);
+                unsigned long const wait_res=detail::win32::WaitForMultipleObjectsEx(2,semaphores,wait_all,::boost::detail::get_milliseconds_until(wait_until), 0);
                if(wait_res==detail::win32::timeout)
                {
                    for(;;)
@@ -500,7 +500,7 @@ namespace boost
                        state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
                        if (must_notify)
                        {
-                          BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
+                          BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
                        }

                        if(current_state==old_state)
@@ -586,7 +586,7 @@ namespace boost
            unsigned long wait_res;
            if (tp>n) {
              chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-chrono::system_clock::now());
-              wait_res=detail::winapi::WaitForMultipleObjectsEx(2,semaphores,wait_all,
+              wait_res=detail::win32::WaitForMultipleObjectsEx(2,semaphores,wait_all,
                  static_cast<unsigned long>(rel_time.count()), 0);
            } else {
              wait_res=detail::win32::timeout;
@@ -616,7 +616,7 @@ namespace boost
                state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
                if (must_notify)
                {
-                  BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
+                  BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
                }
                if(current_state==old_state)
                {
@@ -698,7 +698,7 @@ namespace boost
                    return;
                }

-                BOOST_VERIFY(!detail::winapi::WaitForSingleObjectEx(semaphores[unlock_sem],detail::winapi::infinite, 0));
+                BOOST_VERIFY(!detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],detail::win32::infinite, 0));
            }
        }

@@ -790,7 +790,7 @@ namespace boost
                {
                    if(!last_reader)
                    {
-                        BOOST_VERIFY(!detail::winapi::WaitForSingleObjectEx(upgrade_sem,detail::win32::infinite, 0));
+                        BOOST_VERIFY(!detail::win32::WaitForSingleObjectEx(upgrade_sem,detail::win32::infinite, 0));
                    }
                    break;
                }
--- a/include/boost/thread/win32/thread_data.hpp
+++ b/include/boost/thread/win32/thread_data.hpp
@@ -153,7 +153,7 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
            void interrupt()
            {
-                BOOST_VERIFY(detail::winapi::SetEvent(interruption_handle)!=0);
+                BOOST_VERIFY(detail::win32::SetEvent(interruption_handle)!=0);
            }
 #endif
            typedef detail::win32::handle native_handle_type;
--- a/include/boost/thread/win32/thread_heap_alloc.hpp
+++ b/include/boost/thread/win32/thread_heap_alloc.hpp
@@ -12,7 +12,45 @@
 #include <boost/throw_exception.hpp>
 #include <boost/core/no_exceptions_support.hpp>

-#include <boost/detail/winapi/heap_memory.hpp>
+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            using ::GetProcessHeap;
+            using ::HeapAlloc;
+            using ::HeapFree;
+        }
+    }
+}
+
+#else
+
+# ifdef HeapAlloc
+# undef HeapAlloc
+# endif
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            extern "C"
+            {
+                __declspec(dllimport) handle __stdcall GetProcessHeap();
+                __declspec(dllimport) void* __stdcall HeapAlloc(handle,unsigned long,ulong_ptr);
+                __declspec(dllimport) int __stdcall HeapFree(handle,unsigned long,void*);
+            }
+        }
+    }
+}
+
+#endif

 #include <boost/config/abi_prefix.hpp>

@@ -22,7 +60,7 @@ namespace boost
    {
        inline void* allocate_raw_heap_memory(unsigned size)
        {
-            void* const heap_memory=detail::winapi::HeapAlloc(detail::winapi::GetProcessHeap(),0,size);
+            void* const heap_memory=detail::win32::HeapAlloc(detail::win32::GetProcessHeap(),0,size);
            if(!heap_memory)
            {
                boost::throw_exception(std::bad_alloc());
@@ -32,26 +70,9 @@ namespace boost

        inline void free_raw_heap_memory(void* heap_memory)
        {
-            BOOST_VERIFY(detail::winapi::HeapFree(detail::winapi::GetProcessHeap(),0,heap_memory)!=0);
+            BOOST_VERIFY(detail::win32::HeapFree(detail::win32::GetProcessHeap(),0,heap_memory)!=0);
        }
-#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) && ! defined (BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template<typename T,typename... Args>
-        inline T* heap_new(Args&&... args)
-        {
-          void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-          BOOST_TRY
-          {
-              T* const data=new (heap_memory) T(static_cast<Args&&>(args)...);
-              return data;
-          }
-          BOOST_CATCH(...)
-          {
-              free_raw_heap_memory(heap_memory);
-              BOOST_RETHROW
-          }
-          BOOST_CATCH_END
-        }
-#else
+
        template<typename T>
        inline T* heap_new()
        {
@@ -204,86 +225,6 @@ namespace boost
            }
            BOOST_CATCH_END
        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6,a7);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6,a7,a8);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8,typename A9>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6,a7,a8,a9);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }


        template<typename T,typename A1>
@@ -443,7 +384,6 @@ namespace boost
            return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
        }

-#endif
 #endif
        template<typename T>
        inline void heap_delete(T* data)
--- a/include/boost/thread/win32/thread_primitives.hpp
+++ b/include/boost/thread/win32/thread_primitives.hpp
@@ -17,21 +17,6 @@
 #include <boost/thread/exceptions.hpp>
 #include <boost/detail/interlocked.hpp>
 #include <boost/detail/winapi/config.hpp>
-
-#include <boost/detail/winapi/semaphore.hpp>
-#include <boost/detail/winapi/dll.hpp>
-#include <boost/detail/winapi/system.hpp>
-#include <boost/detail/winapi/time.hpp>
-#include <boost/detail/winapi/event.hpp>
-#include <boost/detail/winapi/thread.hpp>
-#include <boost/detail/winapi/get_current_thread.hpp>
-#include <boost/detail/winapi/get_current_thread_id.hpp>
-#include <boost/detail/winapi/get_current_process.hpp>
-#include <boost/detail/winapi/get_current_process_id.hpp>
-#include <boost/detail/winapi/wait.hpp>
-#include <boost/detail/winapi/handles.hpp>
-#include <boost/detail/winapi/access_rights.hpp>
-
 //#include <boost/detail/winapi/synchronization.hpp>
 #include <boost/thread/win32/interlocked_read.hpp>
 #include <algorithm>
@@ -40,29 +25,200 @@
 #include <thread>
 #endif

+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+
 namespace boost
 {
    namespace detail
    {
        namespace win32
        {
-            typedef ::boost::detail::winapi::HANDLE_ handle;
-            typedef ::boost::detail::winapi::SYSTEM_INFO_ system_info;
+            typedef HANDLE handle;
+            typedef SYSTEM_INFO system_info;
            typedef unsigned __int64 ticks_type;
-            typedef ::boost::detail::winapi::FARPROC_ farproc_t;
-            unsigned const infinite=::boost::detail::winapi::INFINITE_;
-            unsigned const timeout=::boost::detail::winapi::WAIT_TIMEOUT_;
-            handle const invalid_handle_value=::boost::detail::winapi::INVALID_HANDLE_VALUE_;
-            unsigned const event_modify_state=::boost::detail::winapi::EVENT_MODIFY_STATE_;
-            unsigned const synchronize=::boost::detail::winapi::SYNCHRONIZE_;
-            unsigned const wait_abandoned=::boost::detail::winapi::WAIT_ABANDONED_;
+            typedef FARPROC farproc_t;
+            unsigned const infinite=INFINITE;
+            unsigned const timeout=WAIT_TIMEOUT;
+            handle const invalid_handle_value=INVALID_HANDLE_VALUE;
+            unsigned const event_modify_state=EVENT_MODIFY_STATE;
+            unsigned const synchronize=SYNCHRONIZE;
+            unsigned const wait_abandoned=WAIT_ABANDONED;
            unsigned const create_event_initial_set = 0x00000002;
            unsigned const create_event_manual_reset = 0x00000001;
-            unsigned const event_all_access = ::boost::detail::winapi::EVENT_ALL_ACCESS_;
-            unsigned const semaphore_all_access = boost::detail::winapi::SEMAPHORE_ALL_ACCESS_;
+            unsigned const event_all_access = EVENT_ALL_ACCESS;
+            unsigned const semaphore_all_access = SEMAPHORE_ALL_ACCESS;
+
+
+# ifdef BOOST_NO_ANSI_APIS
+# if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
+            using ::CreateMutexW;
+            using ::CreateEventW;
+            using ::CreateSemaphoreW;
+# else
+            using ::CreateMutexExW;
+            using ::CreateEventExW;
+            using ::CreateSemaphoreExW;
+# endif
+            using ::OpenEventW;
+            using ::GetModuleHandleW;
+# else
+            using ::CreateMutexA;
+            using ::CreateEventA;
+            using ::OpenEventA;
+            using ::CreateSemaphoreA;
+            using ::GetModuleHandleA;
+# endif
+#if BOOST_PLAT_WINDOWS_RUNTIME
+            using ::GetNativeSystemInfo;
+            using ::GetTickCount64;
+#else
+            using ::GetSystemInfo;
+            using ::GetTickCount;
+#endif
+            using ::CloseHandle;
+            using ::ReleaseMutex;
+            using ::ReleaseSemaphore;
+            using ::SetEvent;
+            using ::ResetEvent;
+            using ::WaitForMultipleObjectsEx;
+            using ::WaitForSingleObjectEx;
+            using ::GetCurrentProcessId;
+            using ::GetCurrentThreadId;
+            using ::GetCurrentThread;
+            using ::GetCurrentProcess;
+            using ::DuplicateHandle;
+#if !BOOST_PLAT_WINDOWS_RUNTIME
+            using ::SleepEx;
+            using ::Sleep;
+            using ::QueueUserAPC;
+            using ::GetProcAddress;
+#endif
        }
    }
 }
+#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
+
+# ifdef UNDER_CE
+#  ifndef WINAPI
+#   ifndef _WIN32_WCE_EMULATION
+#    define WINAPI  __cdecl     // Note this doesn't match the desktop definition
+#   else
+#    define WINAPI  __stdcall
+#   endif
+#  endif
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+typedef int BOOL;
+typedef unsigned long DWORD;
+typedef void* HANDLE;
+#  include <kfuncs.h>
+#  ifdef __cplusplus
+}
+#  endif
+# endif
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+struct _SYSTEM_INFO;
+# ifdef __cplusplus
+}
+#endif
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+# ifdef _WIN64
+            typedef unsigned __int64 ulong_ptr;
+# else
+            typedef unsigned long ulong_ptr;
+# endif
+            typedef void* handle;
+            typedef _SYSTEM_INFO system_info;
+            typedef unsigned __int64 ticks_type;
+            typedef int (__stdcall *farproc_t)();
+            unsigned const infinite=~0U;
+            unsigned const timeout=258U;
+            handle const invalid_handle_value=(handle)(-1);
+            unsigned const event_modify_state=2;
+            unsigned const synchronize=0x100000u;
+            unsigned const wait_abandoned=0x00000080u;
+            unsigned const create_event_initial_set = 0x00000002;
+            unsigned const create_event_manual_reset = 0x00000001;
+            unsigned const event_all_access = 0x1F0003;
+            unsigned const semaphore_all_access = 0x1F0003;
+
+            extern "C"
+            {
+                struct _SECURITY_ATTRIBUTES;
+# ifdef BOOST_NO_ANSI_APIS
+# if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
+                __declspec(dllimport) void* __stdcall CreateMutexW(_SECURITY_ATTRIBUTES*,int,wchar_t const*);
+                __declspec(dllimport) void* __stdcall CreateSemaphoreW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*);
+                __declspec(dllimport) void* __stdcall CreateEventW(_SECURITY_ATTRIBUTES*,int,int,wchar_t const*);
+# else
+                __declspec(dllimport) void* __stdcall CreateMutexExW(_SECURITY_ATTRIBUTES*,wchar_t const*,unsigned long,unsigned long);
+                __declspec(dllimport) void* __stdcall CreateEventExW(_SECURITY_ATTRIBUTES*,wchar_t const*,unsigned long,unsigned long);
+                __declspec(dllimport) void* __stdcall CreateSemaphoreExW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*,unsigned long,unsigned long);
+# endif
+                __declspec(dllimport) void* __stdcall OpenEventW(unsigned long,int,wchar_t const*);
+                __declspec(dllimport) void* __stdcall GetModuleHandleW(wchar_t const*);
+# else
+                __declspec(dllimport) void* __stdcall CreateMutexA(_SECURITY_ATTRIBUTES*,int,char const*);
+                __declspec(dllimport) void* __stdcall CreateSemaphoreA(_SECURITY_ATTRIBUTES*,long,long,char const*);
+                __declspec(dllimport) void* __stdcall CreateEventA(_SECURITY_ATTRIBUTES*,int,int,char const*);
+                __declspec(dllimport) void* __stdcall OpenEventA(unsigned long,int,char const*);
+                __declspec(dllimport) void* __stdcall GetModuleHandleA(char const*);
+# endif
+#if BOOST_PLAT_WINDOWS_RUNTIME
+                __declspec(dllimport) void __stdcall GetNativeSystemInfo(_SYSTEM_INFO*);
+                __declspec(dllimport) ticks_type __stdcall GetTickCount64();
+#else
+                __declspec(dllimport) void __stdcall GetSystemInfo(_SYSTEM_INFO*);
+                __declspec(dllimport) unsigned long __stdcall GetTickCount();
+#endif
+                __declspec(dllimport) int __stdcall CloseHandle(void*);
+                __declspec(dllimport) int __stdcall ReleaseMutex(void*);
+                __declspec(dllimport) unsigned long __stdcall WaitForSingleObjectEx(void*,unsigned long,int);
+                __declspec(dllimport) unsigned long __stdcall WaitForMultipleObjectsEx(unsigned long nCount,void* const * lpHandles,int bWaitAll,unsigned long dwMilliseconds,int bAlertable);
+                __declspec(dllimport) int __stdcall ReleaseSemaphore(void*,long,long*);
+                __declspec(dllimport) int __stdcall DuplicateHandle(void*,void*,void*,void**,unsigned long,int,unsigned long);
+#if !BOOST_PLAT_WINDOWS_RUNTIME
+                __declspec(dllimport) unsigned long __stdcall SleepEx(unsigned long,int);
+                __declspec(dllimport) void __stdcall Sleep(unsigned long);
+                typedef void (__stdcall *queue_user_apc_callback_function)(ulong_ptr);
+                __declspec(dllimport) unsigned long __stdcall QueueUserAPC(queue_user_apc_callback_function,void*,ulong_ptr);
+                __declspec(dllimport) farproc_t __stdcall GetProcAddress(void *, const char *);
+#endif
+
+# ifndef UNDER_CE
+                __declspec(dllimport) unsigned long __stdcall GetCurrentProcessId();
+                __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId();
+                __declspec(dllimport) void* __stdcall GetCurrentThread();
+                __declspec(dllimport) void* __stdcall GetCurrentProcess();
+                __declspec(dllimport) int __stdcall SetEvent(void*);
+                __declspec(dllimport) int __stdcall ResetEvent(void*);
+# else
+                using ::GetCurrentProcessId;
+                using ::GetCurrentThreadId;
+                using ::GetCurrentThread;
+                using ::GetCurrentProcess;
+                using ::SetEvent;
+                using ::ResetEvent;
+# endif
+            }
+        }
+    }
+}
+#else
+# error "Win32 functions not available"
+#endif

 #include <boost/config/abi_prefix.hpp>

@@ -94,7 +250,7 @@ namespace boost
                ticks_type current_tick64;

                previous_count = (unsigned long) boost::detail::interlocked_read_acquire(&count);
-                current_tick32 = ::boost::detail::winapi::GetTickCount();
+                current_tick32 = GetTickCount();

                if(previous_count == (unsigned long)-1l)
                {
@@ -146,13 +302,13 @@ namespace boost
                // GetTickCount and GetModuleHandle are not allowed in the Windows Runtime,
                // and kernel32 isn't used in Windows Phone.
 #if BOOST_PLAT_WINDOWS_RUNTIME
-                gettickcount64impl = &::boost::detail::winapi::GetTickCount64;
+                gettickcount64impl = &GetTickCount64;
 #else
                farproc_t addr=GetProcAddress(
 #if !defined(BOOST_NO_ANSI_APIS)
-                    ::boost::detail::winapi::GetModuleHandleA("KERNEL32.DLL"),
+                    GetModuleHandleA("KERNEL32.DLL"),
 #else
-                    ::boost::detail::winapi::GetModuleHandleW(L"KERNEL32.DLL"),
+                    GetModuleHandleW(L"KERNEL32.DLL"),
 #endif
                    "GetTickCount64");
                if(addr)
@@ -185,11 +341,11 @@ namespace boost
                initial_event_state state)
            {
 #if !defined(BOOST_NO_ANSI_APIS)
-                handle const res = ::boost::detail::winapi::CreateEventA(0, type, state, mutex_name);
+                handle const res = win32::CreateEventA(0, type, state, mutex_name);
 #elif BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
-                handle const res = ::boost::detail::winapi::CreateEventW(0, type, state, mutex_name);
+                handle const res = win32::CreateEventW(0, type, state, mutex_name);
 #else
-                handle const res = ::boost::detail::winapi::CreateEventExW(
+                handle const res = win32::CreateEventExW(
                    0,
                    mutex_name,
                    type ? create_event_manual_reset : 0 | state ? create_event_initial_set : 0,
@@ -211,12 +367,12 @@ namespace boost
            inline handle create_anonymous_semaphore_nothrow(long initial_count,long max_count)
            {
 #if !defined(BOOST_NO_ANSI_APIS)
-                handle const res=::boost::detail::winapi::CreateSemaphoreA(0,initial_count,max_count,0);
+                handle const res=win32::CreateSemaphoreA(0,initial_count,max_count,0);
 #else
 #if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
-                handle const res=::boost::detail::winapi::CreateSemaphoreEx(0,initial_count,max_count,0,0);
+                handle const res=win32::CreateSemaphoreEx(0,initial_count,max_count,0,0);
 #else
-                handle const res=::boost::detail::winapi::CreateSemaphoreExW(0,initial_count,max_count,0,0,semaphore_all_access);
+                handle const res=win32::CreateSemaphoreExW(0,initial_count,max_count,0,0,semaphore_all_access);
 #endif
 #endif
                return res;
@@ -234,10 +390,10 @@ namespace boost

            inline handle duplicate_handle(handle source)
            {
-                handle const current_process=::boost::detail::winapi::GetCurrentProcess();
+                handle const current_process=GetCurrentProcess();
                long const same_access_flag=2;
                handle new_handle=0;
-                bool const success=::boost::detail::winapi::DuplicateHandle(current_process,source,current_process,&new_handle,0,false,same_access_flag)!=0;
+                bool const success=DuplicateHandle(current_process,source,current_process,&new_handle,0,false,same_access_flag)!=0;
                if(!success)
                {
                    boost::throw_exception(thread_resource_error());
@@ -247,15 +403,15 @@ namespace boost

            inline void release_semaphore(handle semaphore,long count)
            {
-                BOOST_VERIFY(::boost::detail::winapi::ReleaseSemaphore(semaphore,count,0)!=0);
+                BOOST_VERIFY(ReleaseSemaphore(semaphore,count,0)!=0);
            }

            inline void get_system_info(system_info *info)
            {
 #if BOOST_PLAT_WINDOWS_RUNTIME
-                ::boost::detail::winapi::GetNativeSystemInfo(info);
+                win32::GetNativeSystemInfo(info);
 #else
-                ::boost::detail::winapi::GetSystemInfo(info);
+                win32::GetSystemInfo(info);
 #endif
            }

@@ -266,15 +422,15 @@ namespace boost
 #if BOOST_PLAT_WINDOWS_RUNTIME
                    std::this_thread::yield();
 #else
-                    ::boost::detail::winapi::Sleep(0);
+                    ::boost::detail::win32::Sleep(0);
 #endif
                }
                else
                {
 #if BOOST_PLAT_WINDOWS_RUNTIME
-                    ::boost::detail::winapi::WaitForSingleObjectEx(::boost::detail::winapi::GetCurrentThread(), milliseconds, 0);
+                    ::boost::detail::win32::WaitForSingleObjectEx(::boost::detail::win32::GetCurrentThread(), milliseconds, 0);
 #else
-                    ::boost::detail::winapi::Sleep(milliseconds);
+                    ::boost::detail::win32::Sleep(milliseconds);
 #endif
                }
            }
@@ -290,7 +446,7 @@ namespace boost
                {
                    if (m_completionHandle != ::boost::detail::win32::invalid_handle_value)
                    {
-                        ::boost::detail::winapi::CloseHandle(m_completionHandle);
+                        CloseHandle(m_completionHandle);
                    }
                }

@@ -318,7 +474,7 @@ namespace boost
                {
                    if(handle_to_manage && handle_to_manage!=invalid_handle_value)
                    {
-                        BOOST_VERIFY(::boost::detail::winapi::CloseHandle(handle_to_manage));
+                        BOOST_VERIFY(CloseHandle(handle_to_manage));
                    }
                }

--- a/src/pthread/thread.cpp
+++ b/src/pthread/thread.cpp
@@ -52,7 +52,7 @@ namespace boost
            for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                    i != e; ++i)
            {
-                (*i)->notify_deferred();
+                (*i)->make_ready();
            }
        }

@@ -457,9 +457,9 @@ namespace boost
                }
          }

-          void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts)
+          void BOOST_THREAD_DECL sleep_until(const timespec& ts)
          {
-                timespec now = boost::detail::timespec_now_realtime();
+                timespec now = boost::detail::timespec_now();
                if (boost::detail::timespec_gt(ts, now))
                {
                  for (int foo=0; foo < 5; ++foo)
@@ -479,7 +479,7 @@ namespace boost
                    condition_variable cond;
                    cond.do_wait_until(lock, ts);
    #   endif
-                    timespec now2 = boost::detail::timespec_now_realtime();
+                    timespec now2 = boost::detail::timespec_now();
                    if (boost::detail::timespec_ge(now2, ts))
                    {
                      return;
@@ -487,6 +487,7 @@ namespace boost
                  }
                }
          }
+
        }
      }
      namespace hidden
@@ -506,7 +507,7 @@ namespace boost
            }
        }

-        void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts)
+        void BOOST_THREAD_DECL sleep_until(const timespec& ts)
        {
            boost::detail::thread_data_base* const thread_info=boost::detail::get_current_thread_data();

@@ -517,7 +518,7 @@ namespace boost
            }
            else
            {
-              boost::this_thread::no_interruption_point::hidden::sleep_until_realtime(ts);
+              boost::this_thread::no_interruption_point::hidden::sleep_until(ts);
            }
        }
      } // hidden
--- a/src/win32/thread.cpp
+++ b/src/win32/thread.cpp
@@ -57,7 +57,7 @@ namespace boost
        for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                i != e; ++i)
        {
-            (*i)->notify_deferred();
+            (*i)->make_ready();
        }
    }
  }
@@ -508,7 +508,7 @@ namespace boost
    bool thread::interruption_requested() const BOOST_NOEXCEPT
    {
        detail::thread_data_ptr local_thread_info=(get_thread_info)();
-        return local_thread_info.get() && (detail::winapi::WaitForSingleObjectEx(local_thread_info->interruption_handle,0,0)==0);
+        return local_thread_info.get() && (detail::win32::WaitForSingleObjectEx(local_thread_info->interruption_handle,0,0)==0);
    }

 #endif
@@ -738,7 +738,7 @@ namespace boost

                if(handle_count)
                {
-                    unsigned long const notified_index=detail::winapi::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
+                    unsigned long const notified_index=detail::win32::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
                    if(notified_index<handle_count)
                    {
                        if(notified_index==wait_handle_index)
@@ -748,7 +748,7 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                        else if(notified_index==interruption_index)
                        {
-                            detail::winapi::ResetEvent(detail::get_current_thread_data()->interruption_handle);
+                            detail::win32::ResetEvent(detail::get_current_thread_data()->interruption_handle);
                            throw thread_interrupted();
                        }
 #endif
@@ -823,7 +823,7 @@ namespace boost

                if(handle_count)
                {
-                    unsigned long const notified_index=detail::winapi::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
+                    unsigned long const notified_index=detail::win32::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
                    if(notified_index<handle_count)
                    {
                        if(notified_index==wait_handle_index)
@@ -860,7 +860,7 @@ namespace boost
                return current_thread_data->id;
            }
 #endif
-            return detail::winapi::GetCurrentThreadId();
+            return detail::win32::GetCurrentThreadId();
 #else
            return thread::id(get_or_make_current_thread_data());
 #endif
@@ -871,7 +871,7 @@ namespace boost
        {
            if(interruption_enabled() && interruption_requested())
            {
-                detail::winapi::ResetEvent(detail::get_current_thread_data()->interruption_handle);
+                detail::win32::ResetEvent(detail::get_current_thread_data()->interruption_handle);
                throw thread_interrupted();
            }
        }
@@ -883,7 +883,7 @@ namespace boost

        bool interruption_requested() BOOST_NOEXCEPT
        {
-            return detail::get_current_thread_data() && (detail::winapi::WaitForSingleObjectEx(detail::get_current_thread_data()->interruption_handle,0,0)==0);
+            return detail::get_current_thread_data() && (detail::win32::WaitForSingleObjectEx(detail::get_current_thread_data()->interruption_handle,0,0)==0);
        }
 #endif

--- a/src/win32/tss_pe.cpp
+++ b/src/win32/tss_pe.cpp
@@ -10,7 +10,7 @@
 #include <boost/detail/winapi/config.hpp>
 #include <boost/thread/detail/config.hpp>

-#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB)
+#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB) 

 #if (defined(__MINGW32__) && !defined(_WIN64)) || defined(__MINGW64__) || (__MINGW64_VERSION_MAJOR)

@@ -39,7 +39,7 @@ namespace {
    }
 }

-#if defined(__MINGW64__) || (__MINGW64_VERSION_MAJOR) || (__MINGW32__) || (__MINGW32_MAJOR_VERSION >3) ||   \
+#if defined(__MINGW64__) || (__MINGW64_VERSION_MAJOR) || (__MINGW32_MAJOR_VERSION >3) ||             \
    ((__MINGW32_MAJOR_VERSION==3) && (__MINGW32_MINOR_VERSION>=18))
 extern "C"
 {
@@ -111,27 +111,15 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU


    //Definitions required by implementation
-    #if (_MSC_VER < 1300) || ((_MSC_VER > 1900) && (_MSC_VER < 1910)) // 1300 == VC++ 7.0, 1900 == VC++ 14.0, 1910 == VC++ 2017
-        typedef void ( __cdecl *_PVFV_ )();
-        typedef void ( __cdecl *_PIFV_ )();
-        #define INIRETSUCCESS_V
-        #define INIRETSUCCESS_I
-        #define PVAPI_V void __cdecl
-        #define PVAPI_I void __cdecl
-    #elif (_MSC_VER >= 1910)
-        typedef void ( __cdecl *_PVFV_ )();
-        typedef int ( __cdecl *_PIFV_ )();
-        #define INIRETSUCCESS_V
-        #define INIRETSUCCESS_I 0
-        #define PVAPI_V void __cdecl
-        #define PVAPI_I int __cdecl
+
+    #if (_MSC_VER < 1300) || (_MSC_VER > 2000) // 1300 == VC++ 7.0, 1900 == VC++ 14.0
+        typedef void (__cdecl *_PVFV)();
+        #define INIRETSUCCESS
+        #define PVAPI void __cdecl
    #else
-        typedef int ( __cdecl *_PVFV_ )();
-        typedef int ( __cdecl *_PIFV_ )();
-        #define INIRETSUCCESS_V 0
-        #define INIRETSUCCESS_I 0
-        #define PVAPI_V int __cdecl
-        #define PVAPI_I int __cdecl
+        typedef int (__cdecl *_PVFV)();
+        #define INIRETSUCCESS 0
+        #define PVAPI int __cdecl
    #endif

    typedef void (NTAPI* _TLSCB)(HINSTANCE, DWORD, PVOID);
@@ -148,9 +136,9 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
    {
        //Forward declarations

-        static PVAPI_I on_tls_prepare();
-        static PVAPI_V on_process_init();
-        static PVAPI_V on_process_term();
+        static PVAPI on_tls_prepare();
+        static PVAPI on_process_init();
+        static PVAPI on_process_term();
        static void NTAPI on_tls_callback(HINSTANCE, DWORD, PVOID);

        //The .CRT$Xxx information is taken from Codeguru:
@@ -162,9 +150,9 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
 #pragma section(".CRT$XTU",long,read)
 #pragma section(".CRT$XLC",long,read)
        __declspec(allocate(".CRT$XLC")) _TLSCB __xl_ca=on_tls_callback;
-        __declspec(allocate(".CRT$XIU"))_PIFV_ p_tls_prepare = on_tls_prepare;
-        __declspec(allocate(".CRT$XCU"))_PVFV_ p_process_init = on_process_init;
-        __declspec(allocate(".CRT$XTU"))_PVFV_ p_process_term = on_process_term;
+        __declspec(allocate(".CRT$XIU"))_PVFV p_tls_prepare = on_tls_prepare;
+        __declspec(allocate(".CRT$XCU"))_PVFV p_process_init = on_process_init;
+        __declspec(allocate(".CRT$XTU"))_PVFV p_process_term = on_process_term;
 #else
        #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
        #   pragma data_seg(push, old_seg)
@@ -176,13 +164,13 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
            //this could be changed easily if required.

            #pragma data_seg(".CRT$XIU")
-            static _PIFV_ p_tls_prepare = on_tls_prepare;
+            static _PVFV p_tls_prepare = on_tls_prepare;
            #pragma data_seg()

            //Callback after all global ctors.

            #pragma data_seg(".CRT$XCU")
-            static _PVFV_ p_process_init = on_process_init;
+            static _PVFV p_process_init = on_process_init;
            #pragma data_seg()

            //Callback for tls notifications.
@@ -193,7 +181,7 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
            //Callback for termination.

            #pragma data_seg(".CRT$XTU")
-            static _PVFV_ p_process_term = on_process_term;
+            static _PVFV p_process_term = on_process_term;
            #pragma data_seg()
        #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
        #   pragma data_seg(pop, old_seg)
@@ -205,7 +193,7 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
 #pragma warning(disable:4189)
 #endif

-        PVAPI_I on_tls_prepare()
+        PVAPI on_tls_prepare()
        {
            //The following line has an important side effect:
            //if the TLS directory is not already there, it will
@@ -240,13 +228,13 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
                *pfdst = 0;
            #endif

-            return INIRETSUCCESS_I;
+            return INIRETSUCCESS;
        }
 #ifdef BOOST_MSVC
 #pragma warning(pop)
 #endif

-        PVAPI_V on_process_init()
+        PVAPI on_process_init()
        {
            //Schedule on_thread_exit() to be called for the main
            //thread before destructors of global objects have been
@@ -263,13 +251,13 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU

            boost::on_process_enter();

-            return INIRETSUCCESS_V;
+            return INIRETSUCCESS;
        }

-        PVAPI_V on_process_term()
+        PVAPI on_process_term()
        {
            boost::on_process_exit();
-            return INIRETSUCCESS_V;
+            return INIRETSUCCESS;
        }

        void NTAPI on_tls_callback(HINSTANCE /*h*/, DWORD dwReason, PVOID /*pv*/)
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -964,11 +964,10 @@ rule thread-compile ( sources : reqs * : name )
          #[ thread-run test_11256.cpp ] 
          #[ thread-run test_11256.cpp ]
          #[ thread-run test_11499.cpp ]
-          #[ thread-run test_11611.cpp ]
+          [ thread-run test_11611.cpp ]
          #[ thread-run test_11818.cpp ]
          #[ thread-run test_11796.cpp ]
-          #[ thread-run test_12293.cpp ]
-          [ thread-run test_12949.cpp ]
+          [ thread-run test_12293.cpp ]
          
    ;

--- a/test/sync/conditions/condition_variable/wait_for_pass.cpp
+++ b/test/sync/conditions/condition_variable/wait_for_pass.cpp
@@ -22,7 +22,6 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <cassert>

 #if defined BOOST_THREAD_USES_CHRONO

@@ -36,39 +35,33 @@ int runs = 0;

 void f()
 {
-  try {
-    typedef boost::chrono::steady_clock Clock;
-    typedef boost::chrono::milliseconds milliseconds;
-    boost::unique_lock<boost::mutex> lk(mut);
-    assert(test2 == 0);
-    test1 = 1;
-    cv.notify_one();
-    Clock::time_point t0 = Clock::now();
-    int count=0;
-    while (test2 == 0 && cv.wait_for(lk, milliseconds(250)) == boost::cv_status::no_timeout)
-      count++;
-    Clock::time_point t1 = Clock::now();
-    if (runs == 0)
-    {
-      assert(t1 - t0 < milliseconds(250));
-      assert(test2 != 0);
-    }
-    else
-    {
-      // This test is spurious as it depends on the time the thread system switches the threads
-      assert(t1 - t0 - milliseconds(250) < milliseconds(count*250+5+1000));
-      assert(test2 == 0);
-    }
-    ++runs;
-  } catch(...) {
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
-    assert(false);
+  typedef boost::chrono::steady_clock Clock;
+  typedef boost::chrono::milliseconds milliseconds;
+  boost::unique_lock<boost::mutex> lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  int count=0;
+  while (test2 == 0 && cv.wait_for(lk, milliseconds(250)) == boost::cv_status::no_timeout)
+    count++;
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    BOOST_TEST(t1 - t0 < milliseconds(250));
+    BOOST_TEST(test2 != 0);
  }
+  else
+  {
+    // This test is spurious as it depends on the time the thread system switches the threads
+    BOOST_TEST(t1 - t0 - milliseconds(250) < milliseconds(count*250+5+1000));
+    BOOST_TEST(test2 == 0);
+  }
+  ++runs;
 }

 int main()
 {
-  try
  {
    boost::unique_lock<boost::mutex> lk(mut);
    boost::thread t(f);
@@ -80,13 +73,9 @@ int main()
    lk.unlock();
    cv.notify_one();
    t.join();
-  } catch(...) {
-      std::cout << "ERROR exception" << __LINE__ << std::endl;
-      BOOST_TEST(false);
  }
  test1 = 0;
  test2 = 0;
-  try
  {
    boost::unique_lock<boost::mutex> lk(mut);
    boost::thread t(f);
@@ -96,10 +85,8 @@ int main()
    BOOST_TEST(test1 != 0);
    lk.unlock();
    t.join();
-  } catch(...) {
-      BOOST_TEST(false);
-      std::cout << "ERROR exception" << __LINE__ << std::endl;
  }
+
  return boost::report_errors();
 }
 #else
--- a/test/sync/conditions/condition_variable/wait_for_pred_pass.cpp
+++ b/test/sync/conditions/condition_variable/wait_for_pred_pass.cpp
@@ -21,8 +21,6 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <cassert>
-#include <iostream>

 #if defined BOOST_THREAD_USES_CHRONO

@@ -51,40 +49,34 @@ int runs = 0;

 void f()
 {
-  try {
-    typedef boost::chrono::system_clock Clock;
-    typedef boost::chrono::milliseconds milliseconds;
-    boost::unique_lock < boost::mutex > lk(mut);
-    assert(test2 == 0);
-    test1 = 1;
-    cv.notify_one();
-    Clock::time_point t0 = Clock::now();
-    int count=0;
-    //bool r =
-        (void)cv.wait_for(lk, milliseconds(250), Pred(test2));
-    count++;
-    Clock::time_point t1 = Clock::now();
-    if (runs == 0)
-    {
-      // This test is spurious as it depends on the time the thread system switches the threads
-      assert(t1 - t0 < milliseconds(250+1000));
-      assert(test2 != 0);
-    }
-    else
-    {
-      assert(t1 - t0 - milliseconds(250) < milliseconds(count*250+2));
-      assert(test2 == 0);
-    }
-    ++runs;
-  } catch(...) {
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
-    assert(false);
+  typedef boost::chrono::system_clock Clock;
+  typedef boost::chrono::milliseconds milliseconds;
+  boost::unique_lock < boost::mutex > lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  int count=0;
+  //bool r =
+      (void)cv.wait_for(lk, milliseconds(250), Pred(test2));
+  count++;
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    // This test is spurious as it depends on the time the thread system switches the threads
+    BOOST_TEST(t1 - t0 < milliseconds(250+1000));
+    BOOST_TEST(test2 != 0);
  }
+  else
+  {
+    BOOST_TEST(t1 - t0 - milliseconds(250) < milliseconds(count*250+2));
+    BOOST_TEST(test2 == 0);
+  }
+  ++runs;
 }

 int main()
 {
-  try
  {
    boost::unique_lock < boost::mutex > lk(mut);
    boost::thread t(f);
@@ -96,13 +88,9 @@ int main()
    lk.unlock();
    cv.notify_one();
    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
  }
  test1 = 0;
  test2 = 0;
-  try
  {
    boost::unique_lock < boost::mutex > lk(mut);
    boost::thread t(f);
@@ -112,9 +100,6 @@ int main()
    BOOST_TEST(test1 != 0);
    lk.unlock();
    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
  }

  return boost::report_errors();
--- a/test/sync/conditions/condition_variable/wait_pass.cpp
+++ b/test/sync/conditions/condition_variable/wait_pass.cpp
@@ -17,13 +17,11 @@

 // void wait(unique_lock<mutex>& lock);

-
+#include <iostream>
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <cassert>
-#include <iostream>

 #if defined BOOST_THREAD_USES_CHRONO

@@ -37,40 +35,31 @@ int runs = 0;

 void f()
 {
-  try {
-    boost::unique_lock<boost::mutex> lk(mut);
-    assert(test2 == 0);
-    test1 = 1;
-    cv.notify_one();
-    while (test2 == 0) {
-        cv.wait(lk);
-    }
-    assert(test2 != 0);
-  } catch(...) {
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
-    assert(false);
+  boost::unique_lock<boost::mutex> lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  while (test2 == 0) {
+      cv.wait(lk);
  }
+  BOOST_TEST(test2 != 0);
 }

 int main()
 {
-  try {
-    boost::unique_lock<boost::mutex>lk(mut);
-    boost::thread t(f);
-    BOOST_TEST(test1 == 0);
-    while (test1 == 0)
-    {
-        cv.wait(lk);
-    }
-    BOOST_TEST(test1 != 0);
-    test2 = 1;
-    lk.unlock();
-    cv.notify_one();
-    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
+  boost::unique_lock<boost::mutex>lk(mut);
+  boost::thread t(f);
+  BOOST_TEST(test1 == 0);
+  while (test1 == 0)
+  {
+      cv.wait(lk);
  }
+  BOOST_TEST(test1 != 0);
+  test2 = 1;
+  lk.unlock();
+  cv.notify_one();
+  t.join();
+
  return boost::report_errors();
 }
 #else
--- a/test/sync/conditions/condition_variable/wait_until_pass.cpp
+++ b/test/sync/conditions/condition_variable/wait_until_pass.cpp
@@ -21,8 +21,6 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <iostream>
-#include <cassert>

 #if defined BOOST_THREAD_USES_CHRONO

@@ -51,38 +49,32 @@ int runs = 0;

 void f()
 {
-  try {
-    boost::unique_lock < boost::mutex > lk(mut);
-    assert(test2 == 0);
-    test1 = 1;
-    cv.notify_one();
-    Clock::time_point t0 = Clock::now();
-    Clock::time_point t = t0 + Clock::duration(250);
-    int count=0;
-    while (test2 == 0 && cv.wait_until(lk, t) == boost::cv_status::no_timeout)
-      count++;
-    Clock::time_point t1 = Clock::now();
-    if (runs == 0)
-    {
-      assert(t1 - t0 < Clock::duration(250));
-      assert(test2 != 0);
-    }
-    else
-    {
-      // This test is spurious as it depends on the time the thread system switches the threads
-      assert(t1 - t0 - Clock::duration(250) < Clock::duration(count*250+5+1000));
-      assert(test2 == 0);
-    }
-    ++runs;
-  } catch(...) {
-      assert(false);
-      std::cout << "ERROR exception" << __LINE__ << std::endl;
+  boost::unique_lock < boost::mutex > lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  Clock::time_point t = t0 + Clock::duration(250);
+  int count=0;
+  while (test2 == 0 && cv.wait_until(lk, t) == boost::cv_status::no_timeout)
+    count++;
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    BOOST_TEST(t1 - t0 < Clock::duration(250));
+    BOOST_TEST(test2 != 0);
  }
+  else
+  {
+    // This test is spurious as it depends on the time the thread system switches the threads
+    BOOST_TEST(t1 - t0 - Clock::duration(250) < Clock::duration(count*250+5+1000));
+    BOOST_TEST(test2 == 0);
+  }
+  ++runs;
 }

 int main()
 {
-  try
  {
    boost::unique_lock < boost::mutex > lk(mut);
    boost::thread t(f);
@@ -94,14 +86,9 @@ int main()
    lk.unlock();
    cv.notify_one();
    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
  }
-
  test1 = 0;
  test2 = 0;
-  try
  {
    boost::unique_lock < boost::mutex > lk(mut);
    boost::thread t(f);
@@ -111,9 +98,6 @@ int main()
    BOOST_TEST(test1 != 0);
    lk.unlock();
    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
  }

  return boost::report_errors();
--- a/test/sync/conditions/condition_variable/wait_until_pred_pass.cpp
+++ b/test/sync/conditions/condition_variable/wait_until_pred_pass.cpp
@@ -21,8 +21,6 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-#include <cassert>
-#include <iostream>

 #if defined BOOST_THREAD_USES_CHRONO

@@ -66,37 +64,31 @@ int runs = 0;

 void f()
 {
-  try {
-    boost::unique_lock<boost::mutex> lk(mut);
-    assert(test2 == 0);
-    test1 = 1;
-    cv.notify_one();
-    Clock::time_point t0 = Clock::now();
-    Clock::time_point t = t0 + Clock::duration(250);
-    bool r = cv.wait_until(lk, t, Pred(test2));
-    Clock::time_point t1 = Clock::now();
-    if (runs == 0)
-    {
-      assert(t1 - t0 < Clock::duration(250));
-      assert(test2 != 0);
-      assert(r);
-    }
-    else
-    {
-      assert(t1 - t0 - Clock::duration(250) < Clock::duration(250+2));
-      assert(test2 == 0);
-      assert(!r);
-    }
-    ++runs;
-  } catch(...) {
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
-    assert(false);
+  boost::unique_lock<boost::mutex> lk(mut);
+  BOOST_TEST(test2 == 0);
+  test1 = 1;
+  cv.notify_one();
+  Clock::time_point t0 = Clock::now();
+  Clock::time_point t = t0 + Clock::duration(250);
+  bool r = cv.wait_until(lk, t, Pred(test2));
+  Clock::time_point t1 = Clock::now();
+  if (runs == 0)
+  {
+    BOOST_TEST(t1 - t0 < Clock::duration(250));
+    BOOST_TEST(test2 != 0);
+    BOOST_TEST(r);
  }
+  else
+  {
+    BOOST_TEST(t1 - t0 - Clock::duration(250) < Clock::duration(250+2));
+    BOOST_TEST(test2 == 0);
+    BOOST_TEST(!r);
+  }
+  ++runs;
 }

 int main()
 {
-  try
  {
    boost::unique_lock<boost::mutex> lk(mut);
    boost::thread t(f);
@@ -108,13 +100,9 @@ int main()
    lk.unlock();
    cv.notify_one();
    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
  }
  test1 = 0;
  test2 = 0;
-  try
  {
    boost::unique_lock<boost::mutex> lk(mut);
    boost::thread t(f);
@@ -124,9 +112,6 @@ int main()
    BOOST_TEST(test1 != 0);
    lk.unlock();
    t.join();
-  } catch(...) {
-    BOOST_TEST(false);
-    std::cout << "ERROR exception" << __LINE__ << std::endl;
  }

  return boost::report_errors();
--- a/test/sync/mutual_exclusion/sync_bounded_queue/single_thread_pass.cpp
+++ b/test/sync/mutual_exclusion/sync_bounded_queue/single_thread_pass.cpp
@@ -89,15 +89,12 @@ int main()
  }
  {
    // empty queue push rvalue succeeds
-      boost::sync_bounded_queue<int> q(3);
+      boost::sync_bounded_queue<int> q(2);
      q.push(1);
-      BOOST_TEST_EQ(q.size(), 1u);
      q.push(2);
-      BOOST_TEST_EQ(q.size(), 2u);
-      q.push(2);
-      BOOST_TEST_EQ(q.size(), 3u);
      BOOST_TEST(! q.empty());
      BOOST_TEST( q.full());
+      BOOST_TEST_EQ(q.size(), 2u);
      BOOST_TEST(! q.closed());
  }
  {
@@ -320,15 +317,12 @@ int main()
  }
  {
    // empty queue push rvalue succeeds
-      boost::sync_bounded_queue<int> q(3);
+      boost::sync_bounded_queue<int> q(2);
      q.push_back(1);
-      BOOST_TEST_EQ(q.size(), 1u);
      q.push_back(2);
-      BOOST_TEST_EQ(q.size(), 2u);
-      q.push_back(3);
-      BOOST_TEST_EQ(q.size(), 3u);
      BOOST_TEST(! q.empty());
      BOOST_TEST( q.full());
+      BOOST_TEST_EQ(q.size(), 2u);
      BOOST_TEST(! q.closed());
  }
  {
--- a/test/test_12949.cpp
+++ b/test/test_12949.cpp
@@ -1,21 +0,0 @@
-// Copyright (C) 2017 Vicente Botet
-//
-//  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)
-
-#define BOOST_THREAD_VERSION 4
-//#define BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-
-//#include <boost/thread/thread.hpp>
-#include <boost/thread/condition_variable.hpp>
-
-void f()
-{
-    boost::this_thread::sleep_for(boost::chrono::milliseconds(10)); // **
-}
-int main()
-{
-
-  return 0;
-}
-
--- a/test/test_9856.cpp
+++ b/test/test_9856.cpp
@@ -6,7 +6,7 @@ using namespace boost;

 int main() {
    atomic<size_t> total(0), failures(0);
-
+    
 #pragma omp parallel shared(total, failures) num_threads(1000)
    {
      mutex mtx;
@@ -20,10 +20,10 @@ int main() {
    }
    if(failures)
      std::cout << "There were " << failures << " failures out of " << total << " timed waits." << std::endl;
-    if((100*failures)/total>40)
+    if((100*failures)/total>10)
    {
      std::cerr << "This exceeds 10%, so failing the test." << std::endl;
      return 1;
    }
    return 0;
-}
+}
--- a/test/test_once.cpp
+++ b/test/test_once.cpp
@@ -11,7 +11,6 @@
 #include <boost/thread/thread.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/once.hpp>
-#include <iostream>

 #define LOG \
  if (false) {} else std::cout << std::endl << __FILE__ << "[" << __LINE__ << "]"
--- a/test/test_shared_mutex.cpp
+++ b/test/test_shared_mutex.cpp
@@ -12,7 +12,6 @@
 #include <boost/thread/xtime.hpp>
 #include "./util.inl"
 #include "./shared_mutex_locking_thread.hpp"
-#include <iostream>

 #define CHECK_LOCKED_VALUE_EQUAL(mutex_name,value,expected_value)    \
    {                                                                \
--- a/test/threads/thread/constr/FArgs_pass.cpp
+++ b/test/threads/thread/constr/FArgs_pass.cpp
@@ -26,11 +26,9 @@
 unsigned throw_one = 0xFFFF;

 #if defined _GLIBCXX_THROW
-void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
+inline void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
 #elif defined BOOST_MSVC
-void* operator new(std::size_t s)
-#elif __cplusplus > 201402L
-void* operator new(std::size_t s)
+inline void* operator new(std::size_t s)
 #else
 void* operator new(std::size_t s) throw (std::bad_alloc)
 #endif
@@ -42,9 +40,9 @@ void* operator new(std::size_t s) throw (std::bad_alloc)
 }

 #if defined BOOST_MSVC
-void operator delete(void* p)
+inline void operator delete(void* p)
 #else
-void operator delete(void* p) BOOST_NOEXCEPT_OR_NOTHROW
+inline void operator delete(void* p) throw ()
 #endif
 {
  //std::cout << __FILE__ << ":" << __LINE__ << std::endl;
--- a/test/threads/thread/constr/F_pass.cpp
+++ b/test/threads/thread/constr/F_pass.cpp
@@ -29,8 +29,6 @@ unsigned throw_one = 0xFFFF;
 void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
 #elif defined BOOST_MSVC
 void* operator new(std::size_t s)
-#elif __cplusplus > 201402L
-void* operator new(std::size_t s)
 #else
 void* operator new(std::size_t s) throw (std::bad_alloc)
 #endif
@@ -44,7 +42,7 @@ void* operator new(std::size_t s) throw (std::bad_alloc)
 #if defined BOOST_MSVC
 void operator delete(void* p)
 #else
-void operator delete(void* p) BOOST_NOEXCEPT_OR_NOTHROW
+void operator delete(void* p) throw ()
 #endif
 {
  //std::cout << __FILE__ << ":" << __LINE__ << std::endl;
--- a/test/threads/thread/constr/lambda_pass.cpp
+++ b/test/threads/thread/constr/lambda_pass.cpp
@@ -28,11 +28,9 @@
 unsigned throw_one = 0xFFFF;

 #if defined _GLIBCXX_THROW
-void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
+inline void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
 #elif defined BOOST_MSVC
-void* operator new(std::size_t s)
-#elif __cplusplus > 201402L
-void* operator new(std::size_t s)
+inline void* operator new(std::size_t s)
 #else
 void* operator new(std::size_t s) throw (std::bad_alloc)
 #endif
@@ -43,9 +41,9 @@ void* operator new(std::size_t s) throw (std::bad_alloc)
 }

 #if defined BOOST_MSVC
-void operator delete(void* p)
+inline void operator delete(void* p)
 #else
-void operator delete(void* p) BOOST_NOEXCEPT_OR_NOTHROW
+inline void operator delete(void* p) throw ()
 #endif
 {
  std::free(p);
Author	SHA1	Message	Date
Vicente J. Botet Escriba	5363e099e4	Merge branch 'develop'	2017-03-03 07:28:59 +01:00
Vicente J. Botet Escriba	f79d51f099	Merge branch 'develop'	2017-02-25 13:57:19 +01:00
Vicente J. Botet Escriba	336259c36a	Merge branch 'develop'	2017-02-19 11:27:10 +01:00
Vicente J. Botet Escriba	3391bf87c6	Merge branch 'master' of github.com:boostorg/thread	2016-11-06 16:16:03 +01:00
Vicente J. Botet Escriba	bc6b31e1f7	Merge branch 'develop'	2016-11-05 23:39:19 +01:00
Vicente J. Botet Escriba	84720b7664	Merge branch 'develop'	2016-11-05 00:31:01 +01:00
Rene Rivera	7879a4c286	Add, and update, documentation build targets.	2016-10-10 11:39:53 -05:00
Vicente J. Botet Escriba	11f18980ca	Merge branch 'develop'	2016-09-06 20:11:30 +02:00
Vicente J. Botet Escriba	12e2c8aaca	Merge branch 'develop'	2016-09-06 18:50:21 +02:00
Vicente J. Botet Escriba	046d716bbf	Merge branch 'develop'	2016-09-03 21:17:42 +02:00
Vicente J. Botet Escriba	5b9c1fad85	Merge branch 'develop'	2016-09-02 07:27:09 +02:00
Vicente J. Botet Escriba	58c6b384cc	Merge branch 'develop'	2016-08-16 23:02:52 +02:00
Vicente J. Botet Escriba	7c1570328e	Merge branch 'develop'	2016-08-15 11:54:35 +02:00
Vicente J. Botet Escriba	97895e410f	merge from develop.	2016-08-09 01:14:41 +02:00
Vicente J. Botet Escriba	2494f3fc7a	Apply manualy fixes on develop concerning memory leak os tss and scoped_thread move assignement.	2016-04-24 01:05:45 +02:00
Vicente J. Botet Escriba	159868ac77	Merge branch 'develop'	2016-04-01 00:27:18 +02:00
Vicente J. Botet Escriba	f65e89a85a	Merge branch 'develop'	2016-04-01 00:20:44 +02:00
Vicente J. Botet Escriba	bb47c16939	Merge branch 'develop'	2016-03-28 23:12:48 +02:00
Vicente J. Botet Escriba	02fd2d041b	Merge branch 'develop'	2016-03-08 07:55:45 +01:00
Vicente J. Botet Escriba	2661c06698	Merge branch 'develop'	2016-02-28 19:30:15 +01:00
Vicente J. Botet Escriba	83f877a238	Merge branch 'develop'	2015-12-08 06:30:55 +01:00
Vicente J. Botet Escriba	47f615d073	Merge branch 'develop'	2015-12-07 22:04:51 +01:00
Vicente J. Botet Escriba	7079a80edf	Merge branch 'develop'	2015-11-24 23:03:35 +01:00
Vicente J. Botet Escriba	dbf28a4ac4	Merge branch 'develop'	2015-11-15 00:02:15 +01:00
Vicente J. Botet Escriba	2866734b15	Merge branch 'develop'	2015-10-29 11:33:17 +01:00