Add -j3 to .travis.yml to reduce build time and avoid timeouts

Merge branch 'develop' of github.com:boostorg/thread into develop
reduce the number of travis jobs.
2026-02-03 09:42:16 +00:00 · 2017-09-10 13:46:44 +03:00 · 2017-09-09 18:42:58 +02:00 · 2017-09-09 18:42:23 +02:00 · 2017-09-07 00:56:11 +02:00 · 2017-09-07 00:29:29 +02:00
49 changed files with 1177 additions and 605 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,365 @@
+# 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
@@ -0,0 +1,41 @@
+# 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-16 Vicente J. Botet Escriba.
+  (C) Copyright 2011-17 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,6 +8,49 @@

 [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:]
@@ -27,7 +70,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 trunk 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 master 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 S, typename F>
+      template<typename Ex, 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 S, typename F>
+      template<typename Ex, 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 S, typename F>
+      template<typename Ex, 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.7.2]
+    [version 4.8.0]
    [authors [Williams, Anthony] [Botet Escriba, Vicente J.]]
    [copyright 2007-11 Anthony Williams]
-    [copyright 2011-16 Vicente J. Botet Escriba]
+    [copyright 2011-17 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,6 +17,7 @@
 #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,6 +63,7 @@ int main()
    else
      do_something_in_current_thread();
  }
+#if 0
  {
    int some_local_state=0;
    boost::thread t(( func(some_local_state) ));
@@ -72,6 +73,7 @@ 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 ! defined __clang__
+#if 0
  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 ((out_+capacity(lk)-in_) % capacity(lk));
+      return ((in_+capacity(lk)-out_) % capacity(lk));
    }

    inline void throw_if_closed(unique_lock<mutex>&);
@@ -484,7 +484,9 @@ 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;}
-      wait_until_not_empty(lk);
+      bool is_closed = false;
+      wait_until_not_empty(lk, is_closed);
+      if (is_closed) {return queue_op_status::closed;}
      pull_front(elem, lk);
      return queue_op_status::success;
  }
--- a/include/boost/thread/detail/config.hpp
+++ b/include/boost/thread/detail/config.hpp
@@ -12,21 +12,19 @@
 #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(__GNUC__) && !defined(__INTEL_COMPILER)
+#if !defined(BOOST_NO_MAY_ALIAS)

-  // GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with
-  // regard to violation of the strict aliasing rules.
+  // 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.

  #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,7 +155,15 @@ 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:
@@ -291,7 +299,7 @@ namespace boost
        template <class F>
        explicit thread(F f
        , typename disable_if_c<
-        boost::thread_detail::is_rv<F>::value // todo ass a thread_detail::is_rv
+        boost::thread_detail::is_rv<F>::value // todo as 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
@@ -483,19 +491,13 @@ namespace boost
        }
 #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 {
-            my_clock_t::time_point     s_now = my_clock_t::now();
+            thread_detail::internal_clock_t::time_point     s_now = thread_detail::internal_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);
@@ -503,10 +505,10 @@ namespace boost
          return true;
        }
        template <class Duration>
-        bool try_join_until(const chrono::time_point<my_clock_t, Duration>& t)
+        bool try_join_until(const chrono::time_point<thread_detail::internal_clock_t, Duration>& t)
        {
          using namespace chrono;
-          typedef time_point<my_clock_t, nanoseconds> nano_sys_tmpt;
+          typedef time_point<thread_detail::internal_clock_t, nanoseconds> nano_sys_tmpt;
          return try_join_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
        }
 #endif
@@ -521,7 +523,7 @@ namespace boost
        //}

 #ifdef BOOST_THREAD_USES_CHRONO
-        bool try_join_until(const chrono::time_point<my_clock_t, chrono::nanoseconds>& tp)
+        bool try_join_until(const chrono::time_point<thread_detail::internal_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());
@@ -542,7 +544,7 @@ namespace boost
        }
 #endif
 #ifdef BOOST_THREAD_USES_CHRONO
-        bool try_join_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
+        bool try_join_until(const chrono::time_point<thread_detail::internal_clock_t, 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,11 +86,18 @@ namespace executors
        for(;;)
        {
          work task;
-          queue_op_status st = work_queue.wait_pull(task);
-          if (st == queue_op_status::closed) {
+          try
+          {
+            queue_op_status st = work_queue.wait_pull(task);
+            if (st == queue_op_status::closed) {
+              return;
+            }
+            task();
+          }
+          catch (boost::thread_interrupted&)
+          {
            return;
          }
-          task();
        }
      }
      catch (...)
@@ -234,6 +241,7 @@ 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,10 +57,16 @@ namespace detail
      {
        for(;;)
        {
-          work task;
-          queue_op_status st = _workq.wait_pull(task);
-          if (st == queue_op_status::closed) return;
-          task();
+          try {
+            work task;
+            queue_op_status st = _workq.wait_pull(task);
+            if (st == queue_op_status::closed) return;
+            task();
+          }
+          catch (boost::thread_interrupted&)
+          {
+            return;
+          }
        }
      }
      catch (...)
--- a/include/boost/thread/executors/scheduled_thread_pool.hpp
+++ b/include/boost/thread/executors/scheduled_thread_pool.hpp
@@ -32,6 +32,7 @@ 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,6 +231,7 @@ 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,6 +31,7 @@ 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 make_ready()
+            void notify_deferred()
            {
              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_ != 0 && future_->valid();
+            return future_.get() != 0 && future_->valid();
        }

        void wait() const
@@ -1639,7 +1639,9 @@ 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))))
@@ -1680,7 +1682,7 @@ namespace boost
        // retrieving the value
        move_dest_type get()
        {
-            if (this->future_ == 0)
+            if (this->future_.get() == 0)
            {
                boost::throw_exception(future_uninitialized());
            }
@@ -1700,7 +1702,7 @@ namespace boost
        get_or(BOOST_THREAD_RV_REF(R2) v)
        {

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

            move_dest_type get_or(R const& v) // EXTENSION
            {
-                if (this->future_ == 0)
+                if (this->future_.get() == 0)
                {
                    boost::throw_exception(future_uninitialized());
                }
@@ -4747,7 +4749,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_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4811,7 +4813,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_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4835,7 +4837,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_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4865,7 +4867,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_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4939,7 +4941,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_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4965,7 +4967,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_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());

    // keep state alive as we move ourself but hold the lock
    shared_ptr<detail::shared_state_base> sentinel(this->future_);
@@ -4995,7 +4997,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_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());

    boost::unique_lock<boost::mutex> lock(this->future_->mutex);
    if (underlying_cast<int>(policy) & int(launch::async)) {
@@ -5064,7 +5066,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_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=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,
@@ -5085,7 +5087,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_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=0, future_uninitialized());

    boost::unique_lock<boost::mutex> lock(this->future_->mutex);
    launch policy = this->launch_policy(lock);
@@ -5257,7 +5259,7 @@ namespace detail
  BOOST_THREAD_FUTURE<R2>
  BOOST_THREAD_FUTURE<BOOST_THREAD_FUTURE<R2> >::unwrap()
  {
-    BOOST_THREAD_ASSERT_PRECONDITION(this->future_!=0, future_uninitialized());
+    BOOST_THREAD_ASSERT_PRECONDITION(this->future_.get()!=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,9 +45,17 @@ namespace boost
                m_.unlock();
                m=&m_;
            }
-            ~lock_on_exit()
+            void deactivate()
            {
-                if(m)
+                if (m)
+                {
+                    m->lock();
+                }
+                m = 0;
+            }
+            ~lock_on_exit() BOOST_NOEXCEPT_IF(false)
+            {
+                if (m)
                {
                    m->lock();
                }
@@ -70,10 +78,13 @@ 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();
-#endif
            res = pthread_cond_wait(&cond,the_mutex);
+#endif
        }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
        this_thread::interruption_point();
@@ -101,10 +112,13 @@ 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();
-#endif
            cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
+#endif
        }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
        this_thread::interruption_point();
@@ -176,6 +190,8 @@ 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();
@@ -404,6 +420,8 @@ 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,16 +69,8 @@ namespace boost
            unique_lock<mutex>& lock,
            struct timespec const &timeout)
        {
-#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));
+#if defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
+            return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now_monotonic()));
 #else
            // old behavior was fine for monotonic
            return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now_realtime()));
@@ -90,31 +82,37 @@ namespace boost
        condition_variable()
        {
            int res;
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+//#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.
            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
+//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+                // ditto
                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
+//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+            // ditto
            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,41 +20,47 @@ namespace boost
            pthread_mutex_t* m;
            bool locked;
        public:
-            explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_):
+            explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_) BOOST_NOEXCEPT:
                m(m_),locked(true)
            {
                BOOST_VERIFY(!pthread_mutex_lock(m));
            }
-            void unlock()
+            void unlock() BOOST_NOEXCEPT
            {
                BOOST_VERIFY(!pthread_mutex_unlock(m));
                locked=false;
            }
-            
-            ~pthread_mutex_scoped_lock()
+            void check() BOOST_NOEXCEPT
+            {
+              if(locked)
+              {
+                  unlock();
+              }
+            }
+            ~pthread_mutex_scoped_lock() BOOST_NOEXCEPT
            {
                if(locked)
                {
                    unlock();
                }
            }
-            
+
        };

        class pthread_mutex_scoped_unlock
        {
            pthread_mutex_t* m;
        public:
-            explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_):
+            explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_) BOOST_NOEXCEPT:
                m(m_)
            {
                BOOST_VERIFY(!pthread_mutex_unlock(m));
            }
-            ~pthread_mutex_scoped_unlock()
+            ~pthread_mutex_scoped_unlock() BOOST_NOEXCEPT
            {
                BOOST_VERIFY(!pthread_mutex_lock(m));
            }
-            
+
        };
    }
 }
--- a/include/boost/thread/pthread/shared_mutex.hpp
+++ b/include/boost/thread/pthread/shared_mutex.hpp
@@ -20,7 +20,6 @@
 #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,7 +50,11 @@ 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
@@ -177,6 +181,7 @@ namespace boost
            thread_data_base* const thread_info;
            pthread_mutex_t* m;
            bool set;
+            bool done;

            void check_for_interruption()
            {
@@ -193,7 +198,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)
+                set(thread_info && thread_info->interrupt_enabled), done(false)
            {
                if(set)
                {
@@ -208,9 +213,10 @@ namespace boost
                    BOOST_VERIFY(!pthread_mutex_lock(m));
                }
            }
-            ~interruption_checker()
+            void check()
            {
-                if(set)
+              if ( ! done) {
+                if (set)
                {
                    BOOST_VERIFY(!pthread_mutex_unlock(m));
                    lock_guard<mutex> guard(thread_info->data_mutex);
@@ -221,6 +227,13 @@ namespace boost
                {
                    BOOST_VERIFY(!pthread_mutex_unlock(m));
                }
+                done = true;
+              }
+            }
+
+            ~interruption_checker() BOOST_NOEXCEPT_IF(false)
+            {
+                check();
            }
        };
 #endif
@@ -231,10 +244,12 @@ namespace boost
        namespace hidden
        {
          void BOOST_THREAD_DECL sleep_for(const timespec& ts);
-          void BOOST_THREAD_DECL sleep_until(const timespec& ts);
+          void BOOST_THREAD_DECL sleep_until_realtime(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
@@ -250,10 +265,12 @@ namespace boost
          namespace hidden
          {
            void BOOST_THREAD_DECL sleep_for(const timespec& ts);
-            void BOOST_THREAD_DECL sleep_until(const timespec& ts);
+            void BOOST_THREAD_DECL sleep_until_realtime(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
@@ -275,7 +292,7 @@ namespace boost
 #endif
        inline void sleep(system_time const& abs_time)
        {
-          return boost::this_thread::hidden::sleep_until(boost::detail::to_timespec(abs_time));
+          return boost::this_thread::hidden::sleep_until_realtime(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,8 +16,13 @@ namespace boost
        {
            return new T();
        }
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#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
        template<typename T,typename A1>
        inline T* heap_new(A1&& a1)
        {
@@ -61,6 +66,31 @@ 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,32 +71,21 @@ namespace boost
    {
      return (ts.tv_sec >= 0) || (ts.tv_nsec >= 0);
    }
-    inline timespec timespec_now()
+#if defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
+
+    inline timespec timespec_now_monotonic()
    {
      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=win32::GetCurrentThreadId();
+                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
                return try_recursive_lock(current_thread_id) || try_basic_lock(current_thread_id);
            }

            void lock()
            {
-                long const current_thread_id=win32::GetCurrentThreadId();
+                long const current_thread_id=boost::detail::winapi::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=win32::GetCurrentThreadId();
+                long const current_thread_id=boost::detail::winapi::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=win32::GetCurrentThreadId();
+                long const current_thread_id=boost::detail::winapi::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=win32::GetCurrentThreadId();
+                long const current_thread_id=boost::detail::winapi::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)
                {
-                    win32::CloseHandle(old_event);
+                    winapi::CloseHandle(old_event);
                }
            }

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

                    do
                    {
-                        unsigned const retval(win32::WaitForSingleObjectEx(sem, ::boost::detail::win32::infinite,0));
+                        unsigned const retval(winapi::WaitForSingleObjectEx(sem, ::boost::detail::win32::infinite,0));
                        BOOST_VERIFY(0 == retval || ::boost::detail::win32::wait_abandoned == retval);
-//                        BOOST_VERIFY(win32::WaitForSingleObject(
+//                        BOOST_VERIFY(winapi::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(win32::WaitForSingleObjectEx(sem,::boost::detail::get_milliseconds_until(wait_until),0)!=0)
+                        if(winapi::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(win32::WaitForSingleObjectEx(sem,static_cast<unsigned long>(rel_time.count()),0)!=0)
+                      if(winapi::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))
                    {
-                        win32::SetEvent(get_event());
+                        winapi::SetEvent(get_event());
                    }
                }
            }
@@ -256,7 +256,7 @@ namespace boost
 #endif
                    if(old_event!=0)
                    {
-                        win32::CloseHandle(new_event);
+                        winapi::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::win32::ReleaseSemaphore(semaphore,count_to_release,0);
+                detail::winapi::ReleaseSemaphore(semaphore,count_to_release,0);
            }

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

            bool woken()
            {
-                unsigned long const woken_result=detail::win32::WaitForSingleObjectEx(wake_sem,0,0);
+                unsigned long const woken_result=detail::winapi::WaitForSingleObjectEx(wake_sem,0,0);
                BOOST_ASSERT((woken_result==detail::win32::timeout) || (woken_result==0));
                return woken_result==0;
            }
@@ -135,39 +135,45 @@ namespace boost
            void wake_waiters(long count_to_wake)
            {
                detail::interlocked_write_release(&total_count,total_count-count_to_wake);
-                detail::win32::ReleaseSemaphore(wake_sem,count_to_wake,0);
+                detail::winapi::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()
                {
-                    lock.unlock();
-                    unlocked=true;
+                  if ( ! _unlocked )
+                  {
+                    _lock.unlock();
+                    _unlocked=true;
+                  }
                }
-                ~relocker()
+                void lock()
                {
-                    if(unlocked)
-                    {
-                        lock.lock();
-                    }
-
+                  if ( _unlocked )
+                  {
+                    _lock.lock();
+                    _unlocked=false;
+                  }
+                }
+                ~relocker() BOOST_NOEXCEPT_IF(false)
+                {
+                  lock();
                }
            };


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

            struct entry_manager
            {
-                entry_ptr const entry;
+                entry_ptr 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

-                ~entry_manager()
+                void remove_waiter_and_reset()
                {
+                  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->()
@@ -215,23 +235,24 @@ namespace boost
            template<typename lock_type>
            bool do_wait(lock_type& lock,timeout abs_time)
            {
-                relocker<lock_type> locker(lock);
+              relocker<lock_type> locker(lock);
+              entry_manager entry(get_wait_entry(), internal_mutex);
+              locker.unlock();

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

-                locker.unlock();
-
-                bool woken=false;
-                while(!woken)
-                {
-                    if(!entry->wait(abs_time))
-                    {
-                        return false;
-                    }
-
-                    woken=entry->woken();
-                }
-                return woken;
+                  woken=entry->woken();
+              }
+              // do it here to avoid throwing on the destructor
+              entry.remove_waiter_and_reset();
+              locker.lock();
+              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(win32::GetCurrentProcessId(),
+            detail::int_to_string(winapi::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::win32::OpenEventW(
+            return ::boost::detail::winapi::OpenEventW(
 #else
-            return ::boost::detail::win32::OpenEventA(
+            return ::boost::detail::winapi::OpenEventA(
 #endif
                ::boost::detail::win32::synchronize |
                ::boost::detail::win32::event_modify_state,
@@ -186,7 +186,7 @@ namespace boost
            }
            if(ctx.event_handle)
            {
-                ::boost::detail::win32::ResetEvent(ctx.event_handle);
+                ::boost::detail::winapi::ResetEvent(ctx.event_handle);
            }
            return true;
          }
@@ -207,7 +207,7 @@ namespace boost
          }
          if(ctx.event_handle)
          {
-              ::boost::detail::win32::SetEvent(ctx.event_handle);
+              ::boost::detail::winapi::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::win32::SetEvent(ctx.event_handle);
+              ::boost::detail::winapi::SetEvent(ctx.event_handle);
          }
        }
    }
@@ -264,7 +264,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite, 0));
        }
    }
@@ -308,7 +308,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -355,7 +355,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -400,7 +400,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -443,7 +443,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -486,7 +486,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -529,7 +529,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -574,7 +574,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -617,7 +617,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -660,7 +660,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -703,7 +703,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -748,7 +748,7 @@ namespace boost
                        continue;
                    }
                }
-                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                                 ctx.event_handle,::boost::detail::win32::infinite,0));
            }
        }
@@ -793,7 +793,7 @@ namespace boost
                        continue;
                    }
                }
-                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                                 ctx.event_handle,::boost::detail::win32::infinite,0));
            }
        }
@@ -839,7 +839,7 @@ namespace boost
                        continue;
                    }
                }
-                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                                 ctx.event_handle,::boost::detail::win32::infinite,0));
            }
        }
@@ -886,7 +886,7 @@ namespace boost
                        continue;
                    }
                }
-                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                                 ctx.event_handle,::boost::detail::win32::infinite,0));
            }
        }
@@ -930,7 +930,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -977,7 +977,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -1024,7 +1024,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
                             ctx.event_handle,::boost::detail::win32::infinite,0));
        }
    }
@@ -1073,7 +1073,7 @@ namespace boost
                    continue;
                }
            }
-            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::winapi::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::win32::ReleaseSemaphore(semaphores[exclusive_sem],1,0)!=0);
+                BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[exclusive_sem],1,0)!=0);
            }

            if(old_state.shared_waiting || old_state.exclusive_waiting)
            {
-                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+                BOOST_VERIFY(detail::winapi::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::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+                BOOST_VERIFY(detail::winapi::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::win32::CloseHandle(upgrade_sem);
-            detail::win32::CloseHandle(semaphores[unlock_sem]);
-            detail::win32::CloseHandle(semaphores[exclusive_sem]);
+            detail::winapi::CloseHandle(upgrade_sem);
+            detail::winapi::CloseHandle(semaphores[unlock_sem]);
+            detail::winapi::CloseHandle(semaphores[exclusive_sem]);
        }

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

-                unsigned long const res=detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],::boost::detail::get_milliseconds_until(wait_until), 0);
+                unsigned long const res=detail::winapi::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::win32::WaitForSingleObjectEx(semaphores[unlock_sem],
+              res=detail::winapi::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::win32::ReleaseSemaphore(upgrade_sem,1,0)!=0);
+                            BOOST_VERIFY(detail::winapi::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::win32::WaitForMultipleObjectsEx(2,semaphores,wait_all,::boost::detail::get_milliseconds_until(wait_until), 0);
+                unsigned long const wait_res=detail::winapi::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::win32::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
+                          BOOST_VERIFY(detail::winapi::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::win32::WaitForMultipleObjectsEx(2,semaphores,wait_all,
+              wait_res=detail::winapi::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::win32::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
+                  BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
                }
                if(current_state==old_state)
                {
@@ -698,7 +698,7 @@ namespace boost
                    return;
                }

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

@@ -790,7 +790,7 @@ namespace boost
                {
                    if(!last_reader)
                    {
-                        BOOST_VERIFY(!detail::win32::WaitForSingleObjectEx(upgrade_sem,detail::win32::infinite, 0));
+                        BOOST_VERIFY(!detail::winapi::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::win32::SetEvent(interruption_handle)!=0);
+                BOOST_VERIFY(detail::winapi::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,45 +12,7 @@
 #include <boost/throw_exception.hpp>
 #include <boost/core/no_exceptions_support.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/detail/winapi/heap_memory.hpp>

 #include <boost/config/abi_prefix.hpp>

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

        inline void free_raw_heap_memory(void* heap_memory)
        {
-            BOOST_VERIFY(detail::win32::HeapFree(detail::win32::GetProcessHeap(),0,heap_memory)!=0);
+            BOOST_VERIFY(detail::winapi::HeapFree(detail::winapi::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()
        {
@@ -225,6 +204,86 @@ 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>
@@ -384,6 +443,7 @@ 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,6 +17,21 @@
 #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>
@@ -25,200 +40,29 @@
 #include <thread>
 #endif

-#if defined( BOOST_USE_WINDOWS_H )
-# include <windows.h>
-
 namespace boost
 {
    namespace detail
    {
        namespace win32
        {
-            typedef HANDLE handle;
-            typedef SYSTEM_INFO system_info;
+            typedef ::boost::detail::winapi::HANDLE_ handle;
+            typedef ::boost::detail::winapi::SYSTEM_INFO_ system_info;
            typedef unsigned __int64 ticks_type;
-            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;
+            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_;
            unsigned const create_event_initial_set = 0x00000002;
            unsigned const create_event_manual_reset = 0x00000001;
-            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
+            unsigned const event_all_access = ::boost::detail::winapi::EVENT_ALL_ACCESS_;
+            unsigned const semaphore_all_access = boost::detail::winapi::SEMAPHORE_ALL_ACCESS_;
        }
    }
 }
-#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>

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

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

                if(previous_count == (unsigned long)-1l)
                {
@@ -302,13 +146,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 = &GetTickCount64;
+                gettickcount64impl = &::boost::detail::winapi::GetTickCount64;
 #else
                farproc_t addr=GetProcAddress(
 #if !defined(BOOST_NO_ANSI_APIS)
-                    GetModuleHandleA("KERNEL32.DLL"),
+                    ::boost::detail::winapi::GetModuleHandleA("KERNEL32.DLL"),
 #else
-                    GetModuleHandleW(L"KERNEL32.DLL"),
+                    ::boost::detail::winapi::GetModuleHandleW(L"KERNEL32.DLL"),
 #endif
                    "GetTickCount64");
                if(addr)
@@ -341,11 +185,11 @@ namespace boost
                initial_event_state state)
            {
 #if !defined(BOOST_NO_ANSI_APIS)
-                handle const res = win32::CreateEventA(0, type, state, mutex_name);
+                handle const res = ::boost::detail::winapi::CreateEventA(0, type, state, mutex_name);
 #elif BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
-                handle const res = win32::CreateEventW(0, type, state, mutex_name);
+                handle const res = ::boost::detail::winapi::CreateEventW(0, type, state, mutex_name);
 #else
-                handle const res = win32::CreateEventExW(
+                handle const res = ::boost::detail::winapi::CreateEventExW(
                    0,
                    mutex_name,
                    type ? create_event_manual_reset : 0 | state ? create_event_initial_set : 0,
@@ -367,12 +211,12 @@ namespace boost
            inline handle create_anonymous_semaphore_nothrow(long initial_count,long max_count)
            {
 #if !defined(BOOST_NO_ANSI_APIS)
-                handle const res=win32::CreateSemaphoreA(0,initial_count,max_count,0);
+                handle const res=::boost::detail::winapi::CreateSemaphoreA(0,initial_count,max_count,0);
 #else
 #if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
-                handle const res=win32::CreateSemaphoreEx(0,initial_count,max_count,0,0);
+                handle const res=::boost::detail::winapi::CreateSemaphoreEx(0,initial_count,max_count,0,0);
 #else
-                handle const res=win32::CreateSemaphoreExW(0,initial_count,max_count,0,0,semaphore_all_access);
+                handle const res=::boost::detail::winapi::CreateSemaphoreExW(0,initial_count,max_count,0,0,semaphore_all_access);
 #endif
 #endif
                return res;
@@ -390,10 +234,10 @@ namespace boost

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

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

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

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

@@ -474,7 +318,7 @@ namespace boost
                {
                    if(handle_to_manage && handle_to_manage!=invalid_handle_value)
                    {
-                        BOOST_VERIFY(CloseHandle(handle_to_manage));
+                        BOOST_VERIFY(::boost::detail::winapi::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)->make_ready();
+                (*i)->notify_deferred();
            }
        }

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

-          void BOOST_THREAD_DECL sleep_until(const timespec& ts)
+          void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts)
          {
-                timespec now = boost::detail::timespec_now();
+                timespec now = boost::detail::timespec_now_realtime();
                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();
+                    timespec now2 = boost::detail::timespec_now_realtime();
                    if (boost::detail::timespec_ge(now2, ts))
                    {
                      return;
@@ -487,7 +487,6 @@ namespace boost
                  }
                }
          }
-
        }
      }
      namespace hidden
@@ -507,7 +506,7 @@ namespace boost
            }
        }

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

@@ -518,7 +517,7 @@ namespace boost
            }
            else
            {
-              boost::this_thread::no_interruption_point::hidden::sleep_until(ts);
+              boost::this_thread::no_interruption_point::hidden::sleep_until_realtime(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)->make_ready();
+            (*i)->notify_deferred();
        }
    }
  }
@@ -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::win32::WaitForSingleObjectEx(local_thread_info->interruption_handle,0,0)==0);
+        return local_thread_info.get() && (detail::winapi::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::win32::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
+                    unsigned long const notified_index=detail::winapi::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::win32::ResetEvent(detail::get_current_thread_data()->interruption_handle);
+                            detail::winapi::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::win32::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
+                    unsigned long const notified_index=detail::winapi::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::win32::GetCurrentThreadId();
+            return detail::winapi::GetCurrentThreadId();
 #else
            return thread::id(get_or_make_current_thread_data());
 #endif
@@ -871,7 +871,7 @@ namespace boost
        {
            if(interruption_enabled() && interruption_requested())
            {
-                detail::win32::ResetEvent(detail::get_current_thread_data()->interruption_handle);
+                detail::winapi::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::win32::WaitForSingleObjectEx(detail::get_current_thread_data()->interruption_handle,0,0)==0);
+            return detail::get_current_thread_data() && (detail::winapi::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_MAJOR_VERSION >3) ||             \
+#if defined(__MINGW64__) || (__MINGW64_VERSION_MAJOR) || (__MINGW32__) || (__MINGW32_MAJOR_VERSION >3) ||   \
    ((__MINGW32_MAJOR_VERSION==3) && (__MINGW32_MINOR_VERSION>=18))
 extern "C"
 {
@@ -111,15 +111,27 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU


    //Definitions required by implementation
-
-    #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
+    #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
    #else
-        typedef int (__cdecl *_PVFV)();
-        #define INIRETSUCCESS 0
-        #define PVAPI int __cdecl
+        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
    #endif

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

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

        //The .CRT$Xxx information is taken from Codeguru:
@@ -150,9 +162,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"))_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;
+        __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;
 #else
        #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
        #   pragma data_seg(push, old_seg)
@@ -164,13 +176,13 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
            //this could be changed easily if required.

            #pragma data_seg(".CRT$XIU")
-            static _PVFV p_tls_prepare = on_tls_prepare;
+            static _PIFV_ 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.
@@ -181,7 +193,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)
@@ -193,7 +205,7 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
 #pragma warning(disable:4189)
 #endif

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

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

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

            boost::on_process_enter();

-            return INIRETSUCCESS;
+            return INIRETSUCCESS_V;
        }

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

        void NTAPI on_tls_callback(HINSTANCE /*h*/, DWORD dwReason, PVOID /*pv*/)
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -964,10 +964,11 @@ 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_12293.cpp ]
+          [ thread-run test_12949.cpp ]
          
    ;

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

 #if defined BOOST_THREAD_USES_CHRONO

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

 void f()
 {
-  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);
+  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);
  }
-  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);
@@ -73,9 +80,13 @@ 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);
@@ -85,8 +96,10 @@ 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,6 +21,8 @@
 #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

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

 void f()
 {
-  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);
+  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);
  }
-  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);
@@ -88,9 +96,13 @@ 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);
@@ -100,6 +112,9 @@ 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,11 +17,13 @@

 // 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

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

 void f()
 {
-  boost::unique_lock<boost::mutex> lk(mut);
-  BOOST_TEST(test2 == 0);
-  test1 = 1;
-  cv.notify_one();
-  while (test2 == 0) {
-      cv.wait(lk);
+  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_TEST(test2 != 0);
 }

 int main()
 {
-  boost::unique_lock<boost::mutex>lk(mut);
-  boost::thread t(f);
-  BOOST_TEST(test1 == 0);
-  while (test1 == 0)
-  {
-      cv.wait(lk);
+  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_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,6 +21,8 @@
 #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

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

 void f()
 {
-  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);
+  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;
  }
-  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);
@@ -86,9 +94,14 @@ 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);
@@ -98,6 +111,9 @@ 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,6 +21,8 @@
 #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

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

 void f()
 {
-  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);
+  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);
  }
-  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);
@@ -100,9 +108,13 @@ 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,6 +124,9 @@ 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,12 +89,15 @@ int main()
  }
  {
    // empty queue push rvalue succeeds
-      boost::sync_bounded_queue<int> q(2);
+      boost::sync_bounded_queue<int> q(3);
      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());
  }
  {
@@ -317,12 +320,15 @@ int main()
  }
  {
    // empty queue push rvalue succeeds
-      boost::sync_bounded_queue<int> q(2);
+      boost::sync_bounded_queue<int> q(3);
      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
@@ -0,0 +1,21 @@
+// 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>10)
+    if((100*failures)/total>40)
    {
      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,6 +11,7 @@
 #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,6 +12,7 @@
 #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,9 +26,11 @@
 unsigned throw_one = 0xFFFF;

 #if defined _GLIBCXX_THROW
-inline void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
+void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
 #elif defined BOOST_MSVC
-inline void* operator new(std::size_t s)
+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
@@ -40,9 +42,9 @@ void* operator new(std::size_t s) throw (std::bad_alloc)
 }

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

 #if defined _GLIBCXX_THROW
-inline void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
+void* operator new(std::size_t s) _GLIBCXX_THROW (std::bad_alloc)
 #elif defined BOOST_MSVC
-inline void* operator new(std::size_t s)
+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
@@ -41,9 +43,9 @@ void* operator new(std::size_t s) throw (std::bad_alloc)
 }

 #if defined BOOST_MSVC
-inline void operator delete(void* p)
+void operator delete(void* p)
 #else
-inline void operator delete(void* p) throw ()
+void operator delete(void* p) BOOST_NOEXCEPT_OR_NOTHROW
 #endif
 {
  std::free(p);
Author	SHA1	Message	Date
Peter Dimov	13959e3a5e	Add -j3 to .travis.yml to reduce build time and avoid timeouts	2017-09-10 13:46:44 +03:00
Vicente J. Botet Escriba	3556f298c7	Merge branch 'develop' of github.com:boostorg/thread into develop	2017-09-09 18:42:58 +02:00
Vicente J. Botet Escriba	091e8c8088	reduce the number of travis jobs.	2017-09-09 18:42:23 +02:00
Vicente J. Botet Escriba	eda6b64491	Merge pull request #140 from SSE4/clang_windows_fixes - switch to boost winapi, to avoid duplicated definitions when compil…	2017-09-07 00:56:11 +02:00
Vicente J. Botet Escriba	ee24ff8dd1	commit CI files.	2017-09-07 00:29:29 +02:00
SSE4	dfe39c630f	Merge pull request #1 from Lastique/clang_windows_fixes_fixes Fix compilation of Boost.WinAPI-based Boost.Thread	2017-09-06 09:36:01 +07:00
Andrey Semashev	a1460b6b0d	Fixed incorrect call to GetCurrentThreadId.	2017-09-05 21:43:42 +03:00
Andrey Semashev	02f3290765	Added a missing include.	2017-09-05 21:42:43 +03:00
SSE4	5f0eeeff66	- additional WinAPI definitions	2017-08-31 16:12:16 +07:00
SSE4	e63257ff7f	- switch to boost winapi, to avoid duplicated definitions when compiling using Clang on Windows	2017-08-31 14:52:13 +07:00
Vicente J. Botet Escriba	39c23ddf5a	Interrup the threads before joining on schedulers.	2017-08-28 09:16:20 +02:00
Vicente J. Botet Escriba	3ee73c866d	INcrease the threashold of spourious timeouts.	2017-08-28 09:15:39 +02:00
Vicente J. Botet Escriba	584b9c2d29	Merge pull request #131 from Lastique/fix_ticket12730 Changed signatures of TLS cleanup hooks for consistency with MSVC RTL.	2017-08-27 20:57:04 +02:00
Andrey Semashev	349f59d92d	Changed signatures of TLS cleanup hooks for consistency with MSVC RTL. This should fix startup of executables statically linked with Boost.Thread because of undefined return value of the thread/process startup hooks. Should fix https://svn.boost.org/trac10/ticket/12730.	2017-08-27 19:17:23 +03:00
Vicente J. Botet Escriba	e99ec0a283	Update copyright.	2017-08-26 10:50:51 +02:00
Vicente J. Botet Escriba	5920e4c7af	Update copyright.	2017-08-26 10:50:15 +02:00
Vicente J. Botet Escriba	13f3d7ed87	Update changes.	2017-08-26 10:48:11 +02:00
Vicente J. Botet Escriba	738ab19573	Update to new version 4.8.0with changes.	2017-08-26 10:41:58 +02:00
Vicente J. Botet Escriba	510e66aef7	rename make_ready to notify_deferred.	2017-08-26 10:39:31 +02:00
Vicente J. Botet Escriba	19c590a881	manage with #12949 .	2017-08-26 10:38:37 +02:00
Vicente J. Botet Escriba	395e3d786b	#130 - Bug in boost::condition_variable on Windows.	2017-08-24 09:04:26 +02:00
Vicente J. Botet Escriba	fdc0cbcd8c	#130 - Bug in boost::condition_variable on Windows.	2017-08-24 08:45:36 +02:00
Vicente J. Botet Escriba	f27a2921da	manage with #13019 - ABI compatibility for BOOST_THREAD_PROVIDES_INTERRUPTIONS incomplete.	2017-08-23 00:33:57 +02:00
Vicente J. Botet Escriba	bb32aa3164	manage with 13163-boost::detail::heap_new does not have a variadic variant.	2017-08-22 23:48:23 +02:00
Vicente J. Botet Escriba	70b887a7bd	Merge branch 'develop' of github.com:boostorg/thread into develop	2017-08-16 20:31:11 +02:00
Vicente J. Botet Escriba	28bf345c96	make more evident that timespec is realtime and not monotonic.	2017-08-16 20:30:59 +02:00
Vicente J. Botet Escriba	6a1eed0fa8	Merge pull request #129 from shinobu-x/wip-sk-20170815 Do not include same header twice	2017-08-16 07:41:23 +02:00
Shinobu Kinjo	c4d5488f7a	Do not include same header twice include/boost/thread/pthread/shared_mutex.hpp	2017-08-15 07:29:10 +09:00
Vicente J. Botet Escriba	24a22b66ef	Workaround deprecated ::getpagesize().	2017-08-13 07:19:42 +02:00
Vicente J. Botet Escriba	9579dc2056	Merge pull request #126 from Lastique/patch-6 Use BOOST_MAY_ALIAS from Boost.Config.	2017-08-03 23:02:41 +02:00
Vicente J. Botet Escriba	89e694cc56	Merge pull request #127 from dkolsen-pgi/sleep_until Fix sleep_until() to use a realtime clock	2017-08-03 23:00:23 +02:00
David Olsen	047205fbbd	Fix sleep_until() to use a realtime clock boost::this_thread::no_interruption_point::hidden::sleep_until() takes an absolute time as a parameter and converts it to a duration for the length of time to sleep. But the current time that the absolute time is compared against came from timespec_now(), which, on Linux at least, uses CLOCK_MONOTONIC, which "represents monotonic time since some unspecified starting point." Since timespec_now() may have a different starting point than the time that was passed to sleep_until(), that can result in sleep_until() sleeping for an extremely long time, causing the program to appear to hang. Change sleep_until() to get the current time from timespec_now_realtime(), which uses CLOCK_REALTIME, which has the same epoch as the time that is passed to sleep_until().	2017-08-02 15:19:32 -07:00
Andrey Semashev	23e7135f2c	Use BOOST_MAY_ALIAS from Boost.Config.	2017-07-29 17:09:18 +03:00
Vicente J. Botet Escriba	d4cff01c72	#12519 .	2017-06-11 11:30:59 +02:00
Vicente J. Botet Escriba	5f7dc381c7	Merge pull request #125 from vslavik/fix-comparison Don't compare shared_ptr<> to 0	2017-06-07 17:57:21 +02:00
Václav Slavík	ea0bc01400	Don't compare shared_ptr<> to 0 Update the code to consistently use a check for .get() == 0, as was already done in most, but not all, places, to avoid issues with ambiguous overloaded operator== and operator!=.	2017-06-07 17:24:40 +02:00
Vicente J. Botet Escriba	3bc883d114	Merge pull request #124 from florianbehrens/patch-1 Fixed future::then template argument in documentation.	2017-05-24 12:18:21 +02:00
Florian Behrens	2e2850ff94	Fixed future::then template argument in documentation.	2017-05-24 12:03:38 +02:00
Vicente J. Botet Escriba	1a8019f499	Merge pull request #123 from Lastique/fix_entry_manager Fix entry_manager constructor not accepting entry_ptr rvalue	2017-05-23 21:54:30 +02:00
Andrey Semashev	bf4b38b0af	Fixed entry_manager constructor not accepting entry_ptr rvalue. This resolves compilation failures with MinGW.	2017-05-22 13:11:11 +03:00
Vicente J. Botet Escriba	f78b10a450	Merge pull request #122 from vincenthsu/develop Fix sync_bounded_queue<>::size()	2017-05-11 01:33:43 +02:00
Vincent Hsu	603689372c	Fix sync_bounded_queue<>::size()	2017-05-10 13:12:01 +08:00
Vicente J. Botet Escriba	5b05d6a8c8	fix compile error.	2017-05-07 16:01:10 +02:00
Vicente J. Botet Escriba	12c0fe14cd	fix compile error.	2017-05-07 09:05:12 +02:00
Vicente J. Botet Escriba	ace2b8f89e	rollback and use RAII.	2017-05-06 23:04:52 +02:00
Vicente J. Botet Escriba	24188f295c	fix missing remove aiter while return.	2017-05-06 22:53:41 +02:00
Vicente J. Botet Escriba	653671bc0e	fix compilation error.	2017-05-06 14:43:49 +02:00
Vicente J. Botet Escriba	c251497758	Avoid throwing on destructor: condition_variable.	2017-05-06 12:09:23 +02:00
Vicente J. Botet Escriba	69435fa44e	try to fix lock on destructor issues.	2017-05-06 03:58:13 +02:00
Vicente J. Botet Escriba	6bc6fcab9a	fix compilation error :(	2017-05-04 19:16:04 +02:00
Vicente J. Botet Escriba	50bac8c0eb	fix compilation error :(	2017-05-04 07:58:58 +02:00
Vicente J. Botet Escriba	d709d4707c	comment failing test. It is surely a bad test.	2017-05-01 03:39:53 +02:00
Vicente J. Botet Escriba	879db6841d	try to fix compilation error on windows condition_variable.hpp.	2017-05-01 02:58:45 +02:00
Vicente J. Botet Escriba	2ce385b949	Add missing iostream.	2017-04-29 18:19:02 +02:00
Vicente J. Botet Escriba	21458fcc67	Add missing iostream.	2017-04-29 17:56:32 +02:00
Vicente J. Botet Escriba	d83b7ddc0f	Merge branch 'develop' of github.com:boostorg/thread into develop	2017-04-29 17:35:01 +02:00
Vicente J. Botet Escriba	5ee3e8d04b	manage with #12888 .	2017-04-29 16:17:07 +02:00
Vicente J. Botet Escriba	dcafe1e17d	Add noexcept(false) in destructor that could throw in C++11.	2017-04-29 16:15:57 +02:00
Vicente J. Botet Escriba	8dfa7c2e42	fix issue throw() noexcept issue.	2017-04-29 16:14:41 +02:00
Vicente J. Botet Escriba	c83d30f526	manage with #12874 .	2017-04-29 16:13:52 +02:00
Vicente J. Botet Escriba	51b367df53	manage with 12958.	2017-04-29 16:12:35 +02:00
Vicente J. Botet Escriba	da83662e1a	added test for 12949.	2017-04-29 16:11:31 +02:00
Vicente J. Botet Escriba	36861e5b67	Comment error. Need to be fixed.	2017-04-29 16:10:43 +02:00
Vicente J. Botet Escriba	67df4dd84e	Merge pull request #120 from MarcelRaad/patch-2 Remove wrong MSVC version check	2017-04-21 02:10:19 +02:00
Marcel Raad	676521808d	Remove wrong MSVC version check There is no compiler with (_MSC_VER > 2000) and taking the legacy codepath would probably break compilation again when there is. As (_MSC_VER < 1300) (that would be MSVC up to 6.0 from 1998) is not supported by Boost anymore anyway and cannot compile Boost.Thread, this codepath can just be removed completely.	2017-03-24 22:28:41 +01:00