#130 - Bug in boost::condition_variable on Windows.

.travis.yml

@@ -1,369 +0,0 @@
-# Copyright 2016, 2017 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-language: cpp
-
-sudo: false
-
-python: "2.7"
-
-os:
-  - linux
-  - osx
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++11
-
-#    - 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

@@ -1,79 +0,0 @@
-# Copyright 2016, 2017 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-platform:
-  - x64
-
-environment:
-  matrix:
-    - ARGS: --toolset=msvc-9.0  address-model=32
-    - ARGS: --toolset=msvc-10.0 address-model=32
-    - ARGS: --toolset=msvc-11.0 address-model=32
-    - ARGS: --toolset=msvc-12.0 address-model=32
-    - ARGS: --toolset=msvc-14.0 address-model=32
-    - ARGS: --toolset=msvc-12.0 address-model=64
-    - ARGS: --toolset=msvc-14.0 address-model=64
-    - ARGS: --toolset=msvc-14.0 address-model=64 cxxflags=-std:c++latest
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARGS: --toolset=msvc-14.1 address-model=64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARGS: --toolset=msvc-14.1 address-model=32
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARGS: --toolset=msvc-14.1 address-model=64 cxxflags=-std:c++latest
-    - ARGS: --toolset=gcc address-model=64
-      PATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
-    - ARGS: --toolset=gcc address-model=64 cxxflags=-std=gnu++1z
-      PATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
-    - ARGS: --toolset=gcc address-model=32
-      PATH: C:\mingw-w64\i686-5.3.0-posix-dwarf-rt_v4-rev0\mingw32\bin;%PATH%
-    - ARGS: --toolset=gcc address-model=32 linkflags=-Wl,-allow-multiple-definition
-      PATH: C:\MinGW\bin;%PATH%
-
-
-
-#    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-#      ARGS: --toolset=msvc-9.0
-#    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-#      ARGS: --toolset=msvc-10.0
-#    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-#      ARGS: --toolset=msvc-11.0
-#    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-#      ARGS: --toolset=msvc-12.0
-#    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-#      ARGS: --toolset=msvc-14.0
-#    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-#      ARGS: --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:
-  - cd libs\config\test
-  - ..\..\..\b2 config_info_travis_install %ARGS%
-  - config_info_travis
-  - cd ..\..\thread\test
-  - ..\..\..\b2 -j3 %ARGS%

build/Jamfile.v2

@@ -17,7 +17,7 @@
 # PTW32_INCLUDE and PTW32_LIB respectively. You can specify these
 # paths in site-config.jam, user-config.jam or in the environment.
 # A new feature is provided to request a specific API:
-# <threadapi>win32 and <threadapi>pthread.
+# <threadapi>win32 and <threadapi)pthread.
 #
 # The naming of the resulting libraries is mostly the same for the
 # variant native to the build platform, i.e.
@@ -33,10 +33,10 @@
 #########################################################################
 
 import os ;
+import feature ;
 import indirect ;
 import path ;
 import configure ; 
-import threadapi-feature ;
 
 project boost/thread
     : source-location ../src
@@ -141,6 +141,16 @@ project boost/thread
       <library>/boost/system//boost_system
     ;
 
+local rule default_threadapi ( )
+{
+    local api = pthread ;
+    if [ os.name ] = "NT" { api = win32 ; }
+    return $(api) ;
+}
+
+feature.feature threadapi : pthread win32 : propagated ;
+feature.set-default threadapi : [ default_threadapi ] ;
+
 exe has_atomic_flag_lockfree : ../build/has_atomic_flag_lockfree_test.cpp ; 
 
 rule tag ( name : type ? : property-set )
@@ -152,7 +162,7 @@ rule tag ( name : type ? : property-set )
         local api = [ $(property-set).get <threadapi> ] ;
 
         # non native api gets additional tag
-        if $(api) != [ threadapi-feature.get-default $(property-set) ] {
+        if $(api) != [ default_threadapi ] {
             result = $(result)_$(api) ;
         }
     }

doc/async_executors.qbk

@@ -1,5 +1,5 @@
 [/
- / Copyright (c) 2014-2017 Vicente J. Botet Escriba
+ / Copyright (c) 2014-2015 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)
@@ -481,7 +481,7 @@ If invoked closure throws an exception the executor will call std::terminate, as
 [/////////////////////////]
 [section:work Class `work`]
 
-  #include <boost/thread/executors/work.hpp>
+  #include <boost/thread/work.hpp>
   namespace boost {
     typedef 'implementation_defined' work;
   }
@@ -499,7 +499,7 @@ If invoked closure throws an exception the executor will call std::terminate, as
 
 Executor abstract base class.
 
-  #include <boost/thread/executors/executor.hpp>
+  #include <boost/thread/executor.hpp>
   namespace boost {
     class executor
     {
@@ -564,7 +564,7 @@ Executor abstract base class.
 
 Polymorphic adaptor of a model of Executor to an executor.
 
-  #include <boost/thread/executors/executor.hpp>
+  #include <boost/thread/executor.hpp>
   namespace boost {
     template <typename Executor>
     class executor_adaptor : public executor
@@ -643,7 +643,7 @@ Polymorphic adaptor of a model of Executor to an executor.
 
 Executor abstract base class.
 
-  #include <boost/thread/executors/generic_executor_ref.hpp>
+  #include <boost/thread/generic_executor_ref.hpp>
   namespace boost {
     class generic_executor_ref
     {
@@ -1333,7 +1333,7 @@ Executor providing time related functions.
 
 A serial executor ensuring that there are no two work units that executes concurrently.
 
-  #include <boost/thread/executors/serial_executor.hpp>
+  #include <boost/thread/serial_executor.hpp>
   namespace boost {
     template <class Executor>
     class serial_executor
@@ -1404,6 +1404,83 @@ A serial executor ensuring that there are no two work units that executes concur
 ]
 
 
+[endsect]
+
+[endsect]
+
+[//////////////////////////////////////////////////////////]
+[section:generic_serial_executor Class `generic_serial_executor`]
+
+A serial executor ensuring that there are no two work units that executes concurrently.
+
+  #include <boost/thread/generic_serial_executor.hpp>
+  namespace boost {
+    class generic_serial_executor
+    {
+    public:
+      generic_serial_executor(generic_serial_executor const&) = delete;
+      generic_serial_executor& operator=(generic_serial_executor const&) = delete;
+  
+      template <class Executor>
+      generic_serial_executor(Executor& ex);
+ 
+      generic_executor_ref& underlying_executor() noexcept;
+
+      void close();
+      bool closed();
+  
+      template <typename Closure>
+      void submit(Closure&& closure);
+  
+      bool try_executing_one();
+      template <typename Pred>
+      bool reschedule_until(Pred const& pred);
+
+    };
+  }
+
+[/////////////////////////////////////]
+[section:constructor Constructor `generic_serial_executor(Executor&)`]
+
+      template <class Executor>
+      generic_serial_executor(Executor& ex);
+
+[variablelist
+
+[[Effects:] [Constructs a serial_executor. ]]
+
+[[Throws:] [Nothing. ]]
+
+]
+
+
+[endsect]
+[/////////////////////////////////////]
+[section:destructor Destructor `~serial_executor()`]
+
+      ~generic_serial_executor();
+
+[variablelist
+
+[[Effects:] [Destroys the serial_executor.]]
+
+[[Synchronization:] [The completion of all the closures happen before the completion of the executor destructor.]]
+
+]
+
+[endsect]
+[/////////////////////////////////////]
+[section:underlying_executor Function member `underlying_executor()`]
+
+      Executor& underlying_executor() noexcept;
+
+[variablelist
+
+[[Return:] [The underlying executor instance. ]]
+
+]
+
+
 [endsect]
 
 [endsect]
@@ -1414,7 +1491,7 @@ A serial executor ensuring that there are no two work units that executes concur
 
 A serial executor ensuring that there are no two work units that executes concurrently.
 
-  #include <boost/thread/executors/inline_executor.hpp>
+  #include <boost/thread/inline_executor.hpp>
   namespace boost {
     class inline_executor
     {
@@ -1598,7 +1675,7 @@ A thread_executor with a threads for each task.
 
 A user scheduled executor.
 
-  #include <boost/thread/executors/loop_executor.hpp>
+  #include <boost/thread/loop_executor.hpp>
   namespace boost {
     class loop_executor
     { 

doc/changes.qbk

@@ -1,6 +1,6 @@
 [/
   (C) Copyright 2007-11 Anthony Williams.
-  (C) Copyright 2011-17 Vicente J. Botet Escriba.
+  (C) Copyright 2011-16 Vicente J. Botet Escriba.
   Distributed under the Boost Software License, Version 1.0.
   (See accompanying file LICENSE_1_0.txt or copy at
   http://www.boost.org/LICENSE_1_0.txt).
@@ -8,57 +8,6 @@
 
 [section:changes History]
 
-[heading Version 4.8.0 - boost 1.66]
-
-[*Know Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
-
-* [@http://svn.boost.org/trac/boost/ticket/10964 #10964] future<future<T>>::unwrap().then() Deadlocks
-
-
-Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
-
-Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread master regression test] to see the last regression test snapshot.
-
-[*Fixed Bugs:]
-
-* [@http://svn.boost.org/trac/boost/ticket/12976 #12976] Boost Thread Executors documentation mistakes
-* [@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
-
-[*New Experimental Features:]
-
-
-[heading Version 4.7.5 - boost 1.65.1]
-
-[*Fixed Bugs:]
-
-* [@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:]
@@ -78,7 +27,7 @@ Please define BOOST_THREAD_PATCH to apply the patch that could unfortunately res
 
 Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
 
-Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread master regression test] to see the last regression test snapshot.
+Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread trunk regression test] to see the last regression test snapshot.
 
 
 [*Fixed Bugs:]

doc/configuration.qbk

@@ -179,9 +179,9 @@ When `BOOST_THREAD_VERSION>=3` define `BOOST_THREAD_DONT_PROVIDE_GENERIC_SHARED_
 [section:shared_upwards Shared Locking Upwards Conversion]
 
 Boost.Threads includes in version 3 the Shared Locking Upwards Conversion as defined in [@http://home.roadrunner.com/~hinnant/bloomington/shared_mutex.html Shared Locking].
-These conversions need to be used carefully to avoid deadlock or livelock. The user need to define explicitly `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS` to get these upwards conversions. 
+These conversions need to be used carefully to avoid deadlock or livelock. The user need to define explicitly `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION` to get these upwards conversions. 
 
-When `BOOST_THREAD_VERSION==2` define `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS ` if you want these features.
+When `BOOST_THREAD_VERSION==2` define `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION ` if you want these features.
 When `BOOST_THREAD_VERSION>=3` define `BOOST_THREAD_DONT_PROVIDE_SHARED_MUTEX_UPWARDS_CONVERSION ` if you don't want these features.
 
 [endsect]
@@ -352,7 +352,7 @@ The user can request the version 3 by defining `BOOST_THREAD_VERSION` to 3. In t
 * Breaking change `BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION `
 * Conformity & Breaking change `BOOST_THREAD_PROVIDES_FUTURE`
 * Uniformity `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN`
-* Extension `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS`
+* Extension `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION`
 * Conformity `BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS`
 * Conformity & Breaking change BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE
 * Conformity & Breaking change BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE

doc/future_ref.qbk

@@ -1507,13 +1507,6 @@ executor, then the parent is filled by immediately calling `.wait()`, and the po
 
       template<typename F>
       void set_wait_callback(F f); // EXTENSION
-
-      void set_value_deferred(see below);  // EXTENSION
-      void set_exception_deferred(exception_ptr p);  // EXTENSION
-      template <typename E>
-      void set_exception_deferred(E e); // EXTENSION
-      void notify_deferred(); // EXTENSION
-
     };
 
 [///////////////////////////////////////////////]
@@ -1690,10 +1683,9 @@ Stores the value r in the shared state without making that state ready immediate
 Schedules that state to be made ready when the current thread exits, after all objects of thread storage duration 
 associated with the current thread have been destroyed.]]
 
-[[Postconditions:] [the result associated with `*this` is set as deferred]]
 
 [[Throws:] [
-- __promise_already_satisfied__ if the result associated with `*this` is already ['ready] or deferred. 
+- __promise_already_satisfied__ if the result associated with `*this` is already ['ready]. 
 
 - __broken_promise__ if `*this` has no shared state. 
 
@@ -1719,11 +1711,11 @@ Stores the exception pointer p in the shared state without making that state rea
 Schedules that state to be made ready when the current thread exits, after all objects of thread storage duration
  associated with the current thread have been destroyed.]]
 
-[[Postconditions:] [the result associated with `*this` is set as deferred]]
-
+[[Postconditions:] [All futures waiting on the shared state are ['ready] and __unique_future_has_exception__ or
+__shared_future_has_exception__ for those futures shall return `true`.]]
 
 [[Throws:] [
-- __promise_already_satisfied__ if the result associated with `*this` is already ['ready] or deferred. 
+- __promise_already_satisfied__ if the result associated with `*this` is already ['ready]. 
 
 - __broken_promise__ if `*this` has no shared state. 
 
@@ -1753,82 +1745,6 @@ or __shared_future__ associated with this result, and the result is not ['ready]
 ]
 
 [endsect]
-[///////////////////////////////////////////////]
-[section:set_value Member Function `set_value_deferred()` EXTENSION]
-
-    void set_value_deferred(R&& r);
-    void set_value_deferred(const R& r);
-    void promise<R&>:: set_value_deferred(R& r);
-    void promise<void>:: set_value_deferred();
-
-[variablelist
-
-[[Effects:] [
-- If BOOST_THREAD_PROVIDES_PROMISE_LAZY is defined and if `*this` was not associated with a result, allocate storage for a new shared state and associate it with `*this`. 
-
-- Stores the value `r` in the shared state without making that state ready immediately. Threads blocked waiting for the asynchronous result are not woken. They will be woken only when `notify_deferred` is called.
-]]
-
-[[Postconditions:] [the result associated with `*this` is set as deferred]]
-
-[[Throws:] [
-- __promise_already_satisfied__ if the result associated with `*this` is already ['ready] or deferred. 
-
-- __broken_promise__ if `*this` has no shared state. 
-
-- `std::bad_alloc` if the memory required for storage of the result cannot be allocated. 
-
-- Any exception thrown by the copy or move-constructor of `R`.]]
-
-]
-
-[endsect]
-[///////////////////////////////////////////////////////]
-[section:set_exception Member Function `set_exception_deferred()` EXTENSION]
-
-    void set_exception_deferred(boost::exception_ptr e);
-    template <typename E>
-    void set_exception_deferred(E e); // EXTENSION
-
-[variablelist
-
-[[Effects:] [
-- If BOOST_THREAD_PROVIDES_PROMISE_LAZY is defined and if `*this` was not associated with a result, allocate storage for a new shared state and associate it with `*this`. 
-
-- Store the exception `e` in the shared state associated with `*this`without making that state ready immediately. Threads blocked waiting for the asynchronous result are not woken. They will be woken only when `notify_deferred` is called.]]
-
-[[Postconditions:] [the result associated with `*this` is set as deferred]]
-
-
-[[Throws:] [
-- __promise_already_satisfied__ if the result associated with `*this` is already ['ready] or deferred. 
-
-- __broken_promise__ if `*this` has no shared state. 
-
-- `std::bad_alloc` if the memory required for storage of the result cannot be allocated.
-]]
-
-]
-
-[endsect]
-
-[///////////////////////////////////////////////]
-[section:set_value Member Function `notify_deferred()` EXTENSION]
-
-[variablelist
-
-[[Effects:] [
-Any threads blocked waiting for the asynchronous result are woken.
-]]
-
-[[Postconditions:] [All futures waiting on the shared state are ['ready] and __unique_future_has_value__ or
-__shared_future_has_value__ for those futures shall return `true`.]]
-
-[[Postconditions:] [the result associated with `*this` is ready.]]
-
-]
-[endsect]
-
 
 [endsect]
 [////////////////////////////////////////////////////]

doc/mutex_concepts.qbk

@@ -542,7 +542,7 @@ requirements and the following expressions are well-formed and have the specifie
 * `m.__unlock_upgrade_and_lock_shared();`
 
 
-If `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS is defined the following expressions are also required:
+If `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION is defined the following expressions are also required:
 
 * `m.__try_unlock_shared_and_lock();`
 * `m.__try_unlock_shared_and_lock_for(rel_time);`
@@ -678,7 +678,7 @@ If the conversion is not successful, the shared ownership of m is retained.]]
 
 [[Throws:] [Nothing]]
 
-[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
+[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
 
 ]
 [endsect]
@@ -704,7 +704,7 @@ If the conversion is not successful, the shared ownership of the mutex is retain
 
 [[Throws:] [Nothing]]
 
-[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
+[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
 
 ]
 [endsect]
@@ -730,7 +730,7 @@ If the conversion is not successful, the shared ownership of the mutex is retain
 
 [[Throws:] [Nothing]]
 
-[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
+[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
 
 ]
 [endsect]
@@ -770,7 +770,7 @@ If the conversion is not successful, the shared ownership of the mutex is retain
 
 [[Throws:] [Nothing]]
 
-[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
+[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
 
 ]
 [endsect]
@@ -797,7 +797,7 @@ If the conversion is not successful, the shared ownership of m is retained.]]
 
 [[Throws:] [Nothing]]
 
-[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
+[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
 
 
 ]
@@ -823,7 +823,7 @@ If the conversion is not successful, the shared ownership of the mutex is retain
 
 [[Throws:] [Nothing]]
 
-[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
+[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
 
 ]
 [endsect]
@@ -1268,7 +1268,7 @@ The following classes are models of `StrictLock`:
         unique_lock(Lockable& m_,defer_lock_t) noexcept;
         unique_lock(Lockable& m_,try_to_lock_t);
 
-    #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
+    #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
         unique_lock(shared_lock<mutex_type>&& sl, try_to_lock_t); // C++14 
         template <class Clock, class Duration>
         unique_lock(shared_lock<mutex_type>&& sl,
@@ -1426,7 +1426,7 @@ Else `sl.__owns_lock()` returns `true`, and in this case if `sl.mutex()->try_unl
 
 [[Throws:] [Nothing.]]
 
-[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
+[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
 
 ]
 
@@ -1451,7 +1451,7 @@ Else `sl.__owns_lock_shared_ref__()` returns `true`, and in this case if `sl.mut
 
 [[Throws:] [Nothing.]]
 
-[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
+[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
 
 ]
 
@@ -1478,7 +1478,7 @@ Else `sl.owns_lock()` returns `true`, and in this case if `sl.mutex()-> __try_un
 
 [[Throws:] [Nothing.]]
 
-[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
+[[Notes:] [Available only if `BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION` and `BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN` is defined on Windows platform]]
 
 ]
 
@@ -1899,7 +1899,7 @@ __owns_lock_shared_ref__ returns `false`.]]
         bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
         void unlock();
 
-    #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
+    #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
        // Conversion from shared locking
         upgrade_lock(shared_lock<mutex_type>&& sl, try_to_lock_t);
         template <class Clock, class Duration>

doc/thread.qbk

@@ -8,10 +8,10 @@
 
 [library Thread
     [quickbook 1.5]
-    [version 4.8.0]
+    [version 4.7.2]
     [authors [Williams, Anthony] [Botet Escriba, Vicente J.]]
     [copyright 2007-11 Anthony Williams]
-    [copyright 2011-17 Vicente J. Botet Escriba]
+    [copyright 2011-16 Vicente J. Botet Escriba]
     [purpose C++ Library for launching threads and synchronizing data between them]
     [category text]
     [license

example/ba_externallly_locked.cpp

@@ -12,10 +12,6 @@
 #include <boost/thread/lock_types.hpp>
 #include <iostream>
 
-#ifdef BOOST_MSVC
-# pragma warning(disable: 4355) // 'this' : used in base member initializer list
-#endif
-
 using namespace boost;
 
 class BankAccount

example/future_fallback_to.cpp

@@ -21,10 +21,6 @@
 
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 int p1_ex()
 {
   BOOST_THREAD_LOG << "P1" << BOOST_THREAD_END_LOG;

example/future_then.cpp

@@ -20,10 +20,6 @@
 #include <iostream>
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 int p1()
 {
   BOOST_THREAD_LOG << "P1" << BOOST_THREAD_END_LOG;

example/future_unwrap.cpp

@@ -20,10 +20,6 @@
 
 #if defined BOOST_THREAD_PROVIDES_FUTURE_UNWRAP
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 int p1()
 {
   BOOST_THREAD_LOG << "P1" << BOOST_THREAD_END_LOG;

example/future_when_all.cpp

@@ -21,10 +21,6 @@
 #include <string>
 #if defined BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 int p1()
 {
   BOOST_THREAD_LOG

example/lambda_future.cpp

@@ -20,11 +20,8 @@
 #include <iostream>
 
 #if    defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION \
-  && ! defined BOOST_NO_CXX11_LAMBDAS && ! (defined BOOST_MSVC && _MSC_VER < 1800) // works since msvc-12.0
+  && ! defined BOOST_NO_CXX11_LAMBDAS && ! (defined BOOST_MSVC && _MSC_VER < 1700)
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
 
 int main()
 {
@@ -71,8 +68,6 @@ int main()
 }
 #else
 
-//#warning "This test is not supported in this configuration, either because  Bosst.Thread has been configured to don't support continuations, the compiler doesn't provides lambdas or because they are buggy as for MSV versions < msvc-12.0"
-
 int main()
 {
   return 0;

example/parallel_accumulate.cpp

@@ -37,7 +37,7 @@ struct accumulate_block
 template<typename Iterator,typename T>
 T parallel_accumulate(Iterator first,Iterator last,T init)
 {
-    unsigned long const length=static_cast<unsigned long>(std::distance(first,last));
+    unsigned long const length=std::distance(first,last);
 
     if(!length)
         return init;

example/thread_pool.cpp

@@ -18,10 +18,6 @@
 #include <boost/assert.hpp>
 #include <string>
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 void p1()
 {
   BOOST_THREAD_LOG

example/user_scheduler.cpp

@@ -17,10 +17,6 @@
 #include <boost/thread/thread_only.hpp>
 #include <string>
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 void p1()
 {
   BOOST_THREAD_LOG

include/boost/thread/concurrent_queues/detail/sync_deque_base.hpp

@@ -3,7 +3,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Vicente J. Botet Escriba 2013-2017. Distributed under the Boost
+// (C) Copyright Vicente J. Botet Escriba 2013-2014. 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)
 //
@@ -17,7 +17,9 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/concurrent_queues/queue_op_status.hpp>
 
+#include <boost/chrono/duration.hpp>
 #include <boost/chrono/time_point.hpp>
+#include <boost/chrono/system_clocks.hpp>
 #include <boost/throw_exception.hpp>
 
 #include <boost/config/abi_prefix.hpp>
@@ -38,6 +40,10 @@ namespace detail
     typedef typename Queue::size_type size_type;
     typedef queue_op_status op_status;
 
+    typedef typename chrono::steady_clock clock;
+    typedef typename clock::duration duration;
+    typedef typename clock::time_point time_point;
+
     // Constructors/Assignment/Destructors
     BOOST_THREAD_NO_COPYABLE(sync_deque_base)
     inline sync_deque_base();
@@ -86,8 +92,7 @@ namespace detail
 
     inline void wait_until_not_empty(unique_lock<mutex>& lk);
     inline bool wait_until_not_empty_or_closed(unique_lock<mutex>& lk);
-    template <class WClock, class Duration>
-    queue_op_status wait_until_not_empty_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&);
+    inline queue_op_status wait_until_not_empty_until(unique_lock<mutex>& lk, time_point const&);
 
     inline void notify_not_empty_if_needed(unique_lock<mutex>& )
     {
@@ -198,8 +203,7 @@ namespace detail
   }
 
   template <class ValueType, class Queue>
-  template <class WClock, class Duration>
-  queue_op_status sync_deque_base<ValueType, Queue>::wait_until_not_empty_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp)
+  queue_op_status sync_deque_base<ValueType, Queue>::wait_until_not_empty_until(unique_lock<mutex>& lk, time_point const&tp)
   {
     for (;;)
     {

include/boost/thread/concurrent_queues/detail/sync_queue_base.hpp

@@ -3,7 +3,7 @@
 
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Vicente J. Botet Escriba 2013-2017. Distributed under the Boost
+// (C) Copyright Vicente J. Botet Escriba 2013-2014. 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)
 //
@@ -17,7 +17,9 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/concurrent_queues/queue_op_status.hpp>
 
+#include <boost/chrono/duration.hpp>
 #include <boost/chrono/time_point.hpp>
+#include <boost/chrono/system_clocks.hpp>
 #include <boost/throw_exception.hpp>
 
 #include <boost/config/abi_prefix.hpp>
@@ -38,6 +40,10 @@ namespace detail
     typedef typename Queue::size_type size_type;
     typedef queue_op_status op_status;
 
+    typedef typename chrono::steady_clock clock;
+    typedef typename clock::duration duration;
+    typedef typename clock::time_point time_point;
+
     // Constructors/Assignment/Destructors
     BOOST_THREAD_NO_COPYABLE(sync_queue_base)
     inline sync_queue_base();
@@ -86,8 +92,7 @@ namespace detail
 
     inline void wait_until_not_empty(unique_lock<mutex>& lk);
     inline bool wait_until_not_empty_or_closed(unique_lock<mutex>& lk);
-    template <class WClock, class Duration>
-    queue_op_status wait_until_not_empty_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&);
+    inline queue_op_status wait_until_not_empty_until(unique_lock<mutex>& lk, time_point const&);
 
     inline void notify_not_empty_if_needed(unique_lock<mutex>& )
     {
@@ -198,8 +203,7 @@ namespace detail
   }
 
   template <class ValueType, class Queue>
-  template <class WClock, class Duration>
-  queue_op_status sync_queue_base<ValueType, Queue>::wait_until_not_empty_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp)
+  queue_op_status sync_queue_base<ValueType, Queue>::wait_until_not_empty_until(unique_lock<mutex>& lk, time_point const&tp)
   {
     for (;;)
     {

include/boost/thread/concurrent_queues/sync_priority_queue.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2014 Ian Forbed
-// Copyright (C) 2014-2017 Vicente J. Botet Escriba
+// Copyright (C) 2014 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)
@@ -130,10 +130,8 @@ namespace concurrent
 
     void pull(ValueType&);
 
-    template <class WClock, class Duration>
-    queue_op_status pull_until(const chrono::time_point<WClock,Duration>&, ValueType&);
-    template <class Rep, class Period>
-    queue_op_status pull_for(const chrono::duration<Rep,Period>&, ValueType&);
+    queue_op_status pull_until(const clock::time_point&, ValueType&);
+    queue_op_status pull_for(const clock::duration&, ValueType&);
 
     queue_op_status try_pull(ValueType& elem);
     queue_op_status wait_pull(ValueType& elem);
@@ -275,9 +273,8 @@ namespace concurrent
 
   //////////////////////
   template <class T, class Cont,class Cmp>
-  template <class WClock, class Duration>
   queue_op_status
-  sync_priority_queue<T,Cont,Cmp>::pull_until(const chrono::time_point<WClock,Duration>& tp, T& elem)
+  sync_priority_queue<T,Cont,Cmp>::pull_until(const clock::time_point& tp, T& elem)
   {
     unique_lock<mutex> lk(super::mtx_);
     if (queue_op_status::timeout == super::wait_until_not_empty_until(lk, tp))
@@ -288,9 +285,8 @@ namespace concurrent
 
   //////////////////////
   template <class T, class Cont,class Cmp>
-  template <class Rep, class Period>
   queue_op_status
-  sync_priority_queue<T,Cont,Cmp>::pull_for(const chrono::duration<Rep,Period>& dura, T& elem)
+  sync_priority_queue<T,Cont,Cmp>::pull_for(const clock::duration& dura, T& elem)
   {
     return pull_until(clock::now() + dura, elem);
   }

include/boost/thread/concurrent_queues/sync_timed_queue.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2014 Ian Forbed
-// Copyright (C) 2014-2017 Vicente J. Botet Escriba
+// Copyright (C) 2014 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)
@@ -24,13 +24,12 @@ namespace concurrent
 {
 namespace detail
 {
-  // fixme: shouldn't the timepoint be configurable
-  template <class T, class Clock = chrono::steady_clock, class TimePoint=typename Clock::time_point>
+  template <class T, class Clock = chrono::steady_clock>
   struct scheduled_type
   {
     typedef T value_type;
     typedef Clock clock;
-    typedef TimePoint time_point;
+    typedef typename clock::time_point time_point;
     T data;
     time_point time;
 
@@ -58,7 +57,7 @@ namespace detail
       return time > clock::now();
     }
 
-    bool operator <(const scheduled_type & other) const
+    bool operator <(const scheduled_type<T> other) const
     {
       return this->time > other.time;
     }
@@ -66,11 +65,11 @@ namespace detail
 
 } //end detail namespace
 
-  template <class T, class Clock = chrono::steady_clock, class TimePoint=typename Clock::time_point>
+  template <class T, class Clock = chrono::steady_clock>
   class sync_timed_queue
-    : private sync_priority_queue<detail::scheduled_type<T, Clock, TimePoint> >
+    : private sync_priority_queue<detail::scheduled_type<T, Clock> >
   {
-    typedef detail::scheduled_type<T, Clock, TimePoint> stype;
+    typedef detail::scheduled_type<T, Clock> stype;
     typedef sync_priority_queue<stype> super;
   public:
     typedef T value_type;
@@ -93,8 +92,8 @@ namespace detail
     T pull();
     void pull(T& elem);
 
-    template <class WClock, class Duration>
-    queue_op_status pull_until(chrono::time_point<WClock,Duration> const& tp, T& elem);
+    template <class Duration>
+    queue_op_status pull_until(chrono::time_point<clock,Duration> const& tp, T& elem);
     template <class Rep, class Period>
     queue_op_status pull_for(chrono::duration<Rep,Period> const& dura, T& elem);
 
@@ -136,8 +135,8 @@ namespace detail
 
     bool wait_until_not_empty_time_reached_or_closed(unique_lock<mutex>&);
     T pull_when_time_reached(unique_lock<mutex>&);
-    template <class WClock, class Duration>
-    queue_op_status pull_when_time_reached_until(unique_lock<mutex>&, chrono::time_point<WClock,Duration> const& tp, T& elem);
+    template <class Duration>
+    queue_op_status pull_when_time_reached_until(unique_lock<mutex>&, chrono::time_point<clock,Duration> const& tp, T& elem);
     bool time_not_reached(unique_lock<mutex>&);
     bool time_not_reached(lock_guard<mutex>&);
     bool empty_or_time_not_reached(unique_lock<mutex>&);
@@ -150,80 +149,80 @@ namespace detail
   }; //end class
 
 
-  template <class T, class Clock, class TimePoint>
+  template <class T, class Clock>
   template <class Duration>
-  void sync_timed_queue<T, Clock, TimePoint>::push(const T& elem, chrono::time_point<clock,Duration> const& tp)
+  void sync_timed_queue<T, Clock>::push(const T& elem, chrono::time_point<clock,Duration> const& tp)
   {
     super::push(stype(elem,tp));
   }
 
-  template <class T, class Clock, class TimePoint>
+  template <class T, class Clock>
   template <class Rep, class Period>
-  void sync_timed_queue<T, Clock, TimePoint>::push(const T& elem, chrono::duration<Rep,Period> const& dura)
+  void sync_timed_queue<T, Clock>::push(const T& elem, chrono::duration<Rep,Period> const& dura)
   {
     push(elem, clock::now() + dura);
   }
 
-  template <class T, class Clock, class TimePoint>
+  template <class T, class Clock>
   template <class Duration>
-  void sync_timed_queue<T, Clock, TimePoint>::push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp)
+  void sync_timed_queue<T, Clock>::push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp)
   {
     super::push(stype(boost::move(elem),tp));
   }
 
-  template <class T, class Clock, class TimePoint>
+  template <class T, class Clock>
   template <class Rep, class Period>
-  void sync_timed_queue<T, Clock, TimePoint>::push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura)
+  void sync_timed_queue<T, Clock>::push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura)
   {
     push(boost::move(elem), clock::now() + dura);
   }
 
 
 
-  template <class T, class Clock, class TimePoint>
+  template <class T, class Clock>
   template <class Duration>
-  queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_push(const T& elem, chrono::time_point<clock,Duration> const& tp)
+  queue_op_status sync_timed_queue<T, Clock>::try_push(const T& elem, chrono::time_point<clock,Duration> const& tp)
   {
     return super::try_push(stype(elem,tp));
   }
 
-  template <class T, class Clock, class TimePoint>
+  template <class T, class Clock>
   template <class Rep, class Period>
-  queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_push(const T& elem, chrono::duration<Rep,Period> const& dura)
+  queue_op_status sync_timed_queue<T, Clock>::try_push(const T& elem, chrono::duration<Rep,Period> const& dura)
   {
     return try_push(elem,clock::now() + dura);
   }
 
-  template <class T, class Clock, class TimePoint>
+  template <class T, class Clock>
   template <class Duration>
-  queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp)
+  queue_op_status sync_timed_queue<T, Clock>::try_push(BOOST_THREAD_RV_REF(T) elem, chrono::time_point<clock,Duration> const& tp)
   {
     return super::try_push(stype(boost::move(elem), tp));
   }
 
-  template <class T, class Clock, class TimePoint>
+  template <class T, class Clock>
   template <class Rep, class Period>
-  queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura)
+  queue_op_status sync_timed_queue<T, Clock>::try_push(BOOST_THREAD_RV_REF(T) elem, chrono::duration<Rep,Period> const& dura)
   {
     return try_push(boost::move(elem), clock::now() + dura);
   }
 
   ///////////////////////////
-  template <class T, class Clock, class TimePoint>
-  bool sync_timed_queue<T, Clock, TimePoint>::time_not_reached(unique_lock<mutex>&)
+  template <class T, class Clock>
+  bool sync_timed_queue<T, Clock>::time_not_reached(unique_lock<mutex>&)
   {
     return super::data_.top().time_not_reached();
   }
 
-  template <class T, class Clock, class TimePoint>
-  bool sync_timed_queue<T, Clock, TimePoint>::time_not_reached(lock_guard<mutex>&)
+  template <class T, class Clock>
+  bool sync_timed_queue<T, Clock>::time_not_reached(lock_guard<mutex>&)
   {
     return super::data_.top().time_not_reached();
   }
 
   ///////////////////////////
-  template <class T, class Clock, class TimePoint>
-  bool sync_timed_queue<T, Clock, TimePoint>::wait_until_not_empty_time_reached_or_closed(unique_lock<mutex>& lk)
+  template <class T, class Clock>
+  bool sync_timed_queue<T, Clock>::wait_until_not_empty_time_reached_or_closed(unique_lock<mutex>& lk)
   {
     for (;;)
     {
@@ -241,8 +240,8 @@ namespace detail
   }
 
   ///////////////////////////
-  template <class T, class Clock, class TimePoint>
-  T sync_timed_queue<T, Clock, TimePoint>::pull_when_time_reached(unique_lock<mutex>& lk)
+  template <class T, class Clock>
+  T sync_timed_queue<T, Clock>::pull_when_time_reached(unique_lock<mutex>& lk)
   {
     while (time_not_reached(lk))
     {
@@ -254,12 +253,12 @@ namespace detail
     return pull(lk);
   }
 
-  template <class T, class Clock, class TimePoint>
-  template <class WClock, class Duration>
+  template <class T, class Clock>
+  template <class Duration>
   queue_op_status
-  sync_timed_queue<T, Clock, TimePoint>::pull_when_time_reached_until(unique_lock<mutex>& lk, chrono::time_point<WClock, Duration> const& tp, T& elem)
+  sync_timed_queue<T, Clock>::pull_when_time_reached_until(unique_lock<mutex>& lk, chrono::time_point<clock,Duration> const& tp, T& elem)
   {
-    chrono::time_point<WClock, Duration> tpmin = (tp < super::data_.top().time) ? tp : super::data_.top().time;
+    chrono::time_point<clock,Duration> tpmin = (tp < super::data_.top().time) ? tp : super::data_.top().time;
     while (time_not_reached(lk))
     {
       super::throw_if_closed(lk);
@@ -273,15 +272,15 @@ namespace detail
   }
 
   ///////////////////////////
-  template <class T, class Clock, class TimePoint>
-  bool sync_timed_queue<T, Clock, TimePoint>::empty_or_time_not_reached(unique_lock<mutex>& lk)
+  template <class T, class Clock>
+  bool sync_timed_queue<T, Clock>::empty_or_time_not_reached(unique_lock<mutex>& lk)
   {
     if ( super::empty(lk) ) return true;
     if ( time_not_reached(lk) ) return true;
     return false;
   }
-  template <class T, class Clock, class TimePoint>
-  bool sync_timed_queue<T, Clock, TimePoint>::empty_or_time_not_reached(lock_guard<mutex>& lk)
+  template <class T, class Clock>
+  bool sync_timed_queue<T, Clock>::empty_or_time_not_reached(lock_guard<mutex>& lk)
   {
     if ( super::empty(lk) ) return true;
     if ( time_not_reached(lk) ) return true;
@@ -289,8 +288,8 @@ namespace detail
   }
 
   ///////////////////////////
-  template <class T, class Clock, class TimePoint>
-  T sync_timed_queue<T, Clock, TimePoint>::pull(unique_lock<mutex>&)
+  template <class T, class Clock>
+  T sync_timed_queue<T, Clock>::pull(unique_lock<mutex>&)
   {
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
     return boost::move(super::data_.pull().data);
@@ -299,8 +298,8 @@ namespace detail
 #endif
   }
 
-  template <class T, class Clock, class TimePoint>
-  T sync_timed_queue<T, Clock, TimePoint>::pull(lock_guard<mutex>&)
+  template <class T, class Clock>
+  T sync_timed_queue<T, Clock>::pull(lock_guard<mutex>&)
   {
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
     return boost::move(super::data_.pull().data);
@@ -308,8 +307,8 @@ namespace detail
     return super::data_.pull().data;
 #endif
   }
-  template <class T, class Clock, class TimePoint>
-  T sync_timed_queue<T, Clock, TimePoint>::pull()
+  template <class T, class Clock>
+  T sync_timed_queue<T, Clock>::pull()
   {
     unique_lock<mutex> lk(super::mtx_);
     super::wait_until_not_empty(lk);
@@ -317,8 +316,8 @@ namespace detail
   }
 
   ///////////////////////////
-  template <class T, class Clock, class TimePoint>
-  void sync_timed_queue<T, Clock, TimePoint>::pull(unique_lock<mutex>&, T& elem)
+  template <class T, class Clock>
+  void sync_timed_queue<T, Clock>::pull(unique_lock<mutex>&, T& elem)
   {
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
     elem = boost::move(super::data_.pull().data);
@@ -327,8 +326,8 @@ namespace detail
 #endif
   }
 
-  template <class T, class Clock, class TimePoint>
-  void sync_timed_queue<T, Clock, TimePoint>::pull(lock_guard<mutex>&, T& elem)
+  template <class T, class Clock>
+  void sync_timed_queue<T, Clock>::pull(lock_guard<mutex>&, T& elem)
   {
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
     elem = boost::move(super::data_.pull().data);
@@ -337,8 +336,8 @@ namespace detail
 #endif
   }
 
-  template <class T, class Clock, class TimePoint>
-  void sync_timed_queue<T, Clock, TimePoint>::pull(T& elem)
+  template <class T, class Clock>
+  void sync_timed_queue<T, Clock>::pull(T& elem)
   {
     unique_lock<mutex> lk(super::mtx_);
     super::wait_until_not_empty(lk);
@@ -346,10 +345,10 @@ namespace detail
   }
 
   //////////////////////
-  template <class T, class Clock, class TimePoint>
-  template <class WClock, class Duration>
+  template <class T, class Clock>
+  template <class Duration>
   queue_op_status
-  sync_timed_queue<T, Clock, TimePoint>::pull_until(chrono::time_point<WClock, Duration> const& tp, T& elem)
+  sync_timed_queue<T, Clock>::pull_until(chrono::time_point<clock,Duration> const& tp, T& elem)
   {
     unique_lock<mutex> lk(super::mtx_);
 
@@ -359,17 +358,17 @@ namespace detail
   }
 
   //////////////////////
-  template <class T, class Clock, class TimePoint>
+  template <class T, class Clock>
   template <class Rep, class Period>
   queue_op_status
-  sync_timed_queue<T, Clock, TimePoint>::pull_for(chrono::duration<Rep,Period> const& dura, T& elem)
+  sync_timed_queue<T, Clock>::pull_for(chrono::duration<Rep,Period> const& dura, T& elem)
   {
-    return pull_until(chrono::steady_clock::now() + dura, elem);
+    return pull_until(clock::now() + dura, elem);
   }
 
   ///////////////////////////
-  template <class T, class Clock, class TimePoint>
-  queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_pull(unique_lock<mutex>& lk, T& elem)
+  template <class T, class Clock>
+  queue_op_status sync_timed_queue<T, Clock>::try_pull(unique_lock<mutex>& lk, T& elem)
   {
     if ( super::empty(lk) )
     {
@@ -385,8 +384,8 @@ namespace detail
     pull(lk, elem);
     return queue_op_status::success;
   }
-  template <class T, class Clock, class TimePoint>
-  queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_pull(lock_guard<mutex>& lk, T& elem)
+  template <class T, class Clock>
+  queue_op_status sync_timed_queue<T, Clock>::try_pull(lock_guard<mutex>& lk, T& elem)
   {
     if ( super::empty(lk) )
     {
@@ -402,16 +401,16 @@ namespace detail
     return queue_op_status::success;
   }
 
-  template <class T, class Clock, class TimePoint>
-  queue_op_status sync_timed_queue<T, Clock, TimePoint>::try_pull(T& elem)
+  template <class T, class Clock>
+  queue_op_status sync_timed_queue<T, Clock>::try_pull(T& elem)
   {
     lock_guard<mutex> lk(super::mtx_);
     return try_pull(lk, elem);
   }
 
   ///////////////////////////
-  template <class T, class Clock, class TimePoint>
-  queue_op_status sync_timed_queue<T, Clock, TimePoint>::wait_pull(unique_lock<mutex>& lk, T& elem)
+  template <class T, class Clock>
+  queue_op_status sync_timed_queue<T, Clock>::wait_pull(unique_lock<mutex>& lk, T& elem)
   {
     if (super::empty(lk))
     {
@@ -423,16 +422,16 @@ namespace detail
     return queue_op_status::success;
   }
 
-  template <class T, class Clock, class TimePoint>
-  queue_op_status sync_timed_queue<T, Clock, TimePoint>::wait_pull(T& elem)
+  template <class T, class Clock>
+  queue_op_status sync_timed_queue<T, Clock>::wait_pull(T& elem)
   {
     unique_lock<mutex> lk(super::mtx_);
     return wait_pull(lk, elem);
   }
 
 //  ///////////////////////////
-//  template <class T, class Clock, class TimePoint>
-//  queue_op_status sync_timed_queue<T, Clock, TimePoint>::wait_pull(unique_lock<mutex> &lk, T& elem)
+//  template <class T, class Clock>
+//  queue_op_status sync_timed_queue<T, Clock>::wait_pull(unique_lock<mutex> &lk, T& elem)
 //  {
 //    if (super::empty(lk))
 //    {
@@ -443,16 +442,16 @@ namespace detail
 //    pull(lk, elem);
 //    return queue_op_status::success;
 //  }
-//  template <class T, class Clock, class TimePoint>
-//  queue_op_status sync_timed_queue<T, Clock, TimePoint>::wait_pull(T& elem)
+//  template <class T>
+//  queue_op_status sync_timed_queue<T, Clock>::wait_pull(T& elem)
 //  {
 //    unique_lock<mutex> lk(super::mtx_);
 //    return wait_pull(lk, elem);
 //  }
 
   ///////////////////////////
-  template <class T, class Clock, class TimePoint>
-  queue_op_status sync_timed_queue<T, Clock, TimePoint>::nonblocking_pull(T& elem)
+  template <class T, class Clock>
+  queue_op_status sync_timed_queue<T, Clock>::nonblocking_pull(T& elem)
   {
     unique_lock<mutex> lk(super::mtx_, try_to_lock);
     if (! lk.owns_lock()) return queue_op_status::busy;

include/boost/thread/detail/config.hpp

@@ -12,24 +12,23 @@
 #include <boost/detail/workaround.hpp>
 #include <boost/thread/detail/platform.hpp>
 
+#define BOOST_THREAD_USEFIXES_TIMESPEC
 //#define BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
 //#define BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
 // ATTRIBUTE_MAY_ALIAS
 
-//#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
-#if !defined(BOOST_NO_MAY_ALIAS)
+#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
 
-  // GCC since 3.3 and some other compilers have may_alias attribute that helps
-  // to alleviate optimizer issues with regard to violation of the strict aliasing rules.
+  // GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with
+  // regard to violation of the strict aliasing rules.
 
   #define BOOST_THREAD_DETAIL_USE_ATTRIBUTE_MAY_ALIAS
-#endif
-#if defined(BOOST_MAY_ALIAS)
-#define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS BOOST_MAY_ALIAS
+  #define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__))
 #else
-#define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS
+  #define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS
 #endif
 
+
 #if defined BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
 #define BOOST_THREAD_ASSERT_PRECONDITION(EXPR, EX) \
         if (EXPR) {} else boost::throw_exception(EX)
@@ -387,7 +386,7 @@
 
 // provided for backwards compatibility, since this
 // macro was used for several releases by mistake.
-#if defined(BOOST_THREAD_DYN_DLL) && ! defined(BOOST_THREAD_DYN_LINK)
+#if defined(BOOST_THREAD_DYN_DLL) && ! defined BOOST_THREAD_DYN_LINK
 # define BOOST_THREAD_DYN_LINK
 #endif
 
@@ -446,7 +445,7 @@
 // Tell the autolink to link dynamically, this will get undef'ed by auto_link.hpp
 // once it's done with it:
 //
-#if defined(BOOST_THREAD_USE_DLL) &  ! defined(BOOST_DYN_LINK)
+#if defined(BOOST_THREAD_USE_DLL)
 #   define BOOST_DYN_LINK
 #endif
 //

include/boost/thread/detail/log.hpp

@@ -72,13 +72,7 @@ namespace boost
   }
 }
 
-#ifdef BOOST_MSVC
-#define BOOST_THREAD_LOG \
-        __pragma(warning(suppress:4127)) /* conditional expression is constant */ \
-        if (true) {} else boost::thread_detail::dummy_stream
-#else
 #define BOOST_THREAD_LOG if (true) {} else boost::thread_detail::dummy_stream
-#endif
 #define BOOST_THREAD_END_LOG boost::thread_detail::dummy_stream
 
 #endif
@@ -86,13 +80,4 @@ namespace boost
 #define BOOST_THREAD_TRACE BOOST_THREAD_LOG << BOOST_THREAD_END_LOG
 
 
-#ifdef BOOST_MSVC
-#define BOOST_DETAIL_THREAD_LOG \
-        __pragma(warning(suppress:4127)) /* conditional expression is constant */ \
-        if (false) {} else std::cout << std::endl << __FILE__ << "[" << __LINE__ << "]"
-#else
-#define BOOST_DETAIL_THREAD_LOG \
-        if (false) {} else std::cout << std::endl << __FILE__ << "[" << __LINE__ << "]"
-#endif
-
 #endif // header

include/boost/thread/detail/move.hpp

@@ -18,7 +18,9 @@
 #include <boost/type_traits/remove_extent.hpp>
 #include <boost/type_traits/is_array.hpp>
 #include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/remove_cv.hpp>
 #include <boost/type_traits/add_pointer.hpp>
+#include <boost/type_traits/decay.hpp>
 #endif
 
 #include <boost/thread/detail/delete.hpp>

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)
+#if defined(BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC) && defined(BOOST_THREAD_USEFIXES_TIMESPEC)
         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 as a thread_detail::is_rv
+        boost::thread_detail::is_rv<F>::value // todo ass a thread_detail::is_rv
         //boost::thread_detail::is_convertible<F&,BOOST_THREAD_RV_REF(F)>::value
             //|| is_same<typename decay<F>::type, thread>::value
            , dummy* >::type=0

include/boost/thread/executors/basic_thread_pool.hpp

@@ -86,18 +86,11 @@ namespace executors
         for(;;)
         {
           work task;
-          try
-          {
-            queue_op_status st = work_queue.wait_pull(task);
-            if (st == queue_op_status::closed) {
-              return;
-            }
-            task();
-          }
-          catch (boost::thread_interrupted&)
-          {
+          queue_op_status st = work_queue.wait_pull(task);
+          if (st == queue_op_status::closed) {
             return;
           }
+          task();
         }
       }
       catch (...)
@@ -241,7 +234,6 @@ namespace executors
     {
       for (unsigned i = 0; i < threads.size(); ++i)
       {
-        threads[i].interrupt();
         threads[i].join();
       }
     }

include/boost/thread/executors/detail/priority_executor_base.hpp

@@ -57,16 +57,10 @@ namespace detail
       {
         for(;;)
         {
-          try {
-            work task;
-            queue_op_status st = _workq.wait_pull(task);
-            if (st == queue_op_status::closed) return;
-            task();
-          }
-          catch (boost::thread_interrupted&)
-          {
-            return;
-          }
+          work task;
+          queue_op_status st = _workq.wait_pull(task);
+          if (st == queue_op_status::closed) return;
+          task();
         }
       }
       catch (...)

include/boost/thread/executors/scheduled_thread_pool.hpp

@@ -32,7 +32,6 @@ namespace executors
     ~scheduled_thread_pool()
     {
       this->close();
-      _workers.interrupt_all();
       _workers.join_all();
     }
 

include/boost/thread/executors/scheduler.hpp

@@ -16,11 +16,6 @@
 
 #include <boost/config/abi_prefix.hpp>
 
-#if defined(BOOST_MSVC)
-# pragma warning(push)
-# pragma warning(disable: 4355) // 'this' : used in base member initializer list
-#endif
-
 namespace boost
 {
   namespace executors
@@ -236,7 +231,6 @@ namespace boost
       ~scheduler()
       {
         this->close();
-        thr.interrupt();
         thr.join();
       }
       template <class Ex>
@@ -272,10 +266,6 @@ namespace boost
   using executors::scheduler;
 }
 
-#if defined(BOOST_MSVC)
-# pragma warning(pop)
-#endif
-
 #include <boost/config/abi_suffix.hpp>
 
 #endif

include/boost/thread/executors/scheduling_adaptor.hpp

@@ -10,33 +10,27 @@
 
 #include <boost/thread/executors/detail/scheduled_executor_base.hpp>
 
-#if defined(BOOST_MSVC)
-# pragma warning(push)
-# pragma warning(disable: 4355) // 'this' : used in base member initializer list
-#endif
-
 namespace boost
 {
 namespace executors
 {
 
   template <typename Executor>
-  class scheduling_adaptor : public detail::scheduled_executor_base<>
+  class scheduling_adpator : public detail::scheduled_executor_base<>
   {
   private:
     Executor& _exec;
     thread _scheduler;
   public:
 
-    scheduling_adaptor(Executor& ex)
+    scheduling_adpator(Executor& ex)
       : super(),
         _exec(ex),
         _scheduler(&super::loop, this) {}
 
-    ~scheduling_adaptor()
+    ~scheduling_adpator()
     {
       this->close();
-      _scheduler.interrupt();
       _scheduler.join();
     }
 
@@ -51,12 +45,7 @@ namespace executors
 
 } //end executors
 
-  using executors::scheduling_adaptor;
+  using executors::scheduling_adpator;
 
 } //end boost
-
-#if defined(BOOST_MSVC)
-# pragma warning(pop)
-#endif
-
 #endif

include/boost/thread/executors/serial_executor.hpp

@@ -20,11 +20,6 @@
 
 #include <boost/config/abi_prefix.hpp>
 
-#if defined(BOOST_MSVC)
-# pragma warning(push)
-# pragma warning(disable: 4355) // 'this' : used in base member initializer list
-#endif
-
 namespace boost
 {
 namespace executors
@@ -216,10 +211,6 @@ namespace executors
 using executors::serial_executor;
 }
 
-#if defined(BOOST_MSVC)
-# pragma warning(pop)
-#endif
-
 #include <boost/config/abi_suffix.hpp>
 
 #endif

include/boost/thread/future.hpp

@@ -299,7 +299,7 @@ namespace boost
                 }
                 do_continuation(lock);
             }
-            void notify_deferred()
+            void make_ready()
             {
               boost::unique_lock<boost::mutex> lock(this->mutex);
               mark_finished_internal(lock);
@@ -421,7 +421,7 @@ namespace boost
                 mark_exceptional_finish_internal(boost::current_exception(), lock);
             }
 
-            void set_exception_deferred(exception_ptr e)
+            void set_exception_at_thread_exit(exception_ptr e)
             {
               unique_lock<boost::mutex> lk(this->mutex);
               if (has_value(lk))
@@ -430,17 +430,6 @@ namespace boost
               }
               exception=e;
               this->is_constructed = true;
-            }
-            void set_exception_at_thread_exit(exception_ptr e)
-            {
-              set_exception_deferred(e);
-//              unique_lock<boost::mutex> lk(this->mutex);
-//              if (has_value(lk))
-//              {
-//                  throw_exception(promise_already_satisfied());
-//              }
-//              exception=e;
-//              this->is_constructed = true;
               detail::make_ready_at_thread_exit(shared_from_this());
             }
 
@@ -628,7 +617,8 @@ namespace boost
                 boost::unique_lock<boost::mutex> lk(this->mutex);
                 return this->get_sh(lk);
             }
-            void set_value_deferred(source_reference_type result_)
+
+            void set_value_at_thread_exit(source_reference_type result_)
             {
               unique_lock<boost::mutex> lk(this->mutex);
               if (this->has_value(lk))
@@ -642,14 +632,13 @@ namespace boost
 #endif
 
               this->is_constructed = true;
+              detail::make_ready_at_thread_exit(shared_from_this());
             }
-            void set_value_deferred(rvalue_source_type result_)
+            void set_value_at_thread_exit(rvalue_source_type result_)
             {
               unique_lock<boost::mutex> lk(this->mutex);
               if (this->has_value(lk))
-              {
                   throw_exception(promise_already_satisfied());
-              }
 
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 #if defined BOOST_THREAD_FUTURE_USES_OPTIONAL
@@ -665,46 +654,6 @@ namespace boost
 #endif
 #endif
               this->is_constructed = true;
-            }
-
-            void set_value_at_thread_exit(source_reference_type result_)
-            {
-                set_value_deferred(result_);
-//              unique_lock<boost::mutex> lk(this->mutex);
-//              if (this->has_value(lk))
-//              {
-//                  throw_exception(promise_already_satisfied());
-//              }
-//#if defined BOOST_THREAD_FUTURE_USES_OPTIONAL
-//              result = result_;
-//#else
-//              result.reset(new T(result_));
-//#endif
-//
-//              this->is_constructed = true;
-              detail::make_ready_at_thread_exit(shared_from_this());
-            }
-            void set_value_at_thread_exit(rvalue_source_type result_)
-            {
-                set_value_deferred(boost::move(result_));
-//              unique_lock<boost::mutex> lk(this->mutex);
-//              if (this->has_value(lk))
-//                  throw_exception(promise_already_satisfied());
-//
-//#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
-//#if defined BOOST_THREAD_FUTURE_USES_OPTIONAL
-//                result = boost::move(result_);
-//#else
-//                result.reset(new T(boost::move(result_)));
-//#endif
-//#else
-//#if defined BOOST_THREAD_FUTURE_USES_OPTIONAL
-//                result = boost::move(result_);
-//#else
-//                result.reset(new T(static_cast<rvalue_source_type>(result_)));
-//#endif
-//#endif
-//              this->is_constructed = true;
               detail::make_ready_at_thread_exit(shared_from_this());
             }
 
@@ -770,25 +719,13 @@ namespace boost
                 return get_sh(lock);
             }
 
-            void set_value_deferred(T& result_)
+            void set_value_at_thread_exit(T& result_)
             {
               unique_lock<boost::mutex> lk(this->mutex);
               if (this->has_value(lk))
-              {
                   throw_exception(promise_already_satisfied());
-              }
               result= &result_;
               this->is_constructed = true;
-            }
-
-            void set_value_at_thread_exit(T& result_)
-            {
-              set_value_deferred(result_);
-//              unique_lock<boost::mutex> lk(this->mutex);
-//              if (this->has_value(lk))
-//                  throw_exception(promise_already_satisfied());
-//              result= &result_;
-//              this->is_constructed = true;
               detail::make_ready_at_thread_exit(shared_from_this());
             }
 
@@ -842,7 +779,7 @@ namespace boost
                 this->get_sh(lock);
             }
 
-            void set_value_deferred()
+            void set_value_at_thread_exit()
             {
               unique_lock<boost::mutex> lk(this->mutex);
               if (this->has_value(lk))
@@ -850,16 +787,6 @@ namespace boost
                   throw_exception(promise_already_satisfied());
               }
               this->is_constructed = true;
-            }
-            void set_value_at_thread_exit()
-            {
-              set_value_deferred();
-//              unique_lock<boost::mutex> lk(this->mutex);
-//              if (this->has_value(lk))
-//              {
-//                  throw_exception(promise_already_satisfied());
-//              }
-//              this->is_constructed = true;
               detail::make_ready_at_thread_exit(shared_from_this());
             }
         private:
@@ -2336,8 +2263,7 @@ namespace boost
 
 #if defined  BOOST_NO_CXX11_RVALUE_REFERENCES
         template <class TR>
-        typename boost::enable_if_c<is_copy_constructible<TR>::value && is_same<R, TR>::value, void>::type
-            set_value(TR const &  r)
+        typename boost::enable_if_c<is_copy_constructible<TR>::value && is_same<R, TR>::value, void>::type set_value(TR const &  r)
         {
             lazy_init();
             boost::unique_lock<boost::mutex> lock(future_->mutex);
@@ -2375,44 +2301,6 @@ namespace boost
 #endif
         }
 
-#if defined  BOOST_NO_CXX11_RVALUE_REFERENCES
-        template <class TR>
-        typename boost::enable_if_c<is_copy_constructible<TR>::value && is_same<R, TR>::value, void>::type
-            set_value_deferred(TR const &  r)
-        {
-            lazy_init();
-            if (future_.get()==0)
-            {
-                boost::throw_exception(promise_moved());
-            }
-            future_->set_value_deferred(r);
-        }
-#else
-        void set_value_deferred(source_reference_type r)
-        {
-            lazy_init();
-            if (future_.get()==0)
-            {
-                boost::throw_exception(promise_moved());
-            }
-            future_->set_value_deferred(r);
-        }
-#endif
-
-        void set_value_deferred(rvalue_source_type r)
-        {
-            lazy_init();
-            if (future_.get()==0)
-            {
-                boost::throw_exception(promise_moved());
-            }
-#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
-            future_->set_value_deferred(boost::move(r));
-#else
-            future_->set_value_deferred(static_cast<rvalue_source_type>(r));
-#endif
-        }
-
 #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
         template <class ...Args>
         void emplace(BOOST_THREAD_FWD_REF(Args) ...args)
@@ -2443,21 +2331,6 @@ namespace boost
         {
           set_exception(boost::copy_exception(ex));
         }
-        void set_exception_deferred(boost::exception_ptr p)
-        {
-            lazy_init();
-            if (future_.get()==0)
-            {
-                boost::throw_exception(promise_moved());
-            }
-            future_->set_exception_deferred(p);
-        }
-        template <typename E>
-        void set_exception_deferred(E ex)
-        {
-          set_exception_deferred(boost::copy_exception(ex));
-        }
-
         // setting the result with deferred notification
 #if defined  BOOST_NO_CXX11_RVALUE_REFERENCES
         template <class TR>
@@ -2507,14 +2380,6 @@ namespace boost
             lazy_init();
             future_->set_wait_callback(f,this);
         }
-        void notify_deferred()
-        {
-            if (future_.get()==0)
-            {
-                boost::throw_exception(promise_moved());
-            }
-            future_->notify_deferred();
-        }
 
     };
 
@@ -2623,15 +2488,7 @@ namespace boost
             }
             future_->mark_finished_with_result_internal(r, lock);
         }
-        void set_value_deferred(R& r)
-        {
-            lazy_init();
-            if (future_.get()==0)
-            {
-                boost::throw_exception(promise_already_satisfied());
-            }
-            future_->set_value_deferred(r);
-        }
+
         void set_exception(boost::exception_ptr p)
         {
             lazy_init();
@@ -2647,20 +2504,7 @@ namespace boost
         {
           set_exception(boost::copy_exception(ex));
         }
-        void set_exception_deferred(boost::exception_ptr p)
-        {
-            lazy_init();
-            if (future_.get()==0)
-            {
-                boost::throw_exception(promise_moved());
-            }
-            future_->set_exception_deferred(p);
-        }
-        template <typename E>
-        void set_exception_deferred(E ex)
-        {
-          set_exception_deferred(boost::copy_exception(ex));
-        }
+
         // setting the result with deferred notification
         void set_value_at_thread_exit(R& r)
         {
@@ -2691,14 +2535,6 @@ namespace boost
             lazy_init();
             future_->set_wait_callback(f,this);
         }
-        void notify_deferred()
-        {
-            if (future_.get()==0)
-            {
-                boost::throw_exception(promise_moved());
-            }
-            future_->notify_deferred();
-        }
     };
 
     template <>
@@ -2808,15 +2644,6 @@ namespace boost
             }
             future_->mark_finished_with_result_internal(lock);
         }
-        void set_value_deferred()
-        {
-            lazy_init();
-            if (future_.get()==0)
-            {
-                boost::throw_exception(promise_moved());
-            }
-            future_->set_value_deferred();
-        }
 
         void set_exception(boost::exception_ptr p)
         {
@@ -2833,20 +2660,7 @@ namespace boost
         {
           set_exception(boost::copy_exception(ex));
         }
-        void set_exception_deferred(boost::exception_ptr p)
-        {
-            lazy_init();
-            if (future_.get()==0)
-            {
-                boost::throw_exception(promise_moved());
-            }
-            future_->set_exception_deferred(p);
-        }
-        template <typename E>
-        void set_exception_deferred(E ex)
-        {
-          set_exception_deferred(boost::copy_exception(ex));
-        }
+
         // setting the result with deferred notification
         void set_value_at_thread_exit()
         {
@@ -2877,14 +2691,7 @@ namespace boost
             lazy_init();
             future_->set_wait_callback(f,this);
         }
-        void notify_deferred()
-        {
-            if (future_.get()==0)
-            {
-                boost::throw_exception(promise_moved());
-            }
-            future_->notify_deferred();
-        }
+
     };
 }
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS

include/boost/thread/once.hpp

@@ -10,12 +10,6 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/thread/detail/config.hpp>
-
-#ifdef BOOST_MSVC
-# pragma warning(push)
-# pragma warning(disable: 4702) // unreachable code
-#endif
-
 #include <boost/thread/detail/platform.hpp>
 #if defined(BOOST_THREAD_PLATFORM_WIN32)
 #include <boost/thread/win32/once.hpp>
@@ -47,8 +41,4 @@ inline void call_once(Function func,once_flag& flag)
 
 #include <boost/config/abi_suffix.hpp>
 
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif
-
 #endif

include/boost/thread/pthread/condition_variable.hpp

@@ -79,7 +79,7 @@ namespace boost
             pthread_mutex_t* the_mutex = &internal_mutex;
             guard.activate(m);
             res = pthread_cond_wait(&cond,the_mutex);
-            check_for_interruption.unlock_if_locked();
+            check_for_interruption.check();
             guard.deactivate();
 #else
             pthread_mutex_t* the_mutex = m.mutex()->native_handle();
@@ -113,7 +113,7 @@ namespace boost
             pthread_mutex_t* the_mutex = &internal_mutex;
             guard.activate(m);
             cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout);
-            check_for_interruption.unlock_if_locked();
+            check_for_interruption.check();
             guard.deactivate();
 #else
             pthread_mutex_t* the_mutex = m.mutex()->native_handle();
@@ -190,7 +190,7 @@ namespace boost
 #endif
                 guard.activate(m);
                 res=pthread_cond_wait(&cond,&internal_mutex);
-                check_for_interruption.unlock_if_locked();
+                check_for_interruption.check();
                 guard.deactivate();
             }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
@@ -420,7 +420,7 @@ namespace boost
 #endif
               guard.activate(m);
               res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
-              check_for_interruption.unlock_if_locked();
+              check_for_interruption.check();
               guard.deactivate();
           }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS

include/boost/thread/pthread/condition_variable_fwd.hpp

@@ -53,9 +53,9 @@ namespace boost
     class condition_variable
     {
     private:
-//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
         pthread_mutex_t internal_mutex;
-//#endif
+#endif
         pthread_cond_t cond;
 
     public:
@@ -69,8 +69,16 @@ namespace boost
             unique_lock<mutex>& lock,
             struct timespec const &timeout)
         {
-#if defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-            return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now_monotonic()));
+#if ! defined BOOST_THREAD_USEFIXES_TIMESPEC
+            return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now()));
+#elif ! defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
+            //using namespace chrono;
+            //nanoseconds ns = chrono::system_clock::now().time_since_epoch();
+
+            struct timespec ts = boost::detail::timespec_now_realtime();
+            //ts.tv_sec = static_cast<long>(chrono::duration_cast<chrono::seconds>(ns).count());
+            //ts.tv_nsec = static_cast<long>((ns - chrono::duration_cast<chrono::seconds>(ns)).count());
+            return do_wait_until(lock, boost::detail::timespec_plus(timeout, ts));
 #else
             // old behavior was fine for monotonic
             return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now_realtime()));
@@ -82,37 +90,31 @@ namespace boost
         condition_variable()
         {
             int res;
-//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            // Even if it is not used, the internal_mutex exists (see
-            // above) and must be initialized (etc) in case some
-            // compilation units provide interruptions and others
-            // don't.
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             res=pthread_mutex_init(&internal_mutex,NULL);
             if(res)
             {
                 boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread_mutex_init"));
             }
-//#endif
+#endif
             res = detail::monotonic_pthread_cond_init(cond);
             if (res)
             {
-//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-                // ditto
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
-//#endif
+#endif
                 boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in detail::monotonic_pthread_cond_init"));
             }
         }
         ~condition_variable()
         {
             int ret;
-//#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            // ditto
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             do {
               ret = pthread_mutex_destroy(&internal_mutex);
             } while (ret == EINTR);
             BOOST_ASSERT(!ret);
-//#endif
+#endif
             do {
               ret = pthread_cond_destroy(&cond);
             } while (ret == EINTR);

include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp

@@ -30,7 +30,7 @@ namespace boost
                 BOOST_VERIFY(!pthread_mutex_unlock(m));
                 locked=false;
             }
-            void unlock_if_locked() BOOST_NOEXCEPT
+            void check() BOOST_NOEXCEPT
             {
               if(locked)
               {

include/boost/thread/pthread/shared_mutex.hpp

@@ -20,6 +20,7 @@
 #include <boost/chrono/ceil.hpp>
 #endif
 #include <boost/thread/detail/delete.hpp>
+#include <boost/assert.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 

include/boost/thread/pthread/thread_data.hpp

@@ -50,11 +50,7 @@ namespace boost
         // stack
         void set_stack_size(std::size_t size) BOOST_NOEXCEPT {
           if (size==0) return;
-#ifdef BOOST_THREAD_USES_GETPAGESIZE
           std::size_t page_size = getpagesize();
-#else
-          std::size_t page_size = ::sysconf( _SC_PAGESIZE);
-#endif
 #ifdef PTHREAD_STACK_MIN
           if (size<PTHREAD_STACK_MIN) size=PTHREAD_STACK_MIN;
 #endif
@@ -213,7 +209,7 @@ namespace boost
                     BOOST_VERIFY(!pthread_mutex_lock(m));
                 }
             }
-            void unlock_if_locked()
+            void check()
             {
               if ( ! done) {
                 if (set)
@@ -233,7 +229,7 @@ namespace boost
 
             ~interruption_checker() BOOST_NOEXCEPT_IF(false)
             {
-                unlock_if_locked();
+                check();
             }
         };
 #endif
@@ -244,12 +240,10 @@ namespace boost
         namespace hidden
         {
           void BOOST_THREAD_DECL sleep_for(const timespec& ts);
-          void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts);
+          void BOOST_THREAD_DECL sleep_until(const timespec& ts);
         }
 
 #ifdef BOOST_THREAD_USES_CHRONO
-        template <class Rep, class Period>
-        void sleep_for(const chrono::duration<Rep, Period>& d);
 #ifdef BOOST_THREAD_SLEEP_FOR_IS_STEADY
 
         inline
@@ -265,12 +259,10 @@ namespace boost
           namespace hidden
           {
             void BOOST_THREAD_DECL sleep_for(const timespec& ts);
-            void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts);
+            void BOOST_THREAD_DECL sleep_until(const timespec& ts);
           }
 
     #ifdef BOOST_THREAD_USES_CHRONO
-          template <class Rep, class Period>
-          void sleep_for(const chrono::duration<Rep, Period>& d);
     #ifdef BOOST_THREAD_SLEEP_FOR_IS_STEADY
 
           inline
@@ -292,7 +284,7 @@ namespace boost
 #endif
         inline void sleep(system_time const& abs_time)
         {
-          return boost::this_thread::hidden::sleep_until_realtime(boost::detail::to_timespec(abs_time));
+          return boost::this_thread::hidden::sleep_until(boost::detail::to_timespec(abs_time));
         }
 
         template<typename TimeDuration>

include/boost/thread/pthread/thread_heap_alloc.hpp

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

include/boost/thread/pthread/timespec.hpp

@@ -71,21 +71,32 @@ namespace boost
     {
       return (ts.tv_sec >= 0) || (ts.tv_nsec >= 0);
     }
-#if defined BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC
-
-    inline timespec timespec_now_monotonic()
+    inline timespec timespec_now()
     {
       timespec ts;
 
+#if defined CLOCK_MONOTONIC && defined BOOST_THREAD_USEFIXES_TIMESPEC
       if ( ::clock_gettime( CLOCK_MONOTONIC, &ts ) )
       {
         ts.tv_sec = 0;
         ts.tv_nsec = 0;
         BOOST_ASSERT(0 && "Boost::Thread - Internal Error");
       }
+#elif defined(BOOST_THREAD_TIMESPEC_MAC_API)
+      timeval tv;
+      ::gettimeofday(&tv, 0);
+      ts.tv_sec = tv.tv_sec;
+      ts.tv_nsec = tv.tv_usec * 1000;
+#else
+      if ( ::clock_gettime( CLOCK_REALTIME, &ts ) )
+      {
+        ts.tv_sec = 0;
+        ts.tv_nsec = 0;
+        BOOST_ASSERT(0 && "Boost::Thread - Internal Error");
+      }
+#endif
       return ts;
     }
-#endif
 
     inline timespec timespec_now_realtime()
     {

include/boost/thread/v2/shared_mutex.hpp

@@ -246,7 +246,7 @@ namespace boost {
       boost::unique_lock<mutex_t> lk(mut_);
       if (state_ & write_entered_)
       {
-        for (;;)
+        while (true)
         {
           boost::cv_status status = gate1_.wait_until(lk, abs_time);
           if ((state_ & write_entered_) == 0)
@@ -258,7 +258,7 @@ namespace boost {
       state_ |= write_entered_;
       if (state_ & n_readers_)
       {
-        for (;;)
+        while (true)
         {
           boost::cv_status status = gate2_.wait_until(lk, abs_time);
           if ((state_ & n_readers_) == 0)
@@ -281,7 +281,7 @@ namespace boost {
       boost::unique_lock<mutex_t> lk(mut_);
       if ((state_ & write_entered_) || (state_ & n_readers_) == n_readers_)
       {
-        for (;;)
+        while (true)
         {
           boost::cv_status status = gate1_.wait_until(lk, abs_time);
           if ((state_ & write_entered_) == 0 &&
@@ -303,7 +303,7 @@ namespace boost {
       boost::unique_lock<mutex_t> lk(mut_);
       if (state_ & write_entered_)
       {
-        for (;;)
+        while (true)
         {
           bool status = gate1_.timed_wait(lk, abs_time);
           if ((state_ & write_entered_) == 0)
@@ -315,7 +315,7 @@ namespace boost {
       state_ |= write_entered_;
       if (state_ & n_readers_)
       {
-        for (;;)
+        while (true)
         {
           bool status = gate2_.timed_wait(lk, abs_time);
           if ((state_ & n_readers_) == 0)
@@ -334,7 +334,7 @@ namespace boost {
         boost::unique_lock<mutex_t> lk(mut_);
         if (state_ & write_entered_)
         {
-          for (;;)
+          while (true)
           {
             bool status = gate1_.timed_wait(lk, abs_time);
             if ((state_ & write_entered_) == 0)
@@ -346,7 +346,7 @@ namespace boost {
         state_ |= write_entered_;
         if (state_ & n_readers_)
         {
-          for (;;)
+          while (true)
           {
             bool status = gate2_.timed_wait(lk, abs_time);
             if ((state_ & n_readers_) == 0)
@@ -524,7 +524,7 @@ namespace boost {
       boost::unique_lock<mutex_t> lk(mut_);
       if (state_ & (write_entered_ | upgradable_entered_))
       {
-        for (;;)
+        while (true)
         {
           boost::cv_status status = gate1_.wait_until(lk, abs_time);
           if ((state_ & (write_entered_ | upgradable_entered_)) == 0)
@@ -536,7 +536,7 @@ namespace boost {
       state_ |= write_entered_;
       if (state_ & n_readers_)
       {
-        for (;;)
+        while (true)
         {
           boost::cv_status status = gate2_.wait_until(lk, abs_time);
           if ((state_ & n_readers_) == 0)
@@ -559,7 +559,7 @@ namespace boost {
       boost::unique_lock<mutex_t> lk(mut_);
       if ((state_ & write_entered_) || (state_ & n_readers_) == n_readers_)
       {
-        for (;;)
+        while (true)
         {
           boost::cv_status status = gate1_.wait_until(lk, abs_time);
           if ((state_ & write_entered_) == 0 &&
@@ -584,7 +584,7 @@ namespace boost {
       if ((state_ & (write_entered_ | upgradable_entered_)) ||
           (state_ & n_readers_) == n_readers_)
       {
-        for (;;)
+        while (true)
         {
           boost::cv_status status = gate1_.wait_until(lk, abs_time);
           if ((state_ & (write_entered_ | upgradable_entered_)) == 0 &&
@@ -606,7 +606,7 @@ namespace boost {
         boost::unique_lock<mutex_t> lk(mut_);
         if (state_ & (write_entered_ | upgradable_entered_))
         {
-          for (;;)
+          while (true)
           {
             bool status = gate1_.timed_wait(lk, abs_time);
             if ((state_ & (write_entered_ | upgradable_entered_)) == 0)
@@ -618,7 +618,7 @@ namespace boost {
         state_ |= write_entered_;
         if (state_ & n_readers_)
         {
-          for (;;)
+          while (true)
           {
             bool status = gate2_.timed_wait(lk, abs_time);
             if ((state_ & n_readers_) == 0)
@@ -637,7 +637,7 @@ namespace boost {
         boost::unique_lock<mutex_t> lk(mut_);
         if ((state_ & write_entered_) || (state_ & n_readers_) == n_readers_)
         {
-          for (;;)
+          while (true)
           {
             bool status = gate1_.timed_wait(lk, abs_time);
             if ((state_ & write_entered_) == 0 &&
@@ -658,7 +658,7 @@ namespace boost {
         if ((state_ & (write_entered_ | upgradable_entered_)) ||
             (state_ & n_readers_) == n_readers_)
         {
-          for (;;)
+          while (true)
           {
             bool status = gate1_.timed_wait(lk, abs_time);
             if ((state_ & (write_entered_ | upgradable_entered_)) == 0 &&
@@ -683,7 +683,7 @@ namespace boost {
       boost::unique_lock<mutex_t> lk(mut_);
       if (state_ != 1)
       {
-        for (;;)
+        while (true)
         {
           boost::cv_status status = gate2_.wait_until(lk, abs_time);
           if (state_ == 1)
@@ -704,7 +704,7 @@ namespace boost {
       boost::unique_lock<mutex_t> lk(mut_);
       if ((state_ & (write_entered_ | upgradable_entered_)) != 0)
       {
-        for (;;)
+        while (true)
         {
           boost::cv_status status = gate2_.wait_until(lk, abs_time);
           if ((state_ & (write_entered_ | upgradable_entered_)) == 0)
@@ -725,7 +725,7 @@ namespace boost {
       boost::unique_lock<mutex_t> lk(mut_);
       if ((state_ & n_readers_) != 1)
       {
-        for (;;)
+        while (true)
         {
           boost::cv_status status = gate2_.wait_until(lk, abs_time);
           if ((state_ & n_readers_) == 1)

include/boost/thread/win32/basic_recursive_mutex.hpp

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

include/boost/thread/win32/basic_timed_mutex.hpp

@@ -55,7 +55,7 @@ namespace boost
 #endif
                 if(old_event)
                 {
-                    winapi::CloseHandle(old_event);
+                    win32::CloseHandle(old_event);
                 }
             }
 
@@ -81,9 +81,9 @@ namespace boost
 
                     do
                     {
-                        unsigned const retval(winapi::WaitForSingleObjectEx(sem, ::boost::detail::win32::infinite,0));
+                        unsigned const retval(win32::WaitForSingleObjectEx(sem, ::boost::detail::win32::infinite,0));
                         BOOST_VERIFY(0 == retval || ::boost::detail::win32::wait_abandoned == retval);
-//                        BOOST_VERIFY(winapi::WaitForSingleObject(
+//                        BOOST_VERIFY(win32::WaitForSingleObject(
 //                                         sem,::boost::detail::win32::infinite)==0);
                         clear_waiting_and_try_lock(old_count);
                         lock_acquired=!(old_count&lock_flag_value);
@@ -142,7 +142,7 @@ namespace boost
 
                     do
                     {
-                        if(winapi::WaitForSingleObjectEx(sem,::boost::detail::get_milliseconds_until(wait_until),0)!=0)
+                        if(win32::WaitForSingleObjectEx(sem,::boost::detail::get_milliseconds_until(wait_until),0)!=0)
                         {
                             BOOST_INTERLOCKED_DECREMENT(&active_count);
                             return false;
@@ -210,7 +210,7 @@ namespace boost
                       }
                       chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-now);
 
-                      if(winapi::WaitForSingleObjectEx(sem,static_cast<unsigned long>(rel_time.count()),0)!=0)
+                      if(win32::WaitForSingleObjectEx(sem,static_cast<unsigned long>(rel_time.count()),0)!=0)
                       {
                           BOOST_INTERLOCKED_DECREMENT(&active_count);
                           return false;
@@ -232,7 +232,7 @@ namespace boost
                 {
                     if(!win32::interlocked_bit_test_and_set(&active_count,event_set_flag_bit))
                     {
-                        winapi::SetEvent(get_event());
+                        win32::SetEvent(get_event());
                     }
                 }
             }
@@ -256,7 +256,7 @@ namespace boost
 #endif
                     if(old_event!=0)
                     {
-                        winapi::CloseHandle(new_event);
+                        win32::CloseHandle(new_event);
                         return old_event;
                     }
                     else

include/boost/thread/win32/condition_variable.hpp

@@ -76,7 +76,7 @@ namespace boost
             void release(unsigned count_to_release)
             {
                 notified=true;
-                detail::winapi::ReleaseSemaphore(semaphore,count_to_release,0);
+                detail::win32::ReleaseSemaphore(semaphore,count_to_release,0);
             }
 
             void release_waiters()
@@ -96,7 +96,7 @@ namespace boost
 
             bool woken()
             {
-                unsigned long const woken_result=detail::winapi::WaitForSingleObjectEx(wake_sem,0,0);
+                unsigned long const woken_result=detail::win32::WaitForSingleObjectEx(wake_sem,0,0);
                 BOOST_ASSERT((woken_result==detail::win32::timeout) || (woken_result==0));
                 return woken_result==0;
             }
@@ -135,7 +135,7 @@ namespace boost
             void wake_waiters(long count_to_wake)
             {
                 detail::interlocked_write_release(&total_count,total_count-count_to_wake);
-                detail::winapi::ReleaseSemaphore(wake_sem,count_to_wake,0);
+                detail::win32::ReleaseSemaphore(wake_sem,count_to_wake,0);
             }
 
             template<typename lock_type>

include/boost/thread/win32/mfc_thread_init.hpp

@@ -27,12 +27,12 @@ inline BOOL WINAPI ExtRawDllMain(HINSTANCE, DWORD dwReason, LPVOID)
   return TRUE; // ok
 }
 
-extern "C" __declspec(selectany) BOOL (WINAPI * const _pRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) = &ExtRawDllMain;
+extern "C" __declspec(selectany) BOOL (WINAPI * const _pRawDllMainOrig)(HANDLE, DWORD, LPVOID) = &ExtRawDllMain;
 
 # elif defined(_USRDLL)
 
-extern "C" BOOL WINAPI RawDllMain(HINSTANCE, DWORD dwReason, LPVOID);
-extern "C" __declspec(selectany) BOOL (WINAPI * const _pRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) = &RawDllMain;
+extern "C" BOOL WINAPI RawDllMain(HANDLE, DWORD dwReason, LPVOID);
+extern "C" __declspec(selectany) BOOL (WINAPI * const _pRawDllMainOrig)(HANDLE, DWORD, LPVOID) = &RawDllMain;
 
 # endif
 #endif

include/boost/thread/win32/once.hpp

@@ -124,7 +124,7 @@ namespace boost
             std::memcpy(mutex_name,fixed_mutex_name,sizeof(fixed_mutex_name));
             detail::int_to_string(reinterpret_cast<std::ptrdiff_t>(flag_address),
                                   mutex_name + once_mutex_name_fixed_length);
-            detail::int_to_string(winapi::GetCurrentProcessId(),
+            detail::int_to_string(win32::GetCurrentProcessId(),
                                   mutex_name + once_mutex_name_fixed_length + sizeof(void*)*2);
         }
 
@@ -136,9 +136,9 @@ namespace boost
             }
 
 #ifdef BOOST_NO_ANSI_APIS
-            return ::boost::detail::winapi::OpenEventW(
+            return ::boost::detail::win32::OpenEventW(
 #else
-            return ::boost::detail::winapi::OpenEventA(
+            return ::boost::detail::win32::OpenEventA(
 #endif
                 ::boost::detail::win32::synchronize |
                 ::boost::detail::win32::event_modify_state,
@@ -186,7 +186,7 @@ namespace boost
             }
             if(ctx.event_handle)
             {
-                ::boost::detail::winapi::ResetEvent(ctx.event_handle);
+                ::boost::detail::win32::ResetEvent(ctx.event_handle);
             }
             return true;
           }
@@ -207,7 +207,7 @@ namespace boost
           }
           if(ctx.event_handle)
           {
-              ::boost::detail::winapi::SetEvent(ctx.event_handle);
+              ::boost::detail::win32::SetEvent(ctx.event_handle);
           }
         }
         inline void rollback_once_region(once_flag& flag, once_context& ctx) BOOST_NOEXCEPT
@@ -219,7 +219,7 @@ namespace boost
           }
           if(ctx.event_handle)
           {
-              ::boost::detail::winapi::SetEvent(ctx.event_handle);
+              ::boost::detail::win32::SetEvent(ctx.event_handle);
           }
         }
     }
@@ -264,7 +264,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite, 0));
         }
     }
@@ -308,7 +308,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -355,7 +355,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -400,7 +400,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -443,7 +443,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -486,7 +486,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -529,7 +529,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -574,7 +574,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -617,7 +617,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -660,7 +660,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -703,7 +703,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -748,7 +748,7 @@ namespace boost
                         continue;
                     }
                 }
-                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                                  ctx.event_handle,::boost::detail::win32::infinite,0));
             }
         }
@@ -793,7 +793,7 @@ namespace boost
                         continue;
                     }
                 }
-                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                                  ctx.event_handle,::boost::detail::win32::infinite,0));
             }
         }
@@ -839,7 +839,7 @@ namespace boost
                         continue;
                     }
                 }
-                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                                  ctx.event_handle,::boost::detail::win32::infinite,0));
             }
         }
@@ -886,7 +886,7 @@ namespace boost
                         continue;
                     }
                 }
-                BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+                BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                                  ctx.event_handle,::boost::detail::win32::infinite,0));
             }
         }
@@ -930,7 +930,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -977,7 +977,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -1024,7 +1024,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }
@@ -1073,7 +1073,7 @@ namespace boost
                     continue;
                 }
             }
-            BOOST_VERIFY(!::boost::detail::winapi::WaitForSingleObjectEx(
+            BOOST_VERIFY(!::boost::detail::win32::WaitForSingleObjectEx(
                              ctx.event_handle,::boost::detail::win32::infinite,0));
         }
     }

include/boost/thread/win32/shared_mutex.hpp

@@ -67,19 +67,19 @@ namespace boost
         {
             if(old_state.exclusive_waiting)
             {
-                BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[exclusive_sem],1,0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[exclusive_sem],1,0)!=0);
             }
 
             if(old_state.shared_waiting || old_state.exclusive_waiting)
             {
-                BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
             }
         }
         void release_shared_waiters(state_data old_state)
         {
             if(old_state.shared_waiting || old_state.exclusive_waiting)
             {
-                BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
             }
         }
 
@@ -107,9 +107,9 @@ namespace boost
 
         ~shared_mutex()
         {
-            detail::winapi::CloseHandle(upgrade_sem);
-            detail::winapi::CloseHandle(semaphores[unlock_sem]);
-            detail::winapi::CloseHandle(semaphores[exclusive_sem]);
+            detail::win32::CloseHandle(upgrade_sem);
+            detail::win32::CloseHandle(semaphores[unlock_sem]);
+            detail::win32::CloseHandle(semaphores[exclusive_sem]);
         }
 
         bool try_lock_shared()
@@ -191,7 +191,7 @@ namespace boost
                     return true;
                 }
 
-                unsigned long const res=detail::winapi::WaitForSingleObjectEx(semaphores[unlock_sem],::boost::detail::get_milliseconds_until(wait_until), 0);
+                unsigned long const res=detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],::boost::detail::get_milliseconds_until(wait_until), 0);
                 if(res==detail::win32::timeout)
                 {
                     for(;;)
@@ -296,7 +296,7 @@ namespace boost
             unsigned long res;
             if (tp>n) {
               chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-n);
-              res=detail::winapi::WaitForSingleObjectEx(semaphores[unlock_sem],
+              res=detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],
                 static_cast<unsigned long>(rel_time.count()), 0);
             } else {
               res=detail::win32::timeout;
@@ -375,7 +375,7 @@ namespace boost
                     {
                         if(old_state.upgrade)
                         {
-                            BOOST_VERIFY(detail::winapi::ReleaseSemaphore(upgrade_sem,1,0)!=0);
+                            BOOST_VERIFY(detail::win32::ReleaseSemaphore(upgrade_sem,1,0)!=0);
                         }
                         else
                         {
@@ -474,7 +474,7 @@ namespace boost
                 #else
                 const bool wait_all = false;
                 #endif
-                unsigned long const wait_res=detail::winapi::WaitForMultipleObjectsEx(2,semaphores,wait_all,::boost::detail::get_milliseconds_until(wait_until), 0);
+                unsigned long const wait_res=detail::win32::WaitForMultipleObjectsEx(2,semaphores,wait_all,::boost::detail::get_milliseconds_until(wait_until), 0);
                 if(wait_res==detail::win32::timeout)
                 {
                     for(;;)
@@ -500,7 +500,7 @@ namespace boost
                         state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
                         if (must_notify)
                         {
-                          BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
+                          BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
                         }
 
                         if(current_state==old_state)
@@ -586,7 +586,7 @@ namespace boost
             unsigned long wait_res;
             if (tp>n) {
               chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-chrono::system_clock::now());
-              wait_res=detail::winapi::WaitForMultipleObjectsEx(2,semaphores,wait_all,
+              wait_res=detail::win32::WaitForMultipleObjectsEx(2,semaphores,wait_all,
                   static_cast<unsigned long>(rel_time.count()), 0);
             } else {
               wait_res=detail::win32::timeout;
@@ -616,7 +616,7 @@ namespace boost
                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
                 if (must_notify)
                 {
-                  BOOST_VERIFY(detail::winapi::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
+                  BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],1,0)!=0);
                 }
                 if(current_state==old_state)
                 {
@@ -698,7 +698,7 @@ namespace boost
                     return;
                 }
 
-                BOOST_VERIFY(!detail::winapi::WaitForSingleObjectEx(semaphores[unlock_sem],detail::winapi::infinite, 0));
+                BOOST_VERIFY(!detail::win32::WaitForSingleObjectEx(semaphores[unlock_sem],detail::win32::infinite, 0));
             }
         }
 
@@ -790,7 +790,7 @@ namespace boost
                 {
                     if(!last_reader)
                     {
-                        BOOST_VERIFY(!detail::winapi::WaitForSingleObjectEx(upgrade_sem,detail::win32::infinite, 0));
+                        BOOST_VERIFY(!detail::win32::WaitForSingleObjectEx(upgrade_sem,detail::win32::infinite, 0));
                     }
                     break;
                 }

include/boost/thread/win32/thread_data.hpp

@@ -153,7 +153,7 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             void interrupt()
             {
-                BOOST_VERIFY(detail::winapi::SetEvent(interruption_handle)!=0);
+                BOOST_VERIFY(detail::win32::SetEvent(interruption_handle)!=0);
             }
 #endif
             typedef detail::win32::handle native_handle_type;

include/boost/thread/win32/thread_heap_alloc.hpp

@@ -12,7 +12,45 @@
 #include <boost/throw_exception.hpp>
 #include <boost/core/no_exceptions_support.hpp>
 
-#include <boost/detail/winapi/heap_memory.hpp>
+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            using ::GetProcessHeap;
+            using ::HeapAlloc;
+            using ::HeapFree;
+        }
+    }
+}
+
+#else
+
+# ifdef HeapAlloc
+# undef HeapAlloc
+# endif
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            extern "C"
+            {
+                __declspec(dllimport) handle __stdcall GetProcessHeap();
+                __declspec(dllimport) void* __stdcall HeapAlloc(handle,unsigned long,ulong_ptr);
+                __declspec(dllimport) int __stdcall HeapFree(handle,unsigned long,void*);
+            }
+        }
+    }
+}
+
+#endif
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -22,7 +60,7 @@ namespace boost
     {
         inline void* allocate_raw_heap_memory(unsigned size)
         {
-            void* const heap_memory=detail::winapi::HeapAlloc(detail::winapi::GetProcessHeap(),0,size);
+            void* const heap_memory=detail::win32::HeapAlloc(detail::win32::GetProcessHeap(),0,size);
             if(!heap_memory)
             {
                 boost::throw_exception(std::bad_alloc());
@@ -32,26 +70,9 @@ namespace boost
 
         inline void free_raw_heap_memory(void* heap_memory)
         {
-            BOOST_VERIFY(detail::winapi::HeapFree(detail::winapi::GetProcessHeap(),0,heap_memory)!=0);
+            BOOST_VERIFY(detail::win32::HeapFree(detail::win32::GetProcessHeap(),0,heap_memory)!=0);
         }
-#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) && ! defined (BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template<typename T,typename... Args>
-        inline T* heap_new(Args&&... args)
-        {
-          void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-          BOOST_TRY
-          {
-              T* const data=new (heap_memory) T(static_cast<Args&&>(args)...);
-              return data;
-          }
-          BOOST_CATCH(...)
-          {
-              free_raw_heap_memory(heap_memory);
-              BOOST_RETHROW
-          }
-          BOOST_CATCH_END
-        }
-#else
+
         template<typename T>
         inline T* heap_new()
         {
@@ -204,86 +225,6 @@ namespace boost
             }
             BOOST_CATCH_END
         }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6,a7);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6,a7,a8);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-        template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8,typename A9>
-        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
-        {
-            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
-            BOOST_TRY
-            {
-                T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6,a7,a8,a9);
-                return data;
-            }
-            BOOST_CATCH(...)
-            {
-                free_raw_heap_memory(heap_memory);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
 
 
         template<typename T,typename A1>
@@ -443,7 +384,6 @@ namespace boost
             return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
         }
 
-#endif
 #endif
         template<typename T>
         inline void heap_delete(T* data)

include/boost/thread/win32/thread_primitives.hpp

@@ -17,21 +17,6 @@
 #include <boost/thread/exceptions.hpp>
 #include <boost/detail/interlocked.hpp>
 #include <boost/detail/winapi/config.hpp>
-
-#include <boost/detail/winapi/semaphore.hpp>
-#include <boost/detail/winapi/dll.hpp>
-#include <boost/detail/winapi/system.hpp>
-#include <boost/detail/winapi/time.hpp>
-#include <boost/detail/winapi/event.hpp>
-#include <boost/detail/winapi/thread.hpp>
-#include <boost/detail/winapi/get_current_thread.hpp>
-#include <boost/detail/winapi/get_current_thread_id.hpp>
-#include <boost/detail/winapi/get_current_process.hpp>
-#include <boost/detail/winapi/get_current_process_id.hpp>
-#include <boost/detail/winapi/wait.hpp>
-#include <boost/detail/winapi/handles.hpp>
-#include <boost/detail/winapi/access_rights.hpp>
-
 //#include <boost/detail/winapi/synchronization.hpp>
 #include <boost/thread/win32/interlocked_read.hpp>
 #include <algorithm>
@@ -40,29 +25,200 @@
 #include <thread>
 #endif
 
+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+
 namespace boost
 {
     namespace detail
     {
         namespace win32
         {
-            typedef ::boost::detail::winapi::HANDLE_ handle;
-            typedef ::boost::detail::winapi::SYSTEM_INFO_ system_info;
+            typedef HANDLE handle;
+            typedef SYSTEM_INFO system_info;
             typedef unsigned __int64 ticks_type;
-            typedef ::boost::detail::winapi::FARPROC_ farproc_t;
-            unsigned const infinite=::boost::detail::winapi::INFINITE_;
-            unsigned const timeout=::boost::detail::winapi::WAIT_TIMEOUT_;
-            handle const invalid_handle_value=::boost::detail::winapi::INVALID_HANDLE_VALUE_;
-            unsigned const event_modify_state=::boost::detail::winapi::EVENT_MODIFY_STATE_;
-            unsigned const synchronize=::boost::detail::winapi::SYNCHRONIZE_;
-            unsigned const wait_abandoned=::boost::detail::winapi::WAIT_ABANDONED_;
+            typedef FARPROC farproc_t;
+            unsigned const infinite=INFINITE;
+            unsigned const timeout=WAIT_TIMEOUT;
+            handle const invalid_handle_value=INVALID_HANDLE_VALUE;
+            unsigned const event_modify_state=EVENT_MODIFY_STATE;
+            unsigned const synchronize=SYNCHRONIZE;
+            unsigned const wait_abandoned=WAIT_ABANDONED;
             unsigned const create_event_initial_set = 0x00000002;
             unsigned const create_event_manual_reset = 0x00000001;
-            unsigned const event_all_access = ::boost::detail::winapi::EVENT_ALL_ACCESS_;
-            unsigned const semaphore_all_access = boost::detail::winapi::SEMAPHORE_ALL_ACCESS_;
+            unsigned const event_all_access = EVENT_ALL_ACCESS;
+            unsigned const semaphore_all_access = SEMAPHORE_ALL_ACCESS;
+
+
+# ifdef BOOST_NO_ANSI_APIS
+# if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
+            using ::CreateMutexW;
+            using ::CreateEventW;
+            using ::CreateSemaphoreW;
+# else
+            using ::CreateMutexExW;
+            using ::CreateEventExW;
+            using ::CreateSemaphoreExW;
+# endif
+            using ::OpenEventW;
+            using ::GetModuleHandleW;
+# else
+            using ::CreateMutexA;
+            using ::CreateEventA;
+            using ::OpenEventA;
+            using ::CreateSemaphoreA;
+            using ::GetModuleHandleA;
+# endif
+#if BOOST_PLAT_WINDOWS_RUNTIME
+            using ::GetNativeSystemInfo;
+            using ::GetTickCount64;
+#else
+            using ::GetSystemInfo;
+            using ::GetTickCount;
+#endif
+            using ::CloseHandle;
+            using ::ReleaseMutex;
+            using ::ReleaseSemaphore;
+            using ::SetEvent;
+            using ::ResetEvent;
+            using ::WaitForMultipleObjectsEx;
+            using ::WaitForSingleObjectEx;
+            using ::GetCurrentProcessId;
+            using ::GetCurrentThreadId;
+            using ::GetCurrentThread;
+            using ::GetCurrentProcess;
+            using ::DuplicateHandle;
+#if !BOOST_PLAT_WINDOWS_RUNTIME
+            using ::SleepEx;
+            using ::Sleep;
+            using ::QueueUserAPC;
+            using ::GetProcAddress;
+#endif
         }
     }
 }
+#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
+
+# ifdef UNDER_CE
+#  ifndef WINAPI
+#   ifndef _WIN32_WCE_EMULATION
+#    define WINAPI  __cdecl     // Note this doesn't match the desktop definition
+#   else
+#    define WINAPI  __stdcall
+#   endif
+#  endif
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+typedef int BOOL;
+typedef unsigned long DWORD;
+typedef void* HANDLE;
+#  include <kfuncs.h>
+#  ifdef __cplusplus
+}
+#  endif
+# endif
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+struct _SYSTEM_INFO;
+# ifdef __cplusplus
+}
+#endif
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+# ifdef _WIN64
+            typedef unsigned __int64 ulong_ptr;
+# else
+            typedef unsigned long ulong_ptr;
+# endif
+            typedef void* handle;
+            typedef _SYSTEM_INFO system_info;
+            typedef unsigned __int64 ticks_type;
+            typedef int (__stdcall *farproc_t)();
+            unsigned const infinite=~0U;
+            unsigned const timeout=258U;
+            handle const invalid_handle_value=(handle)(-1);
+            unsigned const event_modify_state=2;
+            unsigned const synchronize=0x100000u;
+            unsigned const wait_abandoned=0x00000080u;
+            unsigned const create_event_initial_set = 0x00000002;
+            unsigned const create_event_manual_reset = 0x00000001;
+            unsigned const event_all_access = 0x1F0003;
+            unsigned const semaphore_all_access = 0x1F0003;
+
+            extern "C"
+            {
+                struct _SECURITY_ATTRIBUTES;
+# ifdef BOOST_NO_ANSI_APIS
+# if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
+                __declspec(dllimport) void* __stdcall CreateMutexW(_SECURITY_ATTRIBUTES*,int,wchar_t const*);
+                __declspec(dllimport) void* __stdcall CreateSemaphoreW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*);
+                __declspec(dllimport) void* __stdcall CreateEventW(_SECURITY_ATTRIBUTES*,int,int,wchar_t const*);
+# else
+                __declspec(dllimport) void* __stdcall CreateMutexExW(_SECURITY_ATTRIBUTES*,wchar_t const*,unsigned long,unsigned long);
+                __declspec(dllimport) void* __stdcall CreateEventExW(_SECURITY_ATTRIBUTES*,wchar_t const*,unsigned long,unsigned long);
+                __declspec(dllimport) void* __stdcall CreateSemaphoreExW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*,unsigned long,unsigned long);
+# endif
+                __declspec(dllimport) void* __stdcall OpenEventW(unsigned long,int,wchar_t const*);
+                __declspec(dllimport) void* __stdcall GetModuleHandleW(wchar_t const*);
+# else
+                __declspec(dllimport) void* __stdcall CreateMutexA(_SECURITY_ATTRIBUTES*,int,char const*);
+                __declspec(dllimport) void* __stdcall CreateSemaphoreA(_SECURITY_ATTRIBUTES*,long,long,char const*);
+                __declspec(dllimport) void* __stdcall CreateEventA(_SECURITY_ATTRIBUTES*,int,int,char const*);
+                __declspec(dllimport) void* __stdcall OpenEventA(unsigned long,int,char const*);
+                __declspec(dllimport) void* __stdcall GetModuleHandleA(char const*);
+# endif
+#if BOOST_PLAT_WINDOWS_RUNTIME
+                __declspec(dllimport) void __stdcall GetNativeSystemInfo(_SYSTEM_INFO*);
+                __declspec(dllimport) ticks_type __stdcall GetTickCount64();
+#else
+                __declspec(dllimport) void __stdcall GetSystemInfo(_SYSTEM_INFO*);
+                __declspec(dllimport) unsigned long __stdcall GetTickCount();
+#endif
+                __declspec(dllimport) int __stdcall CloseHandle(void*);
+                __declspec(dllimport) int __stdcall ReleaseMutex(void*);
+                __declspec(dllimport) unsigned long __stdcall WaitForSingleObjectEx(void*,unsigned long,int);
+                __declspec(dllimport) unsigned long __stdcall WaitForMultipleObjectsEx(unsigned long nCount,void* const * lpHandles,int bWaitAll,unsigned long dwMilliseconds,int bAlertable);
+                __declspec(dllimport) int __stdcall ReleaseSemaphore(void*,long,long*);
+                __declspec(dllimport) int __stdcall DuplicateHandle(void*,void*,void*,void**,unsigned long,int,unsigned long);
+#if !BOOST_PLAT_WINDOWS_RUNTIME
+                __declspec(dllimport) unsigned long __stdcall SleepEx(unsigned long,int);
+                __declspec(dllimport) void __stdcall Sleep(unsigned long);
+                typedef void (__stdcall *queue_user_apc_callback_function)(ulong_ptr);
+                __declspec(dllimport) unsigned long __stdcall QueueUserAPC(queue_user_apc_callback_function,void*,ulong_ptr);
+                __declspec(dllimport) farproc_t __stdcall GetProcAddress(void *, const char *);
+#endif
+
+# ifndef UNDER_CE
+                __declspec(dllimport) unsigned long __stdcall GetCurrentProcessId();
+                __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId();
+                __declspec(dllimport) void* __stdcall GetCurrentThread();
+                __declspec(dllimport) void* __stdcall GetCurrentProcess();
+                __declspec(dllimport) int __stdcall SetEvent(void*);
+                __declspec(dllimport) int __stdcall ResetEvent(void*);
+# else
+                using ::GetCurrentProcessId;
+                using ::GetCurrentThreadId;
+                using ::GetCurrentThread;
+                using ::GetCurrentProcess;
+                using ::SetEvent;
+                using ::ResetEvent;
+# endif
+            }
+        }
+    }
+}
+#else
+# error "Win32 functions not available"
+#endif
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -94,7 +250,7 @@ namespace boost
                 ticks_type current_tick64;
 
                 previous_count = (unsigned long) boost::detail::interlocked_read_acquire(&count);
-                current_tick32 = ::boost::detail::winapi::GetTickCount();
+                current_tick32 = GetTickCount();
 
                 if(previous_count == (unsigned long)-1l)
                 {
@@ -146,13 +302,13 @@ namespace boost
                 // GetTickCount and GetModuleHandle are not allowed in the Windows Runtime,
                 // and kernel32 isn't used in Windows Phone.
 #if BOOST_PLAT_WINDOWS_RUNTIME
-                gettickcount64impl = &::boost::detail::winapi::GetTickCount64;
+                gettickcount64impl = &GetTickCount64;
 #else
                 farproc_t addr=GetProcAddress(
 #if !defined(BOOST_NO_ANSI_APIS)
-                    ::boost::detail::winapi::GetModuleHandleA("KERNEL32.DLL"),
+                    GetModuleHandleA("KERNEL32.DLL"),
 #else
-                    ::boost::detail::winapi::GetModuleHandleW(L"KERNEL32.DLL"),
+                    GetModuleHandleW(L"KERNEL32.DLL"),
 #endif
                     "GetTickCount64");
                 if(addr)
@@ -185,11 +341,11 @@ namespace boost
                 initial_event_state state)
             {
 #if !defined(BOOST_NO_ANSI_APIS)
-                handle const res = ::boost::detail::winapi::CreateEventA(0, type, state, mutex_name);
+                handle const res = win32::CreateEventA(0, type, state, mutex_name);
 #elif BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
-                handle const res = ::boost::detail::winapi::CreateEventW(0, type, state, mutex_name);
+                handle const res = win32::CreateEventW(0, type, state, mutex_name);
 #else
-                handle const res = ::boost::detail::winapi::CreateEventExW(
+                handle const res = win32::CreateEventExW(
                     0,
                     mutex_name,
                     type ? create_event_manual_reset : 0 | state ? create_event_initial_set : 0,
@@ -211,12 +367,12 @@ namespace boost
             inline handle create_anonymous_semaphore_nothrow(long initial_count,long max_count)
             {
 #if !defined(BOOST_NO_ANSI_APIS)
-                handle const res=::boost::detail::winapi::CreateSemaphoreA(0,initial_count,max_count,0);
+                handle const res=win32::CreateSemaphoreA(0,initial_count,max_count,0);
 #else
 #if BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_VISTA
-                handle const res=::boost::detail::winapi::CreateSemaphoreEx(0,initial_count,max_count,0,0);
+                handle const res=win32::CreateSemaphoreEx(0,initial_count,max_count,0,0);
 #else
-                handle const res=::boost::detail::winapi::CreateSemaphoreExW(0,initial_count,max_count,0,0,semaphore_all_access);
+                handle const res=win32::CreateSemaphoreExW(0,initial_count,max_count,0,0,semaphore_all_access);
 #endif
 #endif
                 return res;
@@ -234,10 +390,10 @@ namespace boost
 
             inline handle duplicate_handle(handle source)
             {
-                handle const current_process=::boost::detail::winapi::GetCurrentProcess();
+                handle const current_process=GetCurrentProcess();
                 long const same_access_flag=2;
                 handle new_handle=0;
-                bool const success=::boost::detail::winapi::DuplicateHandle(current_process,source,current_process,&new_handle,0,false,same_access_flag)!=0;
+                bool const success=DuplicateHandle(current_process,source,current_process,&new_handle,0,false,same_access_flag)!=0;
                 if(!success)
                 {
                     boost::throw_exception(thread_resource_error());
@@ -247,15 +403,15 @@ namespace boost
 
             inline void release_semaphore(handle semaphore,long count)
             {
-                BOOST_VERIFY(::boost::detail::winapi::ReleaseSemaphore(semaphore,count,0)!=0);
+                BOOST_VERIFY(ReleaseSemaphore(semaphore,count,0)!=0);
             }
 
             inline void get_system_info(system_info *info)
             {
 #if BOOST_PLAT_WINDOWS_RUNTIME
-                ::boost::detail::winapi::GetNativeSystemInfo(info);
+                win32::GetNativeSystemInfo(info);
 #else
-                ::boost::detail::winapi::GetSystemInfo(info);
+                win32::GetSystemInfo(info);
 #endif
             }
 
@@ -266,15 +422,15 @@ namespace boost
 #if BOOST_PLAT_WINDOWS_RUNTIME
                     std::this_thread::yield();
 #else
-                    ::boost::detail::winapi::Sleep(0);
+                    ::boost::detail::win32::Sleep(0);
 #endif
                 }
                 else
                 {
 #if BOOST_PLAT_WINDOWS_RUNTIME
-                    ::boost::detail::winapi::WaitForSingleObjectEx(::boost::detail::winapi::GetCurrentThread(), milliseconds, 0);
+                    ::boost::detail::win32::WaitForSingleObjectEx(::boost::detail::win32::GetCurrentThread(), milliseconds, 0);
 #else
-                    ::boost::detail::winapi::Sleep(milliseconds);
+                    ::boost::detail::win32::Sleep(milliseconds);
 #endif
                 }
             }
@@ -290,7 +446,7 @@ namespace boost
                 {
                     if (m_completionHandle != ::boost::detail::win32::invalid_handle_value)
                     {
-                        ::boost::detail::winapi::CloseHandle(m_completionHandle);
+                        CloseHandle(m_completionHandle);
                     }
                 }
 
@@ -318,7 +474,7 @@ namespace boost
                 {
                     if(handle_to_manage && handle_to_manage!=invalid_handle_value)
                     {
-                        BOOST_VERIFY(::boost::detail::winapi::CloseHandle(handle_to_manage));
+                        BOOST_VERIFY(CloseHandle(handle_to_manage));
                     }
                 }
 

src/pthread/once_atomic.cpp

@@ -40,7 +40,7 @@ namespace boost
         pthread::pthread_mutex_scoped_lock lk(&once_mutex);
         if (f.load(memory_order_acquire) != initialized)
         {
-          for (;;)
+          while (true)
           {
             atomic_int_type expected = uninitialized;
             if (f.compare_exchange_strong(expected, in_progress, memory_order_acq_rel, memory_order_acquire))

src/pthread/thread.cpp

@@ -52,7 +52,7 @@ namespace boost
             for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                     i != e; ++i)
             {
-                (*i)->notify_deferred();
+                (*i)->make_ready();
             }
         }
 
@@ -457,7 +457,7 @@ namespace boost
                 }
           }
 
-          void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts)
+          void BOOST_THREAD_DECL sleep_until(const timespec& ts)
           {
                 timespec now = boost::detail::timespec_now_realtime();
                 if (boost::detail::timespec_gt(ts, now))
@@ -487,6 +487,7 @@ namespace boost
                   }
                 }
           }
+
         }
       }
       namespace hidden
@@ -506,7 +507,7 @@ namespace boost
             }
         }
 
-        void BOOST_THREAD_DECL sleep_until_realtime(const timespec& ts)
+        void BOOST_THREAD_DECL sleep_until(const timespec& ts)
         {
             boost::detail::thread_data_base* const thread_info=boost::detail::get_current_thread_data();
 
@@ -517,7 +518,7 @@ namespace boost
             }
             else
             {
-              boost::this_thread::no_interruption_point::hidden::sleep_until_realtime(ts);
+              boost::this_thread::no_interruption_point::hidden::sleep_until(ts);
             }
         }
       } // hidden

src/win32/thread.cpp

@@ -3,7 +3,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 // (C) Copyright 2007 Anthony Williams
 // (C) Copyright 2007 David Deakins
-// (C) Copyright 2011-2017 Vicente J. Botet Escriba
+// (C) Copyright 2011-2013 Vicente J. Botet Escriba
 
 //#define BOOST_THREAD_VERSION 3
 
@@ -57,7 +57,7 @@ namespace boost
         for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                 i != e; ++i)
         {
-            (*i)->notify_deferred();
+            (*i)->make_ready();
         }
     }
   }
@@ -154,6 +154,8 @@ namespace boost
             return ret;
         }
 
+        //typedef void* uintptr_t;
+
         inline uintptr_t _beginthreadex(void* security, unsigned stack_size, unsigned (__stdcall* start_address)(void*),
                                               void* arglist, unsigned initflag, unsigned* thrdaddr)
         {
@@ -297,7 +299,12 @@ namespace boost
             BOOST_CATCH(thread_interrupted const&)
             {
             }
-            // Unhandled exceptions still cause the application to terminate
+// Removed as it stops the debugger identifying the cause of the exception
+// Unhandled exceptions still cause the application to terminate
+//             BOOST_CATCH(...)
+//             {
+//                 std::terminate();
+//             }
             BOOST_CATCH_END
 #endif
             run_thread_exit_callbacks();
@@ -315,6 +322,7 @@ namespace boost
          if (!thread_info->thread_handle.start(&thread_start_function, thread_info.get(), &thread_info->id))
          {
              intrusive_ptr_release(thread_info.get());
+//           boost::throw_exception(thread_resource_error());
              return false;
          }
          return true;
@@ -323,6 +331,7 @@ namespace boost
         if(!new_thread)
         {
             return false;
+//            boost::throw_exception(thread_resource_error());
         }
         intrusive_ptr_add_ref(thread_info.get());
         thread_info->thread_handle=(detail::win32::handle)(new_thread);
@@ -338,11 +347,12 @@ namespace boost
         attr;
         return start_thread_noexcept();
 #else
-      uintptr_t const new_thread=_beginthreadex(0,static_cast<unsigned int>(attr.get_stack_size()),&thread_start_function,thread_info.get(),
-                                                CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION, &thread_info->id);
+      //uintptr_t const new_thread=_beginthreadex(attr.get_security(),attr.get_stack_size(),&thread_start_function,thread_info.get(),CREATE_SUSPENDED,&thread_info->id);
+      uintptr_t const new_thread=_beginthreadex(0,static_cast<unsigned int>(attr.get_stack_size()),&thread_start_function,thread_info.get(),CREATE_SUSPENDED,&thread_info->id);
       if(!new_thread)
       {
         return false;
+//          boost::throw_exception(thread_resource_error());
       }
       intrusive_ptr_add_ref(thread_info.get());
       thread_info->thread_handle=(detail::win32::handle)(new_thread);
@@ -498,7 +508,7 @@ namespace boost
     bool thread::interruption_requested() const BOOST_NOEXCEPT
     {
         detail::thread_data_ptr local_thread_info=(get_thread_info)();
-        return local_thread_info.get() && (detail::winapi::WaitForSingleObjectEx(local_thread_info->interruption_handle,0,0)==0);
+        return local_thread_info.get() && (detail::win32::WaitForSingleObjectEx(local_thread_info->interruption_handle,0,0)==0);
     }
 
 #endif
@@ -634,6 +644,7 @@ namespace boost
                     } Detailed;
                 } Reason;
             } REASON_CONTEXT, *PREASON_CONTEXT;
+            //static REASON_CONTEXT default_reason_context={0/*POWER_REQUEST_CONTEXT_VERSION*/, 0x00000001/*POWER_REQUEST_CONTEXT_SIMPLE_STRING*/, (LPWSTR)L"generic"};
             typedef BOOL (WINAPI *setwaitabletimerex_t)(HANDLE, const LARGE_INTEGER *, LONG, PTIMERAPCROUTINE, LPVOID, PREASON_CONTEXT, ULONG);
             static inline BOOL WINAPI SetWaitableTimerEx_emulation(HANDLE hTimer, const LARGE_INTEGER *lpDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, PREASON_CONTEXT WakeContext, ULONG TolerableDelay)
             {
@@ -703,6 +714,7 @@ namespace boost
                     if(time_left.milliseconds/20>tolerable)  // 5%
                         tolerable=time_left.milliseconds/20;
                     LARGE_INTEGER due_time=get_due_time(target_time);
+                    //bool const set_time_succeeded=detail_::SetWaitableTimerEx()(timer_handle,&due_time,0,0,0,&detail_::default_reason_context,tolerable)!=0;
                     bool const set_time_succeeded=detail_::SetWaitableTimerEx()(timer_handle,&due_time,0,0,0,NULL,tolerable)!=0;
                     if(set_time_succeeded)
                     {
@@ -726,7 +738,7 @@ namespace boost
 
                 if(handle_count)
                 {
-                    unsigned long const notified_index=detail::winapi::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
+                    unsigned long const notified_index=detail::win32::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
                     if(notified_index<handle_count)
                     {
                         if(notified_index==wait_handle_index)
@@ -736,7 +748,7 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                         else if(notified_index==interruption_index)
                         {
-                            detail::winapi::ResetEvent(detail::get_current_thread_data()->interruption_handle);
+                            detail::win32::ResetEvent(detail::get_current_thread_data()->interruption_handle);
                             throw thread_interrupted();
                         }
 #endif
@@ -787,6 +799,7 @@ namespace boost
                     if(time_left.milliseconds/20>tolerable)  // 5%
                         tolerable=time_left.milliseconds/20;
                     LARGE_INTEGER due_time=get_due_time(target_time);
+                    //bool const set_time_succeeded=detail_::SetWaitableTimerEx()(timer_handle,&due_time,0,0,0,&detail_::default_reason_context,tolerable)!=0;
                     bool const set_time_succeeded=detail_::SetWaitableTimerEx()(timer_handle,&due_time,0,0,0,NULL,tolerable)!=0;
                     if(set_time_succeeded)
                     {
@@ -810,7 +823,7 @@ namespace boost
 
                 if(handle_count)
                 {
-                    unsigned long const notified_index=detail::winapi::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
+                    unsigned long const notified_index=detail::win32::WaitForMultipleObjectsEx(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds, 0);
                     if(notified_index<handle_count)
                     {
                         if(notified_index==wait_handle_index)
@@ -847,7 +860,7 @@ namespace boost
                 return current_thread_data->id;
             }
 #endif
-            return detail::winapi::GetCurrentThreadId();
+            return detail::win32::GetCurrentThreadId();
 #else
             return thread::id(get_or_make_current_thread_data());
 #endif
@@ -858,7 +871,7 @@ namespace boost
         {
             if(interruption_enabled() && interruption_requested())
             {
-                detail::winapi::ResetEvent(detail::get_current_thread_data()->interruption_handle);
+                detail::win32::ResetEvent(detail::get_current_thread_data()->interruption_handle);
                 throw thread_interrupted();
             }
         }
@@ -870,7 +883,7 @@ namespace boost
 
         bool interruption_requested() BOOST_NOEXCEPT
         {
-            return detail::get_current_thread_data() && (detail::winapi::WaitForSingleObjectEx(detail::get_current_thread_data()->interruption_handle,0,0)==0);
+            return detail::get_current_thread_data() && (detail::win32::WaitForSingleObjectEx(detail::get_current_thread_data()->interruption_handle,0,0)==0);
         }
 #endif
 
@@ -1015,5 +1028,16 @@ namespace boost
         current_thread_data->notify_all_at_thread_exit(&cond, lk.release());
       }
     }
+//namespace detail {
+//
+//    void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
+//    {
+//      detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
+//      if(current_thread_data)
+//      {
+//        current_thread_data->make_ready_at_thread_exit(as);
+//      }
+//    }
+//}
 }
 

src/win32/tss_pe.cpp

@@ -94,8 +94,8 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
 #if (_MSC_VER >= 1500)
 
 extern "C" {
-extern BOOL (WINAPI * const _pRawDllMainOrig)(HINSTANCE, DWORD, LPVOID);
-extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) = NULL;
+extern BOOL (WINAPI * const _pRawDllMainOrig)(HANDLE, DWORD, LPVOID);
+extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HANDLE, DWORD, LPVOID) = NULL;
 #if defined (_M_IX86)
 #pragma comment(linker, "/alternatename:__pRawDllMainOrig=__pDefaultRawDllMainOrig")
 #elif defined (_M_X64) || defined (_M_ARM)
@@ -111,28 +111,10 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) =
 
 
     //Definitions required by implementation
-    #if (_MSC_VER < 1300) || ((_MSC_VER > 1900) && (_MSC_VER < 1910)) // 1300 == VC++ 7.0, 1900 == VC++ 14.0, 1910 == VC++ 2017
-        typedef void ( __cdecl *_PVFV_ )();
-        typedef void ( __cdecl *_PIFV_ )();
-        #define INIRETSUCCESS_V
-        #define INIRETSUCCESS_I
-        #define PVAPI_V void __cdecl
-        #define PVAPI_I void __cdecl
-    #elif (_MSC_VER >= 1910)
-        typedef void ( __cdecl *_PVFV_ )();
-        typedef int ( __cdecl *_PIFV_ )();
-        #define INIRETSUCCESS_V
-        #define INIRETSUCCESS_I 0
-        #define PVAPI_V void __cdecl
-        #define PVAPI_I int __cdecl
-    #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 int (__cdecl *_PVFV)();
+    #define INIRETSUCCESS 0
+    #define PVAPI int __cdecl
 
     typedef void (NTAPI* _TLSCB)(HINSTANCE, DWORD, PVOID);
 
@@ -148,9 +130,9 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) =
     {
         //Forward declarations
 
-        static PVAPI_I on_tls_prepare();
-        static PVAPI_V on_process_init();
-        static PVAPI_V on_process_term();
+        static PVAPI on_tls_prepare();
+        static PVAPI on_process_init();
+        static PVAPI on_process_term();
         static void NTAPI on_tls_callback(HINSTANCE, DWORD, PVOID);
 
         //The .CRT$Xxx information is taken from Codeguru:
@@ -162,9 +144,9 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) =
 #pragma section(".CRT$XTU",long,read)
 #pragma section(".CRT$XLC",long,read)
         __declspec(allocate(".CRT$XLC")) _TLSCB __xl_ca=on_tls_callback;
-        __declspec(allocate(".CRT$XIU"))_PIFV_ p_tls_prepare = on_tls_prepare;
-        __declspec(allocate(".CRT$XCU"))_PVFV_ p_process_init = on_process_init;
-        __declspec(allocate(".CRT$XTU"))_PVFV_ p_process_term = on_process_term;
+        __declspec(allocate(".CRT$XIU"))_PVFV p_tls_prepare = on_tls_prepare;
+        __declspec(allocate(".CRT$XCU"))_PVFV p_process_init = on_process_init;
+        __declspec(allocate(".CRT$XTU"))_PVFV p_process_term = on_process_term;
 #else
         #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
         #   pragma data_seg(push, old_seg)
@@ -176,13 +158,13 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) =
             //this could be changed easily if required.
 
             #pragma data_seg(".CRT$XIU")
-            static _PIFV_ p_tls_prepare = on_tls_prepare;
+            static _PVFV p_tls_prepare = on_tls_prepare;
             #pragma data_seg()
 
             //Callback after all global ctors.
 
             #pragma data_seg(".CRT$XCU")
-            static _PVFV_ p_process_init = on_process_init;
+            static _PVFV p_process_init = on_process_init;
             #pragma data_seg()
 
             //Callback for tls notifications.
@@ -193,7 +175,7 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) =
             //Callback for termination.
 
             #pragma data_seg(".CRT$XTU")
-            static _PVFV_ p_process_term = on_process_term;
+            static _PVFV p_process_term = on_process_term;
             #pragma data_seg()
         #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
         #   pragma data_seg(pop, old_seg)
@@ -205,7 +187,7 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) =
 #pragma warning(disable:4189)
 #endif
 
-        PVAPI_I on_tls_prepare()
+        PVAPI on_tls_prepare()
         {
             //The following line has an important side effect:
             //if the TLS directory is not already there, it will
@@ -240,13 +222,13 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) =
                 *pfdst = 0;
             #endif
 
-            return INIRETSUCCESS_I;
+            return INIRETSUCCESS;
         }
 #ifdef BOOST_MSVC
 #pragma warning(pop)
 #endif
 
-        PVAPI_V on_process_init()
+        PVAPI on_process_init()
         {
             //Schedule on_thread_exit() to be called for the main
             //thread before destructors of global objects have been
@@ -263,13 +245,13 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) =
 
             boost::on_process_enter();
 
-            return INIRETSUCCESS_V;
+            return INIRETSUCCESS;
         }
 
-        PVAPI_V on_process_term()
+        PVAPI on_process_term()
         {
             boost::on_process_exit();
-            return INIRETSUCCESS_V;
+            return INIRETSUCCESS;
         }
 
         void NTAPI on_tls_callback(HINSTANCE /*h*/, DWORD dwReason, PVOID /*pv*/)
@@ -283,9 +265,9 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) =
         }
 
 #if (_MSC_VER >= 1500)
-        BOOL WINAPI dll_callback(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
+        BOOL WINAPI dll_callback(HANDLE hInstance, DWORD dwReason, LPVOID lpReserved)
 #else
-        BOOL WINAPI dll_callback(HINSTANCE, DWORD dwReason, LPVOID)
+        BOOL WINAPI dll_callback(HANDLE, DWORD dwReason, LPVOID)
 #endif
         {
             switch (dwReason)
@@ -310,7 +292,7 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) =
 
 extern "C"
 {
-    extern BOOL (WINAPI * const _pRawDllMain)(HINSTANCE, DWORD, LPVOID)=&dll_callback;
+    extern BOOL (WINAPI * const _pRawDllMain)(HANDLE, DWORD, LPVOID)=&dll_callback;
 }
 namespace boost
 {

test/Jamfile.v2

@@ -145,14 +145,14 @@ rule thread-run2 ( sources : name )
     ;
 }
 
-rule thread-run2-noit ( sources : name : reqs * )
+rule thread-run2-noit ( sources : name )
 {
     sources = $(sources) winrt_init.cpp ;
     return
-    [ run $(sources) ../build//boost_thread : : : $(reqs)
+    [ run $(sources) ../build//boost_thread : : :
       : $(name) ]
     [ run $(sources) ../src/tss_null.cpp ../build//boost_thread/<link>static
-        : : : $(reqs)
+        : : :
       : $(name)_lib ]
     #[ run $(sources) ../build//boost_thread : : :
     #  <define>BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
@@ -798,9 +798,9 @@ rule thread-compile ( sources : reqs * : name )
           [ thread-run2-noit ../example/synchronized_value.cpp : ex_synchronized_value ]
           [ thread-run2-noit ../example/synchronized_person.cpp : ex_synchronized_person ]
           [ thread-run2-noit ../example/thread_guard.cpp : ex_thread_guard ]
-          [ thread-run2-noit ../example/std_thread_guard.cpp : ex_std_thread_guard : <toolset>gcc-4.8:<build>no ]
+          [ thread-run2-noit ../example/std_thread_guard.cpp : ex_std_thread_guard ]
           [ thread-run2-noit ../example/scoped_thread.cpp : ex_scoped_thread ]
-          [ thread-run2-noit ../example/std_scoped_thread.cpp : ex_std_scoped_thread : <toolset>gcc-4.8:<build>no ]
+          [ thread-run2-noit ../example/std_scoped_thread.cpp : ex_std_scoped_thread ]
           [ thread-run2-noit ../example/strict_lock.cpp : ex_strict_lock ]
           [ thread-run2-noit ../example/ba_externallly_locked.cpp : ex_ba_externallly_locked ]
           [ thread-run2 ../example/producer_consumer_bounded.cpp : ex_producer_consumer_bounded ]

test/sync/conditions/condition_variable/wait_until_pred_pass.cpp

@@ -74,7 +74,6 @@ void f()
     Clock::time_point t0 = Clock::now();
     Clock::time_point t = t0 + Clock::duration(250);
     bool r = cv.wait_until(lk, t, Pred(test2));
-    (void)r;
     Clock::time_point t1 = Clock::now();
     if (runs == 0)
     {

test/sync/futures/future/get_or_pass.cpp

@@ -22,10 +22,6 @@
 
 #if defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 namespace boost
 {
 template <typename T>

test/sync/futures/future/get_pass.cpp

@@ -32,10 +32,6 @@
 
 #if defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 namespace boost
 {
 template <typename T>

test/sync/futures/future/then_deferred_pass.cpp

@@ -21,9 +21,6 @@
 
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
 
 int p1()
 {

test/sync/futures/future/then_executor_pass.cpp

@@ -24,9 +24,6 @@
 
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
 
 int p1()
 {

test/sync/futures/future/then_pass.cpp

@@ -20,9 +20,6 @@
 
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
 
 int p1()
 {

test/sync/futures/future/wait_for_pass.cpp

@@ -32,10 +32,6 @@
 
 #if defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 typedef boost::chrono::milliseconds ms;
 
 namespace boost

test/sync/futures/future/wait_pass.cpp

@@ -32,10 +32,6 @@
 
 #if defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 typedef boost::chrono::milliseconds ms;
 
 namespace boost

test/sync/futures/future/wait_until_pass.cpp

@@ -33,10 +33,6 @@
 
 #if defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 typedef boost::chrono::milliseconds ms;
 
 namespace boost

test/sync/futures/promise/set_exception_pass.cpp

@@ -75,36 +75,7 @@ int main()
       BOOST_TEST(false);
     }
   }
-  {
-    typedef int T;
-    boost::promise<T> p;
-    boost::future<T> f = p.get_future();
-    p.set_exception_deferred(boost::make_exception_ptr(3));
-    BOOST_TEST(!f.is_ready());
-    p.notify_deferred();
-    try
-    {
-      f.get();
-      BOOST_TEST(false);
-    }
-    catch (boost::wrap<int> i)
-    {
-      BOOST_TEST(i.value == 3);
-    }
-    try
-    {
-      p.set_exception(boost::make_exception_ptr(3));
-      BOOST_TEST(false);
-    }
-    catch (const boost::future_error& e)
-    {
-      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::promise_already_satisfied));
-    }
-    catch (...)
-    {
-      BOOST_TEST(false);
-    }
-  }
+
   return boost::report_errors();
 }
 

test/sync/futures/promise/set_lvalue_pass.cpp

@@ -51,82 +51,7 @@ int main()
       BOOST_TEST(false);
     }
   }
-  {
-    typedef int& T;
-    int i = 3;
-    boost::promise<T> p;
-    boost::future<T> f = p.get_future();
-    p.set_value(i);
-    int& j = f.get();
-    BOOST_TEST(j == 3);
-    ++i;
-    BOOST_TEST(j == 4);
-    try
-    {
-      p.set_value_deferred(i);
-      BOOST_TEST(false);
-    }
-    catch (const boost::future_error& e)
-    {
-      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::promise_already_satisfied));
-    }
-    catch (...)
-    {
-      BOOST_TEST(false);
-    }
-  }
-  {
-    typedef int& T;
-    int i = 3;
-    boost::promise<T> p;
-    boost::future<T> f = p.get_future();
-    p.set_value_deferred(i);
-    BOOST_TEST(!f.is_ready());
-    p.notify_deferred();
-    int& j = f.get();
-    BOOST_TEST(j == 3);
-    ++i;
-    BOOST_TEST(j == 4);
-    try
-    {
-      p.set_value_deferred(i);
-      BOOST_TEST(false);
-    }
-    catch (const boost::future_error& e)
-    {
-      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::promise_already_satisfied));
-    }
-    catch (...)
-    {
-      BOOST_TEST(false);
-    }
-  }
-  {
-    typedef int& T;
-    int i = 3;
-    boost::promise<T> p;
-    boost::future<T> f = p.get_future();
-    p.set_value_deferred(i);
-    BOOST_TEST(!f.is_ready());
-    p.notify_deferred();
-    int& j = f.get();
-    BOOST_TEST(j == 3);
-    ++i;
-    BOOST_TEST(j == 4);
-    try
-    {
-      p.set_value(i);
-      BOOST_TEST(false);
-    }
-    catch (const boost::future_error& e)
-    {
-      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::promise_already_satisfied));
-    }
-    catch (...)
-    {
-      BOOST_TEST(false);
-    }
-  }
+
   return boost::report_errors();
 }
 

test/sync/futures/promise/set_rvalue_pass.cpp

@@ -118,28 +118,6 @@ int main()
       BOOST_TEST(false);
     }
   }
-  {
-    typedef A T;
-    T i;
-    boost::promise<T> p;
-    boost::future<T> f = p.get_future();
-    try
-    {
-      p.set_value_deferred(boost::move(i));
-      BOOST_TEST(!f.is_ready());
-      p.notify_deferred();
-
-      BOOST_TEST(false);
-    }
-    catch (int j)
-    {
-      BOOST_TEST(j == 9);
-    }
-    catch (...)
-    {
-      BOOST_TEST(false);
-    }
-  }
   {
     typedef A T;
     T i;
@@ -159,25 +137,6 @@ int main()
       BOOST_TEST(false);
     }
   }
-  {
-    typedef A T;
-    T i;
-    boost::promise<T> p;
-    boost::future<T> f = p.get_future();
-    try
-    {
-      p.set_value_deferred((T()));
-      BOOST_TEST(false);
-    }
-    catch (int j)
-    {
-      BOOST_TEST(j == 9);
-    }
-    catch (...)
-    {
-      BOOST_TEST(false);
-    }
-  }
   {
     typedef A T;
     T i(3);

test/sync/futures/promise/set_value_const_pass.cpp

@@ -24,10 +24,6 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/static_assert.hpp>
 
-#ifdef BOOST_MSVC
-# pragma warning(disable: 4702) // unreachable code
-#endif
-
 struct A
 {
   A()
@@ -65,30 +61,6 @@ int main()
       BOOST_TEST(false);
     }
   }
-  {
-    typedef int T;
-    T i = 3;
-    boost::promise<T> p;
-    boost::future<T> f = p.get_future();
-    p.set_value_deferred(i);
-    p.notify_deferred();
-    ++i;
-    BOOST_TEST(f.get() == 3);
-    --i;
-    try
-    {
-      p.set_value(i);
-      BOOST_TEST(false);
-    }
-    catch (const boost::future_error& e)
-    {
-      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::promise_already_satisfied));
-    }
-    catch (...)
-    {
-      BOOST_TEST(false);
-    }
-  }
   {
     typedef A T;
     T i;

test/sync/futures/promise/set_value_void_pass.cpp

@@ -58,27 +58,7 @@ int main()
       BOOST_TEST(false);
     }
   }
-  {
-    typedef void T;
-    boost::promise<T> p;
-    boost::future<T> f = p.get_future();
-    p.set_value_deferred();
-    p.notify_deferred();
-    f.get();
-    try
-    {
-      p.set_value();
-      BOOST_TEST(false);
-    }
-    catch (const boost::future_error& e)
-    {
-      BOOST_TEST(e.code() == boost::system::make_error_code(boost::future_errc::promise_already_satisfied));
-    }
-    catch (...)
-    {
-      BOOST_TEST(false);
-    }
-  }
+
   return boost::report_errors();
 }
 

test/sync/futures/shared_future/then_executor_pass.cpp

@@ -23,10 +23,6 @@
 
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 int p1()
 {
   BOOST_THREAD_LOG << "p1 < " << BOOST_THREAD_END_LOG;

test/sync/futures/shared_future/then_pass.cpp

@@ -20,10 +20,6 @@
 
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION
 
-#ifdef BOOST_MSVC
-#pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 int p1()
 {
   BOOST_THREAD_LOG << "p1 < " << BOOST_THREAD_END_LOG;