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

- switch to boost winapi, to avoid duplicated definitions when compil…

.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

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%

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:]

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

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

include/boost/thread/detail/thread.hpp

@@ -157,7 +157,7 @@ namespace boost
     }
 namespace thread_detail {
 #ifdef BOOST_THREAD_USES_CHRONO
-#if defined(BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC) && defined(BOOST_THREAD_USEFIXES_TIMESPEC)
+#if defined(BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC)
         typedef chrono::steady_clock internal_clock_t;
 #else
         typedef chrono::system_clock internal_clock_t;
@@ -299,7 +299,7 @@ namespace thread_detail {
         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

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();
       }
     }

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 (...)

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();
     }
 

include/boost/thread/executors/scheduler.hpp

@@ -231,6 +231,7 @@ namespace boost
       ~scheduler()
       {
         this->close();
+        thr.interrupt();
         thr.join();
       }
       template <class Ex>

include/boost/thread/executors/scheduling_adaptor.hpp

@@ -31,6 +31,7 @@ namespace executors
     ~scheduling_adpator()
     {
       this->close();
+      _scheduler.interrupt();
       _scheduler.join();
     }
 

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);

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);

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>
 

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
@@ -240,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
@@ -259,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
@@ -284,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>

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)

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()
     {

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

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

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,7 +135,7 @@ 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>
@@ -211,7 +211,7 @@ namespace boost
                 {}
 #endif
 
-                void remove_waiter()
+                void remove_waiter_and_reset()
                 {
                   if (entry) {
                     boost::lock_guard<boost::mutex> internal_lock(internal_mutex);
@@ -221,7 +221,7 @@ namespace boost
                 }
                 ~entry_manager() BOOST_NOEXCEPT_IF(false)
                 {
-                    remove_waiter();
+                  remove_waiter_and_reset();
                 }
 
                 list_entry* operator->()
@@ -250,7 +250,7 @@ namespace boost
                   woken=entry->woken();
               }
               // do it here to avoid throwing on the destructor
-              entry->remove_waiter();
+              entry.remove_waiter_and_reset();
               locker.lock();
               return woken;
             }

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));
         }
     }

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;
                 }

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;

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)

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));
                     }
                 }
 

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

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
 

src/win32/tss_pe.cpp

@@ -111,10 +111,28 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NU
 
 
     //Definitions required by implementation
-
-    typedef int (__cdecl *_PVFV)();
-    #define INIRETSUCCESS 0
-    #define PVAPI int __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_ )();
+        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);
 
@@ -130,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:
@@ -144,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)
@@ -158,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.
@@ -175,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)
@@ -187,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
@@ -222,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
@@ -245,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*/)

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;
-}
+}