Merge branch 'develop'

Add self contained header tests and fix discovered bugs

.travis.yml

@@ -30,7 +30,7 @@ matrix:
   include:
     - os: linux
       compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++11
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++11 SELF_CONTAINED_HEADER_TESTS=1
 
 #    - os: linux
 #      compiler: g++-4.7
@@ -331,7 +331,7 @@ matrix:
 
     - os: osx
       compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++98
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++98 SELF_CONTAINED_HEADER_TESTS=1
 
 #    - os: osx
 #      compiler: clang++
@@ -346,23 +346,28 @@ matrix:
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++1z
 
 install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - GIT_FETCH_JOBS=8
+  - BOOST_BRANCH=develop
+  - if [ "$TRAVIS_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
   - 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
+  - git submodule init tools/build
+  - git submodule init libs/config
+  - git submodule init tools/boostdep
+  - git submodule update --jobs $GIT_FETCH_JOBS
   - mkdir -p libs/thread
   - cp -r $TRAVIS_BUILD_DIR/* libs/thread
-  - python tools/boostdep/depinst/depinst.py thread
+  - python tools/boostdep/depinst/depinst.py --git_args "--jobs $GIT_FETCH_JOBS" thread
   - ./bootstrap.sh
   - ./b2 headers
 
 script:
   - |-
     echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
-  - ./b2 -j3 libs/thread/test toolset=$TOOLSET
+  - BUILD_JOBS=`(nproc || sysctl -n hw.ncpu) 2> /dev/null`
+  - if [ -z "$SELF_CONTAINED_HEADER_TESTS" ]; then export BOOST_THREAD_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS=1; fi
+  - ./b2 -j $BUILD_JOBS -l60 libs/thread/test toolset=$TOOLSET
 
 notifications:
   email:

appveyor.yml

@@ -1,4 +1,5 @@
-# Copyright 2016, 2017 Peter Dimov
+# Copyright 2016-2018 Peter Dimov
+# Copyright 2018 Vicente Botet
 # 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)
 
@@ -12,68 +13,61 @@ branches:
     - develop
     - /feature\/.*/
 
-platform:
-  - x64
-
 environment:
   matrix:
-    - ARGS: --toolset=msvc-9.0  address-model=32 cxxflags="/wd4244 /wd4459"
-    - ARGS: --toolset=msvc-10.0 address-model=32 cxxflags="/wd4244 /wd4459"
-    - ARGS: --toolset=msvc-11.0 address-model=32 cxxflags="/wd4244 /wd4459"
-    - ARGS: --toolset=msvc-12.0 address-model=32 cxxflags="/wd4244 /wd4459"
-    - ARGS: --toolset=msvc-14.0 address-model=32 cxxflags="/wd4244 /wd4459"
-    - ARGS: --toolset=msvc-12.0 address-model=64 cxxflags="/wd4244 /wd4459"
-    - ARGS: --toolset=msvc-14.0 address-model=64 cxxflags="/wd4244 /wd4459"
-    - ARGS: --toolset=msvc-14.0 address-model=64 cxxflags="-std:c++latest /wd4244 /wd4459"
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+#      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0
+      TOOLSET: msvc-12.0
+      SELF_CONTAINED_HEADER_TESTS: 1
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.0
+      ADDRMD: 32
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARGS: --toolset=msvc-14.1 address-model=64 cxxflags="/wd4244 /wd4459"
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARGS: --toolset=msvc-14.1 address-model=32 cxxflags="/wd4244 /wd4459"
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARGS: --toolset=msvc-14.1 address-model=64 cxxflags="-std:c++latest /wd4244 /wd4459"
-    - 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
+      TOOLSET: msvc-14.1
+      CXXSTD: 17
+      ADDRMD: 64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\cygwin\bin;
+      TOOLSET: gcc
+      CXXSTD: 14
+      SELF_CONTAINED_HEADER_TESTS: 1
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\cygwin64\bin;
+      TOOLSET: gcc
+      CXXSTD: 14
+      SELF_CONTAINED_HEADER_TESTS: 1
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw\bin;
+      TOOLSET: gcc
+      CXXSTD: 14
+      SELF_CONTAINED_HEADER_TESTS: 1
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      TOOLSET: gcc
+      CXXSTD: 14
+      SELF_CONTAINED_HEADER_TESTS: 1
 
 install:
+  - set GIT_FETCH_JOBS=8
   - 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
+  - git submodule init tools/build
+  - git submodule init libs/config
+  - git submodule init tools/boostdep
+  - git submodule update --jobs %GIT_FETCH_JOBS%
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\thread
+  - python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" thread
   - cmd /c bootstrap
-  - b2 headers
+  - b2 -d0 headers
 
 build: off
 
 test_script:
-  - cd libs\config\test
-  - ..\..\..\b2 config_info_travis_install %ARGS%
-  - config_info_travis
-  - cd ..\..\thread\test
-  - ..\..\..\b2 --abbreviate-paths -j3 %ARGS%
+  - PATH=%ADDPATH%%PATH%
+  - if "%SELF_CONTAINED_HEADER_TESTS%" == "" set BOOST_THREAD_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS=1
+  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+  - b2 -j %NUMBER_OF_PROCESSORS% libs/thread/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release

build/Jamfile.v2

@@ -38,6 +38,8 @@ import path ;
 import configure ; 
 import threadapi-feature ;
 
+exe has_atomic_flag_lockfree : ../build/has_atomic_flag_lockfree_test.cpp ;
+
 project boost/thread
     : source-location ../src
     : requirements <threading>multi
@@ -52,7 +54,6 @@ project boost/thread
       #<define>BOOST_SYSTEM_NO_DEPRECATED
       #<define>BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
 
-      <library>/boost/system//boost_system
        #-pedantic -ansi -std=gnu++0x -Wextra -fpermissive
         <warnings>all
         <toolset>gcc:<cxxflags>-Wextra
@@ -138,11 +139,8 @@ project boost/thread
       #<define>BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
       #<define>BOOST_SYSTEM_NO_DEPRECATED
       #<define>BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
-      <library>/boost/system//boost_system
     ;
 
-exe has_atomic_flag_lockfree : ../build/has_atomic_flag_lockfree_test.cpp ; 
-
 rule tag ( name : type ? : property-set )
 {
     local result = $(name) ;
@@ -238,6 +236,10 @@ rule usage-requirements ( properties * )
             # in that case?
         }
     }
+    if <threadapi>win32 in $(properties)
+    {
+        result += <define>BOOST_THREAD_WIN32 ;
+    }
 
     #if ! <toolset>vacpp in $(properties) || <toolset-vacpp:version>11.1 in $(properties) || <toolset-vacpp:version>12.1.0.1 in $(properties)  || <toolset-vacpp:version>12.1 in $(properties)
     #{
@@ -272,6 +274,10 @@ rule requirements ( properties * )
            result += <library>/boost/atomic//boost_atomic ; 
         } 
     } else {
+        if <threadapi>win32 in $(properties)
+        {
+            result += <define>BOOST_THREAD_WIN32 ;
+        }
         result += <define>BOOST_THREAD_USES_CHRONO ;
         result += <library>/boost/chrono//boost_chrono ;
     }
@@ -284,6 +290,7 @@ alias thread_sources
       win32/thread.cpp
       win32/tss_dll.cpp
       win32/tss_pe.cpp
+      win32/thread_primitives.cpp
       future.cpp
     : ## requirements ##
       <threadapi>win32

circle.yml

@@ -0,0 +1,177 @@
+# Copyright 2018 Tom Hughes
+# 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)
+
+build_steps: &build_steps
+  steps:
+    - run:
+        name: Setup
+        command: |
+          PLATFORM=`uname`
+          if [ "${PLATFORM}" == "Linux" ]; then
+            sudo apt-get install -y software-properties-common apt-transport-https
+
+            # https://github.com/ilikenwf/apt-fast
+            sudo add-apt-repository -y ppa:apt-fast/stable
+            sudo apt-get update
+            sudo apt-get -y install apt-fast
+
+            sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+            wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
+            echo "deb https://apt.llvm.org/trusty/ llvm-toolchain-trusty-4.0 main" | sudo tee -a /etc/apt/sources.list
+            echo "deb https://apt.llvm.org/trusty/ llvm-toolchain-trusty-5.0 main" | sudo tee -a /etc/apt/sources.list
+            echo "deb https://apt.llvm.org/trusty/ llvm-toolchain-trusty-6.0 main" | sudo tee -a /etc/apt/sources.list
+            sudo apt-fast update
+            sudo apt-fast install -y $COMPILER
+          fi
+    - checkout
+    - run:
+        name: Install
+        command: |
+          BOOST_BRANCH=develop && [ "$CIRCLE_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 $HOME/project/* libs/thread
+          python tools/boostdep/depinst/depinst.py thread
+          ./bootstrap.sh
+          ./b2 headers
+    - run:
+        name: Build
+        command: |
+          echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD <cxxflags>$CXXFLAGS <cxxflags>$DEFINES ;" > ~/user-config.jam
+          cd ../boost-root
+          ./b2 -d2 -j8 -l60 libs/thread/test toolset=$TOOLSET
+
+mac_build: &mac_build
+  macos:
+    xcode: "9.2.0"
+  <<: *build_steps
+
+linux_build: &linux_build
+  docker:
+    - image: circleci/buildpack-deps:trusty
+  <<: *build_steps
+
+
+version: 2
+jobs:
+  linux-g++-c++11:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++"
+      - CXXSTD: "c++11"
+
+  linux-g++-7-c++98:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++98"
+
+  linux-g++-7-c++11:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++11"
+
+  linux-g++-7-c++14:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++14"
+
+  linux-g++-7-c++1z:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++1z"
+
+  linux-clang++-4.0-c++98:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++98"
+
+  linux-clang++-4.0-c++11:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++11"
+
+  linux-clang++-4.0-c++14:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++14"
+
+  linux-clang++-4.0-c++1z:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++1z"
+
+  mac-clang++-c++98:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++98"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  mac-clang++-c++11:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++11"
+      - CXXFLAGS: "-Wno-unusable-partial-specialization"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  mac-clang++-c++14:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++14"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  mac-clang++-c++1z:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++1z"
+      - CXXFLAGS: "-Wno-unusable-partial-specialization"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+workflows:
+  version: 2
+  continous:
+    jobs:
+      - linux-g++-c++11
+      - linux-g++-7-c++98
+      - linux-g++-7-c++11
+      - linux-g++-7-c++14
+      - linux-g++-7-c++1z
+      - linux-clang++-4.0-c++98
+      - linux-clang++-4.0-c++11
+      - linux-clang++-4.0-c++14
+      - linux-clang++-4.0-c++1z
+      - mac-clang++-c++98
+      - mac-clang++-c++11
+      - mac-clang++-c++14
+      - mac-clang++-c++1z
+

doc/async_executors.qbk

@@ -1526,7 +1526,7 @@ A thread pool with up to a fixed number of threads.
 
 [variablelist
 
-[[Effects:] [Destroys the thread pool.]]
+[[Effects:] [Interrupts and joins all the threads and then destroys the threads.]]
 
 [[Synchronization:] [The completion of all the closures happen before the completion of the executor destructor.]]
 

doc/changes.qbk

@@ -1,6 +1,6 @@
 [/
   (C) Copyright 2007-11 Anthony Williams.
-  (C) Copyright 2011-17 Vicente J. Botet Escriba.
+  (C) Copyright 2011-18 Vicente J. Botet Escriba.
   Distributed under the Boost Software License, Version 1.0.
   (See accompanying file LICENSE_1_0.txt or copy at
   http://www.boost.org/LICENSE_1_0.txt).
@@ -8,6 +8,57 @@
 
 [section:changes History]
 
+[heading Version 4.9.0 - boost 1.70]
+
+[*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:]
+
+* [@https://github.com/boostorg/thread/pull/268] Add self contained header tests and fix discovered bugs
+
+* Improvements support for cygwin platform using the pthread interface.
+	* [@https://github.com/boostorg/thread/pull/263] Fix compilation of timed functions on Cygwin
+	$ [@https://github.com/boostorg/thread/pull/262] Fix MinGW warnings about violation of the strict aliasing rules
+
+* [@https://github.com/boostorg/thread/pull/260] Fix "interruption_point" defined twice.
+
+* [@https://github.com/boostorg/thread/pull/249] Simplify TSS cleanup routines. Fixes #236
+
+[*New Experimental Features:]
+
+* Since BOOST_THREAD_VERSION 5, BOOST_THREAD_USES_EXECUTOR is defined by default. 
+* [@https://github.com/boostorg/thread/pull/266] Remove linking with Boost.System
+
+[heading Version 4.8.1 - boost 1.67]
+
+[*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:]
+
+
+* [@https://github.com/boostorg/thread/issues/162 #162] fix as much time-related issues as possible and improve the QOI
+* [@https://github.com/boostorg/thread/issues/193 #193] future_then unit test contains two different implementations of do_continuation function
+* [@https://github.com/boostorg/thread/issues/209 #209] Legal problem with `win32/thread_primitives.hpp`
+
+
 [heading Version 4.8.0 - boost 1.66]
 
 [*Know Bugs:]

doc/configuration.qbk

@@ -10,37 +10,37 @@
 
 
 [table Default Values for Configurable Features
-    [[Feature]                  [Anti-Feature]               [V2]  [V3]  [V4]  ]
-    [[USES_CHRONO]              [DONT_USE_CHRONO]            [YES/NO] [YES/NO] [YES/NO] ]
-    [[PROVIDES_INTERRUPTIONS]   [DONT_PROVIDE_INTERRUPTIONS] [YES] [YES] [YES]  ]
-    [[THROW_IF_PRECONDITION_NOT_SATISFIED]   [-] [NO] [NO] [NO]  ]
+    [[Feature]                  [Anti-Feature]               [V2]  [V3]  [V4] [V5] ]
+    [[USES_CHRONO]              [DONT_USE_CHRONO]            [YES/NO] [YES/NO] [YES/NO] [YES/NO] ]
+    [[PROVIDES_INTERRUPTIONS]   [DONT_PROVIDE_INTERRUPTIONS] [YES] [YES] [YES] [YES] ]
+    [[THROW_IF_PRECONDITION_NOT_SATISFIED]   [-] [NO] [NO] [NO] [NO] ]
 
 
 
-    [[PROVIDES_PROMISE_LAZY]    [DONT_PROVIDE_PROMISE_LAZY]  [YES] [NO] [NO]  ]
+    [[PROVIDES_PROMISE_LAZY]    [DONT_PROVIDE_PROMISE_LAZY]  [YES] [NO] [NO] [NO] ]
 
-    [[PROVIDES_BASIC_THREAD_ID] [DONT_PROVIDE_BASIC_THREAD_ID]   [NO]  [YES] [YES] ]
-    [[PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN] [DONT_PROVIDE_GENERIC_SHARED_MUTEX_ON_WIN]   [NO]  [YES] [YES] ]
+    [[PROVIDES_BASIC_THREAD_ID] [DONT_PROVIDE_BASIC_THREAD_ID]   [NO]  [YES] [YES] [YES] ]
+    [[PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN] [DONT_PROVIDE_GENERIC_SHARED_MUTEX_ON_WIN]   [NO]  [YES] [YES] [YES] ]
 
-    [[PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION]    [DONT_PROVIDE_SHARED_MUTEX_UPWARDS_CONVERSION]  [NO] [YES] [YES]  ]
-    [[PROVIDES_EXECUTORS]    [-]  [NO] [NO] [NO]  ]
-    [[PROVIDES_EXPLICIT_LOCK_CONVERSION]    [DONT_PROVIDE_EXPLICIT_LOCK_CONVERSION]  [NO] [YES] [YES]  ]
-    [[PROVIDES_FUTURE]    [DONT_PROVIDE_FUTURE]  [NO] [YES] [YES]  ]
-    [[PROVIDES_FUTURE_CTOR_ALLOCATORS]    [DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS]  [NO] [YES] [YES]  ]
-    [[PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE]    [DONT_PROVIDE_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE]  [NO] [YES] [YES]  ]
-    [[PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE]    [DONT_PROVIDE_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE]  [NO] [YES] [YES]  ]
-    [[PROVIDES_ONCE_CXX11]    [DONT_PROVIDE_ONCE_CXX11]  [NO] [YES] [YES]  ]
-    [[USES_MOVE]                [DONT_USE_MOVE]              [NO] [YES] [YES] ]
+    [[PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION]    [DONT_PROVIDE_SHARED_MUTEX_UPWARDS_CONVERSION]  [NO] [YES] [YES] [YES]  ]
+    [[PROVIDES_EXECUTORS]    [-]  [NO] [NO] [NO] [YES] ]
+    [[PROVIDES_EXPLICIT_LOCK_CONVERSION]    [DONT_PROVIDE_EXPLICIT_LOCK_CONVERSION]  [NO] [YES] [YES] [YES]  ]
+    [[PROVIDES_FUTURE]    [DONT_PROVIDE_FUTURE]  [NO] [YES] [YES] [YES]  ]
+    [[PROVIDES_FUTURE_CTOR_ALLOCATORS]    [DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS]  [NO] [YES] [YES]  [YES]  ]
+    [[PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE]    [DONT_PROVIDE_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE]  [NO] [YES] [YES] [YES]  ]
+    [[PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE]    [DONT_PROVIDE_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE]  [NO] [YES] [YES] [YES]  ]
+    [[PROVIDES_ONCE_CXX11]    [DONT_PROVIDE_ONCE_CXX11]  [NO] [YES] [YES] [YES]  ]
+    [[USES_MOVE]                [DONT_USE_MOVE]              [NO] [YES] [YES] [YES] ]
 
-    [[USES_DATETIME]            [DONT_USE_DATETIME]          [YES/NO] [YES/NO] [YES/NO]  ]
-    [[PROVIDES_THREAD_EQ]       [DONT_PROVIDE_THREAD_EQ]     [YES] [YES] [NO]  ]
-    [[PROVIDES_CONDITION]       [DONT_PROVIDE_CONDITION]     [YES] [YES] [NO]  ]
-    [[PROVIDES_NESTED_LOCKS]    [DONT_PROVIDE_NESTED_LOCKS]  [YES] [YES] [NO]  ]
-    [[PROVIDES_SIGNATURE_PACKAGED_TASK]    [DONT_PROVIDE_SIGNATURE_PACKAGED_TASK]  [NO] [NO] [YES]  ]
-    [[PROVIDES_FUTURE_INVALID_AFTER_GET]    [DONT_PROVIDE_FUTURE_INVALID_AFTER_GET]  [NO] [NO] [YES]  ]
-   [/ [[PROVIDES_FUTURE_CONTINUATION]    [DONT_PROVIDE_FUTURE_CONTINUATION]  [NO] [NO] [YES]  ] ]
+    [[USES_DATETIME]            [DONT_USE_DATETIME]          [YES/NO] [YES/NO] [YES/NO]  [YES/NO] ]
+    [[PROVIDES_THREAD_EQ]       [DONT_PROVIDE_THREAD_EQ]     [YES] [YES] [NO] [NO]  ]
+    [[PROVIDES_CONDITION]       [DONT_PROVIDE_CONDITION]     [YES] [YES] [NO] [NO]  ]
+    [[PROVIDES_NESTED_LOCKS]    [DONT_PROVIDE_NESTED_LOCKS]  [YES] [YES] [NO]  [NO]  ]
+    [[PROVIDES_SIGNATURE_PACKAGED_TASK]    [DONT_PROVIDE_SIGNATURE_PACKAGED_TASK]  [NO] [NO] [YES] [YES]  ]
+    [[PROVIDES_FUTURE_INVALID_AFTER_GET]    [DONT_PROVIDE_FUTURE_INVALID_AFTER_GET]  [NO] [NO] [YES] [YES]  ]
+   [/ [[PROVIDES_FUTURE_CONTINUATION]    [DONT_PROVIDE_FUTURE_CONTINUATION]  [NO] [NO] [YES] [YES]  ] ]
 
-    [[PROVIDES_VARIADIC_THREAD]    [DONT_PROVIDE_VARIADIC_THREAD]  [NO] [NO] [C++11]  ]
+    [[PROVIDES_VARIADIC_THREAD]    [DONT_PROVIDE_VARIADIC_THREAD]  [NO] [NO] [C++11] [C++11] ]
 
 ]
 

doc/once.qbk

@@ -33,7 +33,7 @@
     #ifdef BOOST_THREAD_PROVIDES_ONCE_CXX11
     struct once_flag
     {
-      constexprr once_flag() noexcept;
+      constexpr once_flag() noexcept;
       once_flag(const once_flag&) = delete;
       once_flag& operator=(const once_flag&) = delete;
     };

example/this_executor.cpp

@@ -8,8 +8,7 @@
 #define BOOST_RESULT_OF_USE_DECLTYPE
 #endif
 
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
+#define BOOST_THREAD_VERSION 5
 #define BOOST_THREAD_USES_LOG_THREAD_ID
 
 #include <boost/thread/caller_context.hpp>

example/thread_pool.cpp

@@ -5,7 +5,7 @@
 
 #include <boost/config.hpp>
 
-#define BOOST_THREAD_VERSION 4
+#define BOOST_THREAD_VERSION 5
 //#define BOOST_THREAD_USES_LOG
 #define BOOST_THREAD_USES_LOG_THREAD_ID
 #define BOOST_THREAD_QUEUE_DEPRECATE_OLD
@@ -15,6 +15,7 @@
 
 #include <boost/thread/detail/log.hpp>
 #include <boost/thread/executors/basic_thread_pool.hpp>
+#include <boost/thread/thread_only.hpp>
 #include <boost/assert.hpp>
 #include <string>
 

example/user_scheduler.cpp

@@ -5,7 +5,7 @@
 
 #include <boost/config.hpp>
 
-#define BOOST_THREAD_VERSION 4
+#define BOOST_THREAD_VERSION 5
 //#define BOOST_THREAD_USES_LOG
 #define BOOST_THREAD_USES_LOG_THREAD_ID
 #if ! defined  BOOST_NO_CXX11_DECLTYPE

include/boost/thread/concurrent_queues/queue_op_status.hpp

@@ -11,6 +11,8 @@
 //
 //////////////////////////////////////////////////////////////////////////////
 
+#include <exception>
+#include <boost/core/scoped_enum.hpp>
 #include <boost/thread/detail/config.hpp>
 #include <boost/thread/detail/move.hpp>
 
@@ -25,7 +27,7 @@ namespace concurrent
   { success = 0, empty, full, closed, busy, timeout, not_ready }
   BOOST_SCOPED_ENUM_DECLARE_END(queue_op_status)
 
-  struct sync_queue_is_closed : std::exception
+  struct BOOST_SYMBOL_VISIBLE sync_queue_is_closed : std::exception
   {
   };
 

include/boost/thread/csbl/queue.hpp

@@ -5,7 +5,7 @@
 //
 // 2013/10 Vicente J. Botet Escriba
 //   Creation.
-
+#if 0
 #ifndef BOOST_CSBL_QUEUE_HPP
 #define BOOST_CSBL_QUEUE_HPP
 
@@ -43,3 +43,4 @@ namespace boost
   }
 }
 #endif // header
+#endif

include/boost/thread/detail/config.hpp

@@ -11,6 +11,7 @@
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/thread/detail/platform.hpp>
+#include <boost/thread/detail/thread_safety.hpp>
 
 //#define BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
 // ATTRIBUTE_MAY_ALIAS
@@ -44,7 +45,7 @@
 # elif defined( BOOST_THREAD_CHRONO_MAC_API ) && defined( BOOST_THREAD_CHRONO_POSIX_API )
 #   error both BOOST_THREAD_CHRONO_MAC_API and BOOST_THREAD_CHRONO_POSIX_API are defined
 # elif !defined( BOOST_THREAD_CHRONO_WINDOWS_API ) && !defined( BOOST_THREAD_CHRONO_MAC_API ) && !defined( BOOST_THREAD_CHRONO_POSIX_API )
-#   if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32))
+#   if defined(BOOST_THREAD_PLATFORM_WIN32)
 #     define BOOST_THREAD_CHRONO_WINDOWS_API
 #   elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
 #     define BOOST_THREAD_CHRONO_MAC_API
@@ -123,7 +124,7 @@
 
 /// RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
 //#if defined BOOST_NO_CXX11_RVALUE_REFERENCES || defined BOOST_MSVC
-#define BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#define BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 //#endif
 
 // Default version
@@ -337,10 +338,18 @@
 
 #if BOOST_THREAD_VERSION>=5
 //#define BOOST_THREAD_FUTURE_BLOCKING
+
+#if ! defined BOOST_THREAD_PROVIDES_EXECUTORS \
+ && ! defined BOOST_THREAD_DONT_PROVIDE_EXECUTORS
+#define BOOST_THREAD_PROVIDES_EXECUTORS
+#endif
+
 #else
 //#define BOOST_THREAD_FUTURE_BLOCKING
 #define BOOST_THREAD_ASYNC_FUTURE_WAITS
 #endif
+
+
 // INTERRUPTIONS
 #if ! defined BOOST_THREAD_PROVIDES_INTERRUPTIONS \
  && ! defined BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
@@ -417,6 +426,11 @@
   #define BOOST_THREAD_INTERNAL_CLOCK_IS_MONO
 #elif defined(BOOST_THREAD_CHRONO_MAC_API)
   #define BOOST_THREAD_HAS_MONO_CLOCK
+#elif defined(__ANDROID__)
+  #define BOOST_THREAD_HAS_MONO_CLOCK
+  #if defined(__ANDROID_API__) && __ANDROID_API__ >= 21
+    #define BOOST_THREAD_INTERNAL_CLOCK_IS_MONO
+  #endif
 #else
   #include <time.h> // check for CLOCK_MONOTONIC
   #if defined(CLOCK_MONOTONIC)

include/boost/thread/detail/move.hpp

@@ -350,12 +350,19 @@ namespace boost
 #endif
 
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-      template <class T>
-      typename decay<T>::type
-      decay_copy(T&& t)
-      {
-          return boost::forward<T>(t);
-      }
+  template <class T>
+  typename decay<T>::type
+  decay_copy(T&& t)
+  {
+      return boost::forward<T>(t);
+  }
+  typedef void (*void_fct_ptr)();
+
+//  inline void_fct_ptr
+//  decay_copy(void (&t)())
+//  {
+//      return &t;
+//  }
 #else
   template <class T>
   typename decay<T>::type

include/boost/thread/detail/nullary_function.hpp

@@ -3,7 +3,7 @@
 //  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)
 //
-// 2013/09 Vicente J. Botet Escriba
+// 2013,2018 Vicente J. Botet Escriba
 //    Adapt to boost from CCIA C++11 implementation
 //    Make use of Boost.Move
 
@@ -15,6 +15,7 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/csbl/memory/shared_ptr.hpp>
 #include <boost/type_traits/decay.hpp>
+#include <boost/type_traits/is_same.hpp>
 
 namespace boost
 {
@@ -72,12 +73,16 @@ namespace boost
 
 #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
       template<typename F>
-      explicit nullary_function(F& f):
+      explicit nullary_function(F& f
+                                , typename disable_if<is_same<typename decay<F>::type, nullary_function>, int* >::type=0
+                                ):
       impl(new impl_type<F>(f))
       {}
 #endif
       template<typename F>
-      nullary_function(BOOST_THREAD_RV_REF(F) f):
+      nullary_function(BOOST_THREAD_RV_REF(F) f
+                       , typename disable_if<is_same<typename decay<F>::type, nullary_function>, int* >::type=0
+                       ):
       impl(new impl_type<typename decay<F>::type>(thread_detail::decay_copy(boost::forward<F>(f))))
       {}
 

include/boost/thread/detail/platform.hpp

@@ -31,7 +31,9 @@
 #elif defined(__CYGWIN__)
 #  define BOOST_THREAD_CYGWIN
 #elif (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && !defined(BOOST_DISABLE_WIN32)
+#if ! defined BOOST_THREAD_WIN32
 #  define BOOST_THREAD_WIN32
+#endif
 #elif defined(__BEOS__)
 #  define BOOST_THREAD_BEOS
 #elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)

include/boost/thread/detail/platform_time.hpp

@@ -429,7 +429,7 @@ inline FP init_steady_clock(kern_return_t & err)
 #else
       // Use GetTickCount64() because it's more reliable on older
       // systems like Windows XP and Windows Server 2003.
-      win32::ticks_type msec = win32::GetTickCount64_()();
+      win32::ticks_type msec = win32::gettickcount64();
       return mono_platform_timepoint(msec * 1000000);
 #endif
 #elif defined(BOOST_THREAD_CHRONO_MAC_API)

include/boost/thread/detail/thread.hpp

@@ -18,6 +18,9 @@
 #if defined BOOST_THREAD_USES_DATETIME
 #include <boost/thread/xtime.hpp>
 #endif
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+#include <boost/thread/interruption.hpp>
+#endif
 #include <boost/thread/detail/thread_heap_alloc.hpp>
 #include <boost/thread/detail/make_tuple_indices.hpp>
 #include <boost/thread/detail/invoke.hpp>
@@ -513,7 +516,7 @@ namespace boost
         }
 
         template<typename TimeDuration>
-        inline bool timed_join(TimeDuration const& rel_time)
+        bool timed_join(TimeDuration const& rel_time)
         {
           detail::platform_duration d(rel_time);
 #if defined(BOOST_THREAD_HAS_MONO_CLOCK) && !defined(BOOST_THREAD_INTERNAL_CLOCK_IS_MONO)
@@ -587,14 +590,8 @@ namespace boost
         thread::id BOOST_THREAD_DECL get_id() BOOST_NOEXCEPT;
 #endif
 
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-        void BOOST_THREAD_DECL interruption_point();
-        bool BOOST_THREAD_DECL interruption_enabled() BOOST_NOEXCEPT;
-        bool BOOST_THREAD_DECL interruption_requested() BOOST_NOEXCEPT;
-#endif
-
 #if defined BOOST_THREAD_USES_DATETIME
-        inline BOOST_SYMBOL_VISIBLE void sleep(xtime const& abs_time)
+        inline BOOST_SYMBOL_VISIBLE void sleep(::boost::xtime const& abs_time)
         {
             sleep(system_time(abs_time));
         }
@@ -811,6 +808,7 @@ namespace boost
         };
 
         void BOOST_THREAD_DECL add_thread_exit_function(thread_exit_function_base*);
+//#ifndef BOOST_NO_EXCEPTIONS
         struct shared_state_base;
 #if defined(BOOST_THREAD_PLATFORM_WIN32)
         inline void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
@@ -824,6 +822,7 @@ namespace boost
 #else
         void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as);
 #endif
+//#endif
     }
 
     namespace this_thread

include/boost/thread/detail/thread_safety.hpp

@@ -0,0 +1,160 @@
+#ifndef BOOST_THREAD_DETAIL_THREAD_SAFETY_HPP
+#define BOOST_THREAD_DETAIL_THREAD_SAFETY_HPP
+
+#if defined(__GNUC__) && !defined(__GXX_EXPERIMENTAL_CXX0X__)
+//
+// This is horrible, but it seems to be the only we can shut up the
+// "anonymous variadic macros were introduced in C99 [-Wvariadic-macros]"
+// warning that get spewed out otherwise in non-C++11 mode.
+//
+#pragma GCC system_header
+#endif
+
+// See https://clang.llvm.org/docs/ThreadSafetyAnalysis.html
+
+// Un-comment to enable Thread Safety Analysis
+//#define BOOST_THREAD_ENABLE_THREAD_SAFETY_ANALYSIS
+
+// Enable thread safety attributes only with clang.
+// The attributes can be safely erased when compiling with other compilers.
+#if defined (BOOST_THREAD_ENABLE_THREAD_SAFETY_ANALYSIS) && defined(__clang__) && (!defined(SWIG))
+#define BOOST_THREAD_ANNOTATION_ATTRIBUTE__(x)   __attribute__((x))
+#else
+#define BOOST_THREAD_ANNOTATION_ATTRIBUTE__(x)   // no-op
+#endif
+
+#define BOOST_THREAD_CAPABILITY(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(capability(x))
+
+#define BOOST_THREAD_SCOPED_CAPABILITY \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+
+#define BOOST_THREAD_GUARDED_BY(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
+
+#define BOOST_THREAD_PT_GUARDED_BY(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
+
+#define BOOST_THREAD_ACQUIRED_BEFORE(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
+
+#define BOOST_THREAD_ACQUIRED_AFTER(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
+
+#define BOOST_THREAD_REQUIRES(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_REQUIRES_SHARED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_ACQUIRE(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_ACQUIRE_SHARED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_RELEASE(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(release_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_RELEASE_SHARED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_TRY_ACQUIRE(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_TRY_ACQUIRE_SHARED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(__VA_ARGS__))
+
+#define BOOST_THREAD_EXCLUDES(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+
+#define BOOST_THREAD_ASSERT_CAPABILITY(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(x))
+
+#define BOOST_THREAD_ASSERT_SHARED_CAPABILITY(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(x))
+
+#define BOOST_THREAD_RETURN_CAPABILITY(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+
+#define BOOST_THREAD_NO_THREAD_SAFETY_ANALYSIS \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
+
+#if defined(__clang__) && (!defined(SWIG)) && defined(__FreeBSD__)
+#if __has_attribute(no_thread_safety_analysis)
+#define BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS __attribute__((no_thread_safety_analysis))
+#else
+#define BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+#endif
+#else
+#define BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+#endif
+
+#ifdef USE_LOCK_STYLE_THREAD_SAFETY_ATTRIBUTES
+// The original version of thread safety analysis the following attribute
+// definitions.  These use a lock-based terminology.  They are still in use
+// by existing thread safety code, and will continue to be supported.
+
+// Deprecated.
+#define BOOST_THREAD_PT_GUARDED_VAR \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_var)
+
+// Deprecated.
+#define BOOST_THREAD_GUARDED_VAR \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(guarded_var)
+
+// Replaced by REQUIRES
+#define BOOST_THREAD_EXCLUSIVE_LOCKS_REQUIRED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
+
+// Replaced by REQUIRES_SHARED
+#define BOOST_THREAD_SHARED_LOCKS_REQUIRED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
+
+// Replaced by CAPABILITY
+#define BOOST_THREAD_LOCKABLE \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(lockable)
+
+// Replaced by SCOPED_CAPABILITY
+#define BOOST_THREAD_SCOPED_LOCKABLE \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+
+// Replaced by ACQUIRE
+#define BOOST_THREAD_EXCLUSIVE_LOCK_FUNCTION(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
+
+// Replaced by ACQUIRE_SHARED
+#define BOOST_THREAD_SHARED_LOCK_FUNCTION(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
+
+// Replaced by RELEASE and RELEASE_SHARED
+#define BOOST_THREAD_UNLOCK_FUNCTION(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
+
+// Replaced by TRY_ACQUIRE
+#define BOOST_THREAD_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
+
+// Replaced by TRY_ACQUIRE_SHARED
+#define BOOST_THREAD_SHARED_TRYLOCK_FUNCTION(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
+
+// Replaced by ASSERT_CAPABILITY
+#define BOOST_THREAD_ASSERT_EXCLUSIVE_LOCK(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
+
+// Replaced by ASSERT_SHARED_CAPABILITY
+#define BOOST_THREAD_ASSERT_SHARED_LOCK(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
+
+// Replaced by EXCLUDE_CAPABILITY.
+#define BOOST_THREAD_LOCKS_EXCLUDED(...) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+
+// Replaced by RETURN_CAPABILITY
+#define BOOST_THREAD_LOCK_RETURNED(x) \
+  BOOST_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+
+#endif  // USE_LOCK_STYLE_THREAD_SAFETY_ATTRIBUTES
+
+#endif  // BOOST_THREAD_DETAIL_THREAD_SAFETY_HPP

include/boost/thread/detail/tss_hooks.hpp

@@ -10,7 +10,7 @@
 
 #include <boost/config/abi_prefix.hpp>
 
-#if defined(BOOST_HAS_WINTHREADS)
+#if defined(BOOST_THREAD_WIN32)
 
 namespace boost
 {
@@ -58,7 +58,7 @@ namespace boost
             //it to be linked into the Boost.Threads library.
 }
 
-#endif //defined(BOOST_HAS_WINTHREADS)
+#endif //defined(BOOST_THREAD_WIN32)
 
 #include <boost/config/abi_suffix.hpp>
 

include/boost/thread/exceptions.hpp

@@ -56,7 +56,7 @@ namespace boost
         {
         }
 
-        ~thread_exception() throw()
+        ~thread_exception() BOOST_NOEXCEPT_OR_NOTHROW
         {}
 
 
@@ -113,7 +113,7 @@ namespace boost
         {
         }
 
-        ~lock_error() throw()
+        ~lock_error() BOOST_NOEXCEPT_OR_NOTHROW
         {}
 
     };
@@ -141,7 +141,7 @@ namespace boost
           }
 
 
-        ~thread_resource_error() throw()
+        ~thread_resource_error() BOOST_NOEXCEPT_OR_NOTHROW
         {}
 
     };

include/boost/thread/executors/basic_thread_pool.hpp

@@ -11,6 +11,8 @@
 #define BOOST_THREAD_EXECUTORS_BASIC_THREAD_POOL_HPP
 
 #include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
+
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/thread.hpp>
@@ -231,13 +233,36 @@ namespace executors
       // signal to all the worker threads that there will be no more submissions.
       close();
       // joins all the threads before destroying the thread pool resources (e.g. the queue).
-      join();
+      interrupt_and_join();
     }
 
     /**
      * \b Effects: join all the threads.
      */
     void join()
+    {
+      for (unsigned i = 0; i < threads.size(); ++i)
+      {
+        //threads[i].interrupt();
+        threads[i].join();
+      }
+    }
+
+    /**
+     * \b Effects: interrupt all the threads.
+     */
+    void interrupt()
+    {
+      for (unsigned i = 0; i < threads.size(); ++i)
+      {
+        threads[i].interrupt();
+      }
+    }
+
+    /**
+     * \b Effects: interrupt and join all the threads.
+     */
+    void interrupt_and_join()
     {
       for (unsigned i = 0; i < threads.size(); ++i)
       {
@@ -324,3 +349,4 @@ using executors::basic_thread_pool;
 #include <boost/config/abi_suffix.hpp>
 
 #endif
+#endif

include/boost/thread/executors/executor.hpp

@@ -10,6 +10,7 @@
 #define BOOST_THREAD_EXECUTORS_EXECUTOR_HPP
 
 #include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
 
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
@@ -146,3 +147,4 @@ namespace boost
 #include <boost/config/abi_suffix.hpp>
 
 #endif
+#endif

include/boost/thread/executors/executor_adaptor.hpp

@@ -10,6 +10,7 @@
 #define BOOST_THREAD_EXECUTORS_EXECUTOR_ADAPTOR_HPP
 
 #include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
 
 #include <boost/thread/executors/executor.hpp>
 
@@ -134,3 +135,4 @@ using executors::executor_adaptor;
 #include <boost/config/abi_suffix.hpp>
 
 #endif
+#endif

include/boost/thread/executors/generic_executor_ref.hpp

@@ -8,6 +8,7 @@
 #define BOOST_THREAD_EXECUTORS_GENERIC_EXECUTOR_REF_HPP
 
 #include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
 
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
@@ -211,3 +212,4 @@ namespace boost
 #include <boost/config/abi_suffix.hpp>
 
 #endif
+#endif

include/boost/thread/executors/inline_executor.hpp

@@ -10,9 +10,16 @@
 #define BOOST_THREAD_INLINE_EXECUTOR_HPP
 
 #include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
+
+#include <exception> // std::terminate
+#include <boost/throw_exception.hpp>
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/executors/work.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/concurrent_queues/queue_op_status.hpp> // sync_queue_is_closed
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -169,3 +176,4 @@ using executors::inline_executor;
 #include <boost/config/abi_suffix.hpp>
 
 #endif
+#endif

include/boost/thread/executors/loop_executor.hpp

@@ -12,6 +12,9 @@
 #define BOOST_THREAD_EXECUTORS_LOOP_EXECUTOR_HPP
 
 #include <boost/thread/detail/config.hpp>
+
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
+
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/concurrent_queues/sync_queue.hpp>
@@ -205,5 +208,6 @@ using executors::loop_executor;
 }
 
 #include <boost/config/abi_suffix.hpp>
+#endif
 
 #endif

include/boost/thread/executors/scheduled_thread_pool.hpp

@@ -8,6 +8,9 @@
 #ifndef BOOST_THREAD_EXECUTORS_SCHEDULED_THREAD_POOL_HPP
 #define BOOST_THREAD_EXECUTORS_SCHEDULED_THREAD_POOL_HPP
 
+#include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
+
 #include <boost/thread/executors/detail/scheduled_executor_base.hpp>
 
 namespace boost
@@ -46,4 +49,5 @@ using executors::scheduled_thread_pool;
 
 } //end boost
 #endif
+#endif
 

include/boost/thread/executors/scheduler.hpp

@@ -8,6 +8,7 @@
 #define BOOST_THREAD_EXECUTORS_SCHEDULER_HPP
 
 #include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
 #include <boost/thread/executors/detail/scheduled_executor_base.hpp>
 
 #include <boost/chrono/time_point.hpp>
@@ -279,3 +280,4 @@ namespace boost
 #include <boost/config/abi_suffix.hpp>
 
 #endif
+#endif

include/boost/thread/executors/scheduling_adaptor.hpp

@@ -8,6 +8,8 @@
 #ifndef BOOST_THREAD_EXECUTORS_SCHEDULING_ADAPTOR_HPP
 #define BOOST_THREAD_EXECUTORS_SCHEDULING_ADAPTOR_HPP
 
+#include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
 #include <boost/thread/executors/detail/scheduled_executor_base.hpp>
 
 #if defined(BOOST_MSVC)
@@ -60,3 +62,4 @@ namespace executors
 #endif
 
 #endif
+#endif

include/boost/thread/executors/serial_executor.hpp

@@ -10,6 +10,9 @@
 #define BOOST_THREAD_SERIAL_EXECUTOR_HPP
 
 #include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
+
+#include <exception>
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/concurrent_queues/sync_queue.hpp>
@@ -223,3 +226,4 @@ using executors::serial_executor;
 #include <boost/config/abi_suffix.hpp>
 
 #endif
+#endif

include/boost/thread/executors/serial_executor_cont.hpp

@@ -10,13 +10,19 @@
 #define BOOST_THREAD_SERIAL_EXECUTOR_CONT_HPP
 
 #include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
+
+#include <exception> // std::terminate
+#include <boost/throw_exception.hpp>
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/concurrent_queues/sync_queue.hpp>
 #include <boost/thread/executors/work.hpp>
 #include <boost/thread/executors/generic_executor_ref.hpp>
+#include <boost/thread/mutex.hpp>
 #include <boost/thread/future.hpp>
 #include <boost/thread/scoped_thread.hpp>
+#include <boost/thread/lock_guard.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -32,7 +38,7 @@ namespace executors
   private:
 
     generic_executor_ref ex_;
-    future<void> fut_; // protected by mtx_
+    BOOST_THREAD_FUTURE<void> fut_; // protected by mtx_
     bool closed_; // protected by mtx_
     mutex mtx_;
 
@@ -44,7 +50,7 @@ namespace executors
       };
       continuation(BOOST_THREAD_RV_REF(work) tsk)
       : task(boost::move(tsk)) {}
-      void operator()(future<void> f)
+      void operator()(BOOST_THREAD_FUTURE<void> f)
       {
         try {
           task();
@@ -168,3 +174,4 @@ using executors::serial_executor_cont;
 #include <boost/config/abi_suffix.hpp>
 
 #endif
+#endif

include/boost/thread/executors/thread_executor.hpp

@@ -10,10 +10,15 @@
 #define BOOST_THREAD_THREAD_EXECUTOR_HPP
 
 #include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
+
+#include <boost/throw_exception.hpp>
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/executors/work.hpp>
 #include <boost/thread/executors/executor.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/lock_guard.hpp>
 #include <boost/thread/thread_only.hpp>
 #include <boost/thread/scoped_thread.hpp>
 #include <boost/thread/csbl/vector.hpp>
@@ -155,3 +160,4 @@ using executors::thread_executor;
 #include <boost/config/abi_suffix.hpp>
 
 #endif
+#endif

include/boost/thread/executors/work.hpp

@@ -8,6 +8,8 @@
 #define BOOST_THREAD_EXECUTORS_WORK_HPP
 
 #include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
+
 #include <boost/thread/detail/nullary_function.hpp>
 #include <boost/thread/csbl/functional.hpp>
 
@@ -26,5 +28,5 @@ namespace boost
   }
 } // namespace boost
 
-
+#endif
 #endif //  BOOST_THREAD_EXECUTORS_WORK_HPP

include/boost/thread/experimental/parallel/v2/task_region.hpp

@@ -10,6 +10,9 @@
 // See http://www.boost.org/libs/thread for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////
+
+#include <exception>
+#include <boost/throw_exception.hpp>
 #include <boost/thread/detail/config.hpp>
 
 #include <boost/thread/future.hpp>
@@ -18,6 +21,7 @@
 #endif
 #include <boost/thread/experimental/exception_list.hpp>
 #include <boost/thread/experimental/parallel/v2/inline_namespace.hpp>
+#include <boost/thread/csbl/vector.hpp>
 #include <boost/thread/detail/move.hpp>
 
 #include <boost/config/abi_prefix.hpp>
@@ -126,7 +130,7 @@ BOOST_THREAD_INLINE_NAMESPACE(v2)
 
       for (group_type::iterator it = group.begin(); it != group.end(); ++it)
       {
-        future<void>& f = *it;
+        BOOST_THREAD_FUTURE<void>& f = *it;
         if (f.has_exception())
         {
           try
@@ -191,7 +195,7 @@ protected:
     Executor* ex;
 #endif
     exception_list exs;
-    typedef csbl::vector<future<void> > group_type;
+    typedef csbl::vector<BOOST_THREAD_FUTURE<void> > group_type;
     group_type group;
 
   public:

include/boost/thread/externally_locked.hpp

@@ -24,6 +24,7 @@
 
 namespace boost
 {
+  class mutex;
 
   /**
    * externally_locked cloaks an object of type T, and actually provides full

include/boost/thread/future.hpp

@@ -15,7 +15,16 @@
 
 //#define BOOST_THREAD_CONTINUATION_SYNC
 
-#ifndef BOOST_NO_EXCEPTIONS
+#ifdef BOOST_NO_EXCEPTIONS
+namespace boost
+{
+namespace detail {
+struct shared_state_base {
+    void notify_deferred() {}
+};
+}
+}
+#else
 
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/detail/move.hpp>
@@ -109,6 +118,7 @@ namespace boost
     namespace executors {
         class executor;
     }
+    using executors::executor;
 #endif
     typedef shared_ptr<executor> executor_ptr_type;
 
@@ -577,11 +587,6 @@ namespace boost
               detail::shared_state_base(ex), result()
             {}
 
-
-            ~shared_state()
-            {
-            }
-
             // locating this definition on the template avoid the ODR issue. See https://github.com/boostorg/thread/issues/193
             BOOST_THREAD_DO_CONTINUATION
 
@@ -766,10 +771,6 @@ namespace boost
               detail::shared_state_base(ex), result(0)
             {}
 
-            ~shared_state()
-            {
-            }
-
             // locating this definition on the template avoid the ODR issue. See https://github.com/boostorg/thread/issues/193
             BOOST_THREAD_DO_CONTINUATION
 
@@ -3189,7 +3190,7 @@ namespace boost
             }
         };
 
-#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR)
+#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR)
 
 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK
 #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
@@ -3531,7 +3532,7 @@ namespace boost
         {}
 
         // construction and destruction
-#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR)
+#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR)
 
 #if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK
   #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
@@ -3621,7 +3622,7 @@ namespace boost
 #endif
 
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS
-#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR)
+#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR)
         template <class Allocator>
         packaged_task(boost::allocator_arg_t, Allocator a, R(*f)())
         {
@@ -3642,7 +3643,7 @@ namespace boost
           task = task_ptr(::new(a2.allocate(1)) task_shared_state_type(f), D(a2, 1) );
           future_obtained = false;
         }
-#endif // BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#endif // BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 
 #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
         template <class F, class Allocator>
@@ -3859,7 +3860,7 @@ namespace detail
     // future<R> async(launch policy, F&&, ArgTypes&&...);
     ////////////////////////////////
 
-#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 
 #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
   template <class R, class... ArgTypes>
@@ -3918,7 +3919,7 @@ namespace detail
     }
   }
 #endif
-#endif // defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR)
+#endif // defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR)
 
 #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 
@@ -4147,7 +4148,7 @@ namespace detail {
 //#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #if defined(BOOST_THREAD_PROVIDES_INVOKE) && ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && ! defined(BOOST_NO_CXX11_HDR_TUPLE)
 
-#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 
   template <class Executor, class R, class... ArgTypes>
   BOOST_THREAD_FUTURE<R>
@@ -4163,7 +4164,7 @@ namespace detail {
         )
     ));
   }
-#endif // defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#endif // defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 
   template <class Executor, class F, class ...ArgTypes>
   BOOST_THREAD_FUTURE<typename boost::result_of<typename decay<F>::type(
@@ -4182,7 +4183,7 @@ namespace detail {
   }
 
 #else // ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 
   template <class Executor, class R>
   BOOST_THREAD_FUTURE<R>
@@ -4212,7 +4213,7 @@ namespace detail {
         )
     ));
   }
-#endif // defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#endif // defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 
   template <class Executor, class F>
   BOOST_THREAD_FUTURE<typename boost::result_of<typename decay<F>::type()>::type>
@@ -4268,7 +4269,7 @@ namespace detail {
   // future<R> async(F&&, ArgTypes&&...);
   ////////////////////////////////
 
-#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#if defined BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
   #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
   template <class R, class... ArgTypes>
   BOOST_THREAD_FUTURE<R>

include/boost/thread/futures/wait_for_any.hpp

@@ -14,6 +14,7 @@
 #include <boost/thread/futures/is_future_type.hpp>
 #include <boost/thread/lock_algorithms.hpp>
 #include <boost/thread/mutex.hpp>
+#include <boost/thread/condition_variable.hpp>
 
 #include <boost/core/enable_if.hpp>
 #include <boost/next_prior.hpp>

include/boost/thread/interruption.hpp

@@ -0,0 +1,22 @@
+// (C) Copyright 2013 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)
+
+
+#ifndef BOOST_THREAD_INTERRUPTION_HPP
+#define BOOST_THREAD_INTERRUPTION_HPP
+
+#include <boost/thread/detail/config.hpp>
+
+namespace boost
+{
+    namespace this_thread
+    {
+        void BOOST_THREAD_DECL interruption_point();
+        bool BOOST_THREAD_DECL interruption_enabled() BOOST_NOEXCEPT;
+        bool BOOST_THREAD_DECL interruption_requested() BOOST_NOEXCEPT;
+    }
+}
+
+#endif // header

include/boost/thread/lock_guard.hpp

@@ -23,7 +23,7 @@ namespace boost
 {
 
   template <typename Mutex>
-  class lock_guard
+  class BOOST_THREAD_SCOPED_CAPABILITY lock_guard
   {
   private:
     Mutex& m;
@@ -32,13 +32,13 @@ namespace boost
     typedef Mutex mutex_type;
     BOOST_THREAD_NO_COPYABLE( lock_guard )
 
-    explicit lock_guard(Mutex& m_) :
+    explicit lock_guard(Mutex& m_) BOOST_THREAD_ACQUIRE(m_) :
       m(m_)
     {
       m.lock();
     }
 
-    lock_guard(Mutex& m_, adopt_lock_t) :
+    lock_guard(Mutex& m_, adopt_lock_t) BOOST_THREAD_REQUIRES(m_) :
       m(m_)
     {
 #if ! defined BOOST_THREAD_PROVIDES_NESTED_LOCKS
@@ -62,7 +62,7 @@ namespace boost
     }
 
 #endif
-    ~lock_guard()
+    ~lock_guard() BOOST_THREAD_RELEASE()
     {
       m.unlock();
     }

include/boost/thread/lockable_traits.hpp

@@ -11,7 +11,12 @@
 
 #include <boost/assert.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#ifdef BOOST_NO_CXX11_SFINAE_EXPR
 #include <boost/type_traits/is_class.hpp>
+#else
+#include <boost/type_traits/declval.hpp>
+#endif
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -33,6 +38,7 @@ namespace boost
 #ifndef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
     namespace detail
     {
+#ifdef BOOST_NO_CXX11_SFINAE_EXPR
 #define BOOST_THREAD_DEFINE_HAS_MEMBER_CALLED(member_name)                     \
         template<typename T, bool=boost::is_class<T>::value>            \
         struct has_member_called_##member_name                          \
@@ -142,6 +148,31 @@ namespace boost
         BOOST_STATIC_CONSTANT(
             bool,value=sizeof(has_member_try_lock<T>::has_member(&T::try_lock))==sizeof(true_type));
       };
+#else
+      template<typename T,typename Enabled=void>
+      struct has_member_lock : false_type {};
+
+      template<typename T>
+      struct has_member_lock<T,
+          decltype(void(boost::declval<T&>().lock()))
+      > : true_type {};
+
+      template<typename T,typename Enabled=void>
+      struct has_member_unlock : false_type {};
+
+      template<typename T>
+      struct has_member_unlock<T,
+          decltype(void(boost::declval<T&>().unlock()))
+      > : true_type {};
+
+      template<typename T,typename Enabled=bool>
+      struct has_member_try_lock : false_type {};
+
+      template<typename T>
+      struct has_member_try_lock<T,
+          decltype(bool(boost::declval<T&>().try_lock()))
+      > : true_type {};
+#endif
 
     }
 

include/boost/thread/poly_lockable.hpp

@@ -30,6 +30,9 @@ namespace boost
   };
   //]
 
+  // A proper name for basic_poly_lockable, consistent with naming scheme of other polymorphic wrappers
+  typedef basic_poly_lockable poly_basic_lockable;
+
   //[poly_lockable
   class poly_lockable : public basic_poly_lockable
   {
@@ -51,18 +54,20 @@ namespace boost
     template <typename Clock, typename Duration>
     bool try_lock_until(chrono::time_point<Clock, Duration> const & abs_time)
     {
-      return try_lock_until(time_point_cast<Clock::time_point>(abs_time));
+      return try_lock_until(chrono::time_point_cast<Clock::time_point>(abs_time));
     }
 
     virtual bool try_lock_for(chrono::nanoseconds const & relative_time)=0;
     template <typename Rep, typename Period>
     bool try_lock_for(chrono::duration<Rep, Period> const & rel_time)
     {
-      return try_lock_for(duration_cast<Clock::duration>(rel_time));
+      return try_lock_for(chrono::duration_cast<chrono::nanoseconds>(rel_time));
     }
 
   };
   //]
 
+  // A proper name for timed_poly_lockable, consistent with naming scheme of other polymorphic wrappers
+  typedef timed_poly_lockable poly_timed_lockable;
 }
 #endif

include/boost/thread/poly_shared_lockable.hpp

@@ -33,20 +33,22 @@ namespace boost
     template <typename Clock, typename Duration>
     bool try_lock_shared_until(chrono::time_point<Clock, Duration> const & abs_time)
     {
-      return try_lock_shared_until(time_point_cast<Clock::time_point>(abs_time));
+      return try_lock_shared_until(chrono::time_point_cast<Clock::time_point>(abs_time));
     }
 
     virtual bool try_lock_shared_for(chrono::nanoseconds const & relative_time)=0;
     template <typename Rep, typename Period>
     bool try_lock_shared_for(chrono::duration<Rep, Period> const & rel_time)
     {
-      return try_lock_shared_for(duration_cast<Clock::duration>(rel_time));
+      return try_lock_shared_for(chrono::duration_cast<chrono::nanoseconds>(rel_time));
     }
 
   };
-
   //]
 
+  // A proper name for shared_poly_lockable, consistent with naming scheme of other polymorphic wrappers
+  typedef shared_poly_lockable poly_shared_lockable;
+
   //[upgrade_poly_lockable
   class upgrade_poly_lockable: public shared_poly_lockable
   {
@@ -62,14 +64,14 @@ namespace boost
     template <typename Clock, typename Duration>
     bool try_lock_upgrade_until(chrono::time_point<Clock, Duration> const & abs_time)
     {
-      return try_lock_upgrade_until(time_point_cast<Clock::time_point>(abs_time));
+      return try_lock_upgrade_until(chrono::time_point_cast<Clock::time_point>(abs_time));
     }
 
     virtual bool try_lock_upgrade_for(chrono::nanoseconds const & relative_time)=0;
     template <typename Rep, typename Period>
     bool try_lock_upgrade_for(chrono::duration<Rep, Period> const & rel_time)
     {
-      return try_lock_upgrade_for(duration_cast<Clock::duration>(rel_time));
+      return try_lock_upgrade_for(chrono::duration_cast<chrono::nanoseconds>(rel_time));
     }
 
     virtual bool try_unlock_shared_and_lock() = 0;
@@ -79,14 +81,14 @@ namespace boost
     template <typename Clock, typename Duration>
     bool try_unlock_shared_and_lock_until(chrono::time_point<Clock, Duration> const & abs_time)
     {
-      return try_unlock_shared_and_lock_until(time_point_cast<Clock::time_point>(abs_time));
+      return try_unlock_shared_and_lock_until(chrono::time_point_cast<Clock::time_point>(abs_time));
     }
 
     virtual bool try_unlock_shared_and_lock_for(chrono::nanoseconds const & relative_time)=0;
     template <typename Rep, typename Period>
     bool try_unlock_shared_and_lock_for(chrono::duration<Rep, Period> const & rel_time)
     {
-      return try_unlock_shared_and_lock_for(duration_cast<Clock::duration>(rel_time));
+      return try_unlock_shared_and_lock_for(chrono::duration_cast<chrono::nanoseconds>(rel_time));
     }
 
     virtual void unlock_and_lock_shared() = 0;
@@ -97,14 +99,14 @@ namespace boost
     template <typename Clock, typename Duration>
     bool try_unlock_shared_and_lock_upgrade_until(chrono::time_point<Clock, Duration> const & abs_time)
     {
-      return try_unlock_shared_and_lock_upgrade_until(time_point_cast<Clock::time_point>(abs_time));
+      return try_unlock_shared_and_lock_upgrade_until(chrono::time_point_cast<Clock::time_point>(abs_time));
     }
 
     virtual bool try_unlock_shared_and_lock_upgrade_for(chrono::nanoseconds const & relative_time)=0;
     template <typename Rep, typename Period>
     bool try_unlock_shared_and_lock_upgrade_for(chrono::duration<Rep, Period> const & rel_time)
     {
-      return try_unlock_shared_and_lock_upgrade_for(duration_cast<Clock::duration>(rel_time));
+      return try_unlock_shared_and_lock_upgrade_for(chrono::duration_cast<chrono::nanoseconds>(rel_time));
     }
 
     virtual void unlock_and_lock_upgrade() = 0;
@@ -116,20 +118,22 @@ namespace boost
     template <typename Clock, typename Duration>
     bool try_unlock_upgrade_and_lock_until(chrono::time_point<Clock, Duration> const & abs_time)
     {
-      return try_unlock_upgrade_and_lock_until(time_point_cast<Clock::time_point>(abs_time));
+      return try_unlock_upgrade_and_lock_until(chrono::time_point_cast<Clock::time_point>(abs_time));
     }
 
     virtual bool try_unlock_upgrade_and_lock_for(chrono::nanoseconds const & relative_time)=0;
     template <typename Rep, typename Period>
     bool try_unlock_upgrade_and_lock_for(chrono::duration<Rep, Period> const & rel_time)
     {
-      return try_unlock_upgrade_and_lock_for(duration_cast<Clock::duration>(rel_time));
+      return try_unlock_upgrade_and_lock_for(chrono::duration_cast<chrono::nanoseconds>(rel_time));
     }
 
     virtual void unlock_upgrade_and_lock_shared() = 0;
 
   };
-//]
+  //]
 
+  // A proper name for upgrade_poly_lockable, consistent with naming scheme of other polymorphic wrappers
+  typedef upgrade_poly_lockable poly_upgrade_lockable;
 }
 #endif

include/boost/thread/poly_shared_lockable_adapter.hpp

@@ -17,7 +17,7 @@
 namespace boost
 {
 
-  //[shared_lockable_adapter
+  //[poly_shared_lockable_adapter
   template <typename Mutex, typename Base=poly_shared_lockable>
   class poly_shared_lockable_adapter: public poly_timed_lockable_adapter<Mutex, Base>
   {
@@ -54,9 +54,9 @@ namespace boost
 
   //]
 
-  //[upgrade_lockable_adapter
+  //[poly_upgrade_lockable_adapter
   template <typename Mutex, typename Base=poly_shared_lockable>
-  class upgrade_lockable_adapter: public shared_lockable_adapter<Mutex, Base>
+  class poly_upgrade_lockable_adapter: public poly_shared_lockable_adapter<Mutex, Base>
   {
   public:
     typedef Mutex mutex_type;
@@ -102,7 +102,6 @@ namespace boost
     {
       return this->mtx().try_unlock_shared_and_lock_until(abs_time);
     }
-    template <typename Rep, typename Period>
     bool try_unlock_shared_and_lock_for(chrono::nanoseconds const & rel_time)
     {
       return this->mtx().try_unlock_shared_and_lock_for(rel_time);

include/boost/thread/pthread/condition_variable.hpp

@@ -11,6 +11,7 @@
 #include <boost/thread/pthread/pthread_helpers.hpp>
 
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+#include <boost/thread/interruption.hpp>
 #include <boost/thread/pthread/thread_data.hpp>
 #endif
 #include <boost/thread/pthread/condition_variable_fwd.hpp>
@@ -26,13 +27,6 @@
 
 namespace boost
 {
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-    namespace this_thread
-    {
-        void BOOST_THREAD_DECL interruption_point();
-    }
-#endif
-
     namespace thread_cv_detail
     {
         template<typename MutexType>
@@ -249,7 +243,7 @@ namespace boost
 #endif
         }
         template<typename lock_type>
-        bool timed_wait(lock_type& m,xtime const& abs_time)
+        bool timed_wait(lock_type& m,::boost::xtime const& abs_time)
         {
             return timed_wait(m,system_time(abs_time));
         }
@@ -309,7 +303,7 @@ namespace boost
         }
 
         template<typename lock_type,typename predicate_type>
-        bool timed_wait(lock_type& m,xtime const& abs_time, predicate_type pred)
+        bool timed_wait(lock_type& m,::boost::xtime const& abs_time, predicate_type pred)
         {
             return timed_wait(m,system_time(abs_time),pred);
         }

include/boost/thread/pthread/condition_variable_fwd.hpp

@@ -128,7 +128,7 @@ namespace boost
         }
         bool timed_wait(
             unique_lock<mutex>& m,
-            xtime const& abs_time)
+            ::boost::xtime const& abs_time)
         {
             return timed_wait(m,system_time(abs_time));
         }
@@ -194,7 +194,7 @@ namespace boost
         template<typename predicate_type>
         bool timed_wait(
             unique_lock<mutex>& m,
-            xtime const& abs_time,predicate_type pred)
+            ::boost::xtime const& abs_time,predicate_type pred)
         {
             return timed_wait(m,system_time(abs_time),pred);
         }

include/boost/thread/pthread/mutex.hpp

@@ -39,53 +39,8 @@
 
 namespace boost
 {
-  namespace posix {
-#ifdef BOOST_THREAD_HAS_EINTR_BUG
-    BOOST_FORCEINLINE int pthread_mutex_destroy(pthread_mutex_t* m)
-    {
-      int ret;
-      do
-      {
-          ret = ::pthread_mutex_destroy(m);
-      } while (ret == EINTR);
-      return ret;
-    }
-    BOOST_FORCEINLINE int pthread_mutex_lock(pthread_mutex_t* m)
-    {
-      int ret;
-      do
-      {
-          ret = ::pthread_mutex_lock(m);
-      } while (ret == EINTR);
-      return ret;
-    }
-    BOOST_FORCEINLINE int pthread_mutex_unlock(pthread_mutex_t* m)
-    {
-      int ret;
-      do
-      {
-          ret = ::pthread_mutex_unlock(m);
-      } while (ret == EINTR);
-      return ret;
-    }
-#else
-    BOOST_FORCEINLINE int pthread_mutex_destroy(pthread_mutex_t* m)
-    {
-      return ::pthread_mutex_destroy(m);
-    }
-    BOOST_FORCEINLINE int pthread_mutex_lock(pthread_mutex_t* m)
-    {
-      return ::pthread_mutex_lock(m);
-    }
-    BOOST_FORCEINLINE int pthread_mutex_unlock(pthread_mutex_t* m)
-    {
-      return ::pthread_mutex_unlock(m);
-    }
 
-#endif
-
-  }
-    class mutex
+    class BOOST_THREAD_CAPABILITY("mutex") mutex
     {
     private:
         pthread_mutex_t m;
@@ -107,7 +62,7 @@ namespace boost
           BOOST_ASSERT(!res);
         }
 
-        void lock()
+        void lock() BOOST_THREAD_ACQUIRE()
         {
             int res = posix::pthread_mutex_lock(&m);
             if (res)
@@ -116,7 +71,7 @@ namespace boost
             }
         }
 
-        void unlock()
+        void unlock() BOOST_THREAD_RELEASE()
         {
             int res = posix::pthread_mutex_unlock(&m);
             (void)res;
@@ -127,12 +82,12 @@ namespace boost
 //            }
         }
 
-        bool try_lock()
+        bool try_lock() BOOST_THREAD_TRY_ACQUIRE(true)
         {
             int res;
             do
             {
-                res = pthread_mutex_trylock(&m);
+                res = posix::pthread_mutex_trylock(&m);
             } while (res == EINTR);
             if (res==EBUSY)
             {
@@ -251,7 +206,7 @@ namespace boost
           int res;
           do
           {
-              res = pthread_mutex_trylock(&m);
+              res = posix::pthread_mutex_trylock(&m);
           } while (res == EINTR);
           if (res==EBUSY)
           {
@@ -277,7 +232,7 @@ namespace boost
             boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
             while(is_locked)
             {
-                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
+                BOOST_VERIFY(!posix::pthread_cond_wait(&cond,&m));
             }
             is_locked=true;
         }
@@ -286,7 +241,7 @@ namespace boost
         {
             boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
             is_locked=false;
-            BOOST_VERIFY(!pthread_cond_signal(&cond));
+            BOOST_VERIFY(!posix::pthread_cond_signal(&cond));
         }
 
         bool try_lock()

include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp

@@ -13,6 +13,75 @@
 
 namespace boost
 {
+namespace posix {
+#ifdef BOOST_THREAD_HAS_EINTR_BUG
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_destroy(pthread_mutex_t* m)
+  {
+    int ret;
+    do
+    {
+        ret = ::pthread_mutex_destroy(m);
+    } while (ret == EINTR);
+    return ret;
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_lock(pthread_mutex_t* m)
+  {
+    int ret;
+    do
+    {
+        ret = ::pthread_mutex_lock(m);
+    } while (ret == EINTR);
+    return ret;
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_unlock(pthread_mutex_t* m)
+  {
+    int ret;
+    do
+    {
+        ret = ::pthread_mutex_unlock(m);
+    } while (ret == EINTR);
+    return ret;
+  }
+#else
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_destroy(pthread_mutex_t* m)
+  {
+    return ::pthread_mutex_destroy(m);
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_lock(pthread_mutex_t* m)
+  {
+    return ::pthread_mutex_lock(m);
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_unlock(pthread_mutex_t* m)
+  {
+    return ::pthread_mutex_unlock(m);
+  }
+
+#endif
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_mutex_trylock(pthread_mutex_t* m)
+  {
+    return ::pthread_mutex_trylock(m);
+  }
+
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
+  {
+    return ::pthread_cond_wait(cond, mutex);
+  }
+  BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+  int pthread_cond_signal(pthread_cond_t *cond)
+  {
+    return ::pthread_cond_signal(cond);
+  }
+
+
+}
     namespace pthread
     {
         class pthread_mutex_scoped_lock
@@ -23,11 +92,11 @@ namespace boost
             explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_) BOOST_NOEXCEPT:
                 m(m_),locked(true)
             {
-                BOOST_VERIFY(!pthread_mutex_lock(m));
+                BOOST_VERIFY(!posix::pthread_mutex_lock(m));
             }
             void unlock() BOOST_NOEXCEPT
             {
-                BOOST_VERIFY(!pthread_mutex_unlock(m));
+                BOOST_VERIFY(!posix::pthread_mutex_unlock(m));
                 locked=false;
             }
             void unlock_if_locked() BOOST_NOEXCEPT
@@ -54,11 +123,11 @@ namespace boost
             explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_) BOOST_NOEXCEPT:
                 m(m_)
             {
-                BOOST_VERIFY(!pthread_mutex_unlock(m));
+                BOOST_VERIFY(!posix::pthread_mutex_unlock(m));
             }
             ~pthread_mutex_scoped_unlock() BOOST_NOEXCEPT
             {
-                BOOST_VERIFY(!pthread_mutex_lock(m));
+                BOOST_VERIFY(!posix::pthread_mutex_lock(m));
             }
 
         };

include/boost/thread/pthread/recursive_mutex.hpp

@@ -105,17 +105,17 @@ namespace boost
 #ifdef BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
         void lock()
         {
-            BOOST_VERIFY(!pthread_mutex_lock(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_lock(&m));
         }
 
         void unlock()
         {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_unlock(&m));
         }
 
         bool try_lock() BOOST_NOEXCEPT
         {
-            int const res=pthread_mutex_trylock(&m);
+            int const res=posix::pthread_mutex_trylock(&m);
             BOOST_ASSERT(!res || res==EBUSY);
             return !res;
         }
@@ -270,17 +270,17 @@ namespace boost
 #ifdef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
         void lock()
         {
-            BOOST_VERIFY(!pthread_mutex_lock(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_lock(&m));
         }
 
         void unlock()
         {
-            BOOST_VERIFY(!pthread_mutex_unlock(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_unlock(&m));
         }
 
         bool try_lock()
         {
-            int const res=pthread_mutex_trylock(&m);
+            int const res=posix::pthread_mutex_trylock(&m);
             BOOST_ASSERT(!res || res==EBUSY);
             return !res;
         }

include/boost/thread/pthread/thread_data.hpp

@@ -12,6 +12,7 @@
 #include <boost/thread/lock_types.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/pthread/condition_variable_fwd.hpp>
+#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
 
 #include <boost/shared_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
@@ -56,7 +57,7 @@ namespace boost
 #else
           std::size_t page_size = ::sysconf( _SC_PAGESIZE);
 #endif
-#ifdef PTHREAD_STACK_MIN
+#if PTHREAD_STACK_MIN > 0
           if (size<PTHREAD_STACK_MIN) size=PTHREAD_STACK_MIN;
 #endif
           size = ((size+page_size-1)/page_size)*page_size;
@@ -93,12 +94,15 @@ namespace boost
         struct thread_exit_callback_node;
         struct tss_data_node
         {
-            boost::shared_ptr<boost::detail::tss_cleanup_function> func;
+            typedef void(*cleanup_func_t)(void*);
+            typedef void(*cleanup_caller_t)(cleanup_func_t, void*);
+
+            cleanup_caller_t caller;
+            cleanup_func_t func;
             void* value;
 
-            tss_data_node(boost::shared_ptr<boost::detail::tss_cleanup_function> func_,
-                          void* value_):
-                func(func_),value(value_)
+            tss_data_node(cleanup_caller_t caller_,cleanup_func_t func_,void* value_):
+                caller(caller_),func(func_),value(value_)
             {}
         };
 
@@ -130,9 +134,10 @@ namespace boost
             > notify_list_t;
             notify_list_t notify;
 
+//#ifndef BOOST_NO_EXCEPTIONS
             typedef std::vector<shared_ptr<shared_state_base> > async_states_t;
             async_states_t async_states_;
-
+//#endif
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             // These data must be at the end so that the access to the other fields doesn't change
             // when BOOST_THREAD_PROVIDES_INTERRUPTIONS is defined.
@@ -148,8 +153,10 @@ namespace boost
                 cond_mutex(0),
                 current_cond(0),
 //#endif
-                notify(),
-                async_states_()
+                notify()
+//#ifndef BOOST_NO_EXCEPTIONS
+                , async_states_()
+//#endif
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 , interrupt_enabled(true)
                 , interrupt_requested(false)
@@ -165,11 +172,12 @@ namespace boost
               notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
             }
 
+//#ifndef BOOST_NO_EXCEPTIONS
             void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
             {
               async_states_.push_back(as);
             }
-
+//#endif
         };
 
         BOOST_THREAD_DECL thread_data_base* get_current_thread_data();
@@ -205,11 +213,11 @@ namespace boost
                     check_for_interruption();
                     thread_info->cond_mutex=cond_mutex;
                     thread_info->current_cond=cond;
-                    BOOST_VERIFY(!pthread_mutex_lock(m));
+                    BOOST_VERIFY(!posix::pthread_mutex_lock(m));
                 }
                 else
                 {
-                    BOOST_VERIFY(!pthread_mutex_lock(m));
+                    BOOST_VERIFY(!posix::pthread_mutex_lock(m));
                 }
             }
             void unlock_if_locked()
@@ -217,14 +225,14 @@ namespace boost
               if ( ! done) {
                 if (set)
                 {
-                    BOOST_VERIFY(!pthread_mutex_unlock(m));
+                    BOOST_VERIFY(!posix::pthread_mutex_unlock(m));
                     lock_guard<mutex> guard(thread_info->data_mutex);
                     thread_info->cond_mutex=NULL;
                     thread_info->current_cond=NULL;
                 }
                 else
                 {
-                    BOOST_VERIFY(!pthread_mutex_unlock(m));
+                    BOOST_VERIFY(!posix::pthread_mutex_unlock(m));
                 }
                 done = true;
               }
@@ -264,7 +272,7 @@ namespace boost
         }
 
         template<typename TimeDuration>
-        inline void sleep(TimeDuration const& rel_time)
+        void sleep(TimeDuration const& rel_time)
         {
           mutex mx;
           unique_lock<mutex> lock(mx);
@@ -275,7 +283,7 @@ namespace boost
 
 #ifdef BOOST_THREAD_USES_CHRONO
         template <class Clock, class Duration>
-        inline void sleep_until(const chrono::time_point<Clock, Duration>& t)
+        void sleep_until(const chrono::time_point<Clock, Duration>& t)
         {
           mutex mut;
           unique_lock<mutex> lk(mut);
@@ -284,7 +292,7 @@ namespace boost
         }
 
         template <class Rep, class Period>
-        inline void sleep_for(const chrono::duration<Rep, Period>& d)
+        void sleep_for(const chrono::duration<Rep, Period>& d)
         {
           mutex mut;
           unique_lock<mutex> lk(mut);
@@ -322,7 +330,7 @@ namespace boost
           }
 
           template<typename TimeDuration>
-          inline void sleep(TimeDuration const& rel_time)
+          void sleep(TimeDuration const& rel_time)
           {
             hidden::sleep_for_internal(detail::platform_duration(rel_time));
           }
@@ -330,19 +338,19 @@ namespace boost
 
 #ifdef BOOST_THREAD_USES_CHRONO
           template <class Rep, class Period>
-          inline void sleep_for(const chrono::duration<Rep, Period>& d)
+          void sleep_for(const chrono::duration<Rep, Period>& d)
           {
             hidden::sleep_for_internal(detail::platform_duration(d));
           }
 
           template <class Duration>
-          inline void sleep_until(const chrono::time_point<chrono::steady_clock, Duration>& t)
+          void sleep_until(const chrono::time_point<chrono::steady_clock, Duration>& t)
           {
             sleep_for(t - chrono::steady_clock::now());
           }
 
           template <class Clock, class Duration>
-          inline void sleep_until(const chrono::time_point<Clock, Duration>& t)
+          void sleep_until(const chrono::time_point<Clock, Duration>& t)
           {
             typedef typename common_type<Duration, typename Clock::duration>::type common_duration;
             common_duration d(t - Clock::now());
@@ -370,7 +378,7 @@ namespace boost
           }
 
           template<typename TimeDuration>
-          inline void sleep(TimeDuration const& rel_time)
+          void sleep(TimeDuration const& rel_time)
           {
             this_thread::sleep(rel_time);
           }
@@ -378,13 +386,13 @@ namespace boost
 
 #ifdef BOOST_THREAD_USES_CHRONO
           template <class Clock, class Duration>
-          inline void sleep_until(const chrono::time_point<Clock, Duration>& t)
+          void sleep_until(const chrono::time_point<Clock, Duration>& t)
           {
             this_thread::sleep_until(t);
           }
 
           template <class Rep, class Period>
-          inline void sleep_for(const chrono::duration<Rep, Period>& d)
+          void sleep_for(const chrono::duration<Rep, Period>& d)
           {
             this_thread::sleep_for(d);
           }

include/boost/thread/tss.hpp

@@ -6,8 +6,8 @@
 // (C) Copyright 2007-8 Anthony Williams
 
 #include <boost/thread/detail/config.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/thread/detail/thread_heap_alloc.hpp>
+
+#include <boost/type_traits/add_reference.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -15,15 +15,13 @@ namespace boost
 {
     namespace detail
     {
-        struct tss_cleanup_function
+        namespace thread
         {
-            virtual ~tss_cleanup_function()
-            {}
+            typedef void(*cleanup_func_t)(void*);
+            typedef void(*cleanup_caller_t)(cleanup_func_t, void*);
+        }
 
-            virtual void operator()(void* data)=0;
-        };
-
-        BOOST_THREAD_DECL void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
+        BOOST_THREAD_DECL void set_tss_data(void const* key,detail::thread::cleanup_caller_t caller,detail::thread::cleanup_func_t func,void* tss_data,bool cleanup_existing);
         BOOST_THREAD_DECL void* get_tss_data(void const* key);
     }
 
@@ -34,49 +32,33 @@ namespace boost
         thread_specific_ptr(thread_specific_ptr&);
         thread_specific_ptr& operator=(thread_specific_ptr&);
 
-        struct delete_data:
-            detail::tss_cleanup_function
+        typedef void(*original_cleanup_func_t)(T*);
+
+        static void default_deleter(T* data)
         {
-            void operator()(void* data)
-            {
-                delete static_cast<T*>(data);
-            }
-        };
+            delete data;
+        }
 
-        struct run_custom_cleanup_function:
-            detail::tss_cleanup_function
+        static void cleanup_caller(detail::thread::cleanup_func_t cleanup_function,void* data)
         {
-            void (*cleanup_function)(T*);
-
-            explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
-                cleanup_function(cleanup_function_)
-            {}
-
-            void operator()(void* data)
-            {
-                cleanup_function(static_cast<T*>(data));
-            }
-        };
+            reinterpret_cast<original_cleanup_func_t>(cleanup_function)(static_cast<T*>(data));
+        }
 
 
-        boost::shared_ptr<detail::tss_cleanup_function> cleanup;
+        detail::thread::cleanup_func_t cleanup;
 
     public:
         typedef T element_type;
 
         thread_specific_ptr():
-            cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
+            cleanup(reinterpret_cast<detail::thread::cleanup_func_t>(&default_deleter))
         {}
         explicit thread_specific_ptr(void (*func_)(T*))
-        {
-            if(func_)
-            {
-                cleanup.reset(detail::heap_new<run_custom_cleanup_function>(func_),detail::do_heap_delete<run_custom_cleanup_function>());
-            }
-        }
+          : cleanup(reinterpret_cast<detail::thread::cleanup_func_t>(func_))
+        {}
         ~thread_specific_ptr()
         {
-            detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,true);
+            detail::set_tss_data(this,0,0,0,true);
         }
 
         T* get() const
@@ -87,14 +69,14 @@ namespace boost
         {
             return get();
         }
-        typename boost::detail::sp_dereference< T >::type operator*() const
+        typename add_reference<T>::type operator*() const
         {
             return *get();
         }
         T* release()
         {
             T* const temp=get();
-            detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,false);
+            detail::set_tss_data(this,0,0,0,false);
             return temp;
         }
         void reset(T* new_value=0)
@@ -102,7 +84,7 @@ namespace boost
             T* const current_value=get();
             if(current_value!=new_value)
             {
-                detail::set_tss_data(this,cleanup,new_value,true);
+                detail::set_tss_data(this,&cleanup_caller,cleanup,new_value,true);
             }
         }
     };

include/boost/thread/user_scheduler.hpp

@@ -10,6 +10,8 @@
 #define BOOST_THREAD_USER_SCHEDULER_HPP
 
 #include <boost/thread/detail/config.hpp>
+#if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined BOOST_THREAD_PROVIDES_EXECUTORS && defined BOOST_THREAD_USES_MOVE
+
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/concurrent_queues/sync_queue.hpp>
@@ -200,3 +202,4 @@ namespace boost
 #include <boost/config/abi_suffix.hpp>
 
 #endif
+#endif

include/boost/thread/v2/shared_mutex.hpp

@@ -230,8 +230,7 @@ namespace boost {
         return try_lock_until(chrono::steady_clock::now() + rel_time);
       }
       template <class Clock, class Duration>
-      bool
-      try_lock_until(
+      bool try_lock_until(
           const boost::chrono::time_point<Clock, Duration>& abs_time);
 #endif
 #if defined BOOST_THREAD_USES_DATETIME
@@ -246,14 +245,12 @@ namespace boost {
       bool try_lock_shared();
 #ifdef BOOST_THREAD_USES_CHRONO
       template <class Rep, class Period>
-      bool
-      try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time)
+      bool try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time)
       {
         return try_lock_shared_until(chrono::steady_clock::now() + rel_time);
       }
       template <class Clock, class Duration>
-      bool
-      try_lock_shared_until(
+      bool try_lock_shared_until(
           const boost::chrono::time_point<Clock, Duration>& abs_time);
 #endif
 #if defined BOOST_THREAD_USES_DATETIME
@@ -275,8 +272,7 @@ namespace boost {
 
     // Exclusive ownership
 
-    inline void
-    shared_mutex::lock()
+    inline void shared_mutex::lock()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       gate1_.wait(lk, boost::bind(&shared_mutex::no_writer, boost::ref(*this)));
@@ -284,8 +280,7 @@ namespace boost {
       gate2_.wait(lk, boost::bind(&shared_mutex::no_readers, boost::ref(*this)));
     }
 
-    inline bool
-    shared_mutex::try_lock()
+    inline bool shared_mutex::try_lock()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!no_writer_no_readers())
@@ -298,8 +293,7 @@ namespace boost {
 
 #ifdef BOOST_THREAD_USES_CHRONO
     template <class Clock, class Duration>
-    inline bool
-    shared_mutex::try_lock_until(
+    bool shared_mutex::try_lock_until(
         const boost::chrono::time_point<Clock, Duration>& abs_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
@@ -321,8 +315,7 @@ namespace boost {
 
 #if defined BOOST_THREAD_USES_DATETIME
     template<typename T>
-    inline bool
-    shared_mutex::timed_lock(T const & abs_or_rel_time)
+    bool shared_mutex::timed_lock(T const & abs_or_rel_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
@@ -341,8 +334,7 @@ namespace boost {
     }
 #endif
 
-    inline void
-    shared_mutex::unlock()
+    inline void shared_mutex::unlock()
     {
       boost::lock_guard<mutex_t> _(mut_);
       BOOST_ASSERT(one_writer());
@@ -355,8 +347,7 @@ namespace boost {
 
     // Shared ownership
 
-    inline void
-    shared_mutex::lock_shared()
+    inline void shared_mutex::lock_shared()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       gate1_.wait(lk, boost::bind(&shared_mutex::no_writer_no_max_readers, boost::ref(*this)));
@@ -365,8 +356,7 @@ namespace boost {
       state_ |= num_readers;
     }
 
-    inline bool
-    shared_mutex::try_lock_shared()
+    inline bool shared_mutex::try_lock_shared()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!no_writer_no_max_readers())
@@ -381,8 +371,7 @@ namespace boost {
 
 #ifdef BOOST_THREAD_USES_CHRONO
     template <class Clock, class Duration>
-    inline bool
-    shared_mutex::try_lock_shared_until(
+    bool shared_mutex::try_lock_shared_until(
         const boost::chrono::time_point<Clock, Duration>& abs_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
@@ -400,8 +389,7 @@ namespace boost {
 
 #if defined BOOST_THREAD_USES_DATETIME
     template<typename T>
-    inline bool
-    shared_mutex::timed_lock_shared(T const & abs_or_rel_time)
+    bool shared_mutex::timed_lock_shared(T const & abs_or_rel_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
@@ -416,8 +404,7 @@ namespace boost {
     }
 #endif
 
-    inline void
-    shared_mutex::unlock_shared()
+    inline void shared_mutex::unlock_shared()
     {
       boost::lock_guard<mutex_t> _(mut_);
       BOOST_ASSERT(one_or_more_readers());
@@ -543,8 +530,7 @@ namespace boost {
         return try_lock_until(chrono::steady_clock::now() + rel_time);
       }
       template <class Clock, class Duration>
-      bool
-      try_lock_until(
+      bool try_lock_until(
           const boost::chrono::time_point<Clock, Duration>& abs_time);
 #endif
 #if defined BOOST_THREAD_USES_DATETIME
@@ -559,14 +545,12 @@ namespace boost {
       bool try_lock_shared();
 #ifdef BOOST_THREAD_USES_CHRONO
       template <class Rep, class Period>
-      bool
-      try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time)
+      bool try_lock_shared_for(const boost::chrono::duration<Rep, Period>& rel_time)
       {
         return try_lock_shared_until(chrono::steady_clock::now() + rel_time);
       }
       template <class Clock, class Duration>
-      bool
-      try_lock_shared_until(
+      bool try_lock_shared_until(
           const boost::chrono::time_point<Clock, Duration>& abs_time);
 #endif
 #if defined BOOST_THREAD_USES_DATETIME
@@ -581,15 +565,13 @@ namespace boost {
       bool try_lock_upgrade();
 #ifdef BOOST_THREAD_USES_CHRONO
       template <class Rep, class Period>
-      bool
-      try_lock_upgrade_for(
+      bool try_lock_upgrade_for(
           const boost::chrono::duration<Rep, Period>& rel_time)
       {
         return try_lock_upgrade_until(chrono::steady_clock::now() + rel_time);
       }
       template <class Clock, class Duration>
-      bool
-      try_lock_upgrade_until(
+      bool try_lock_upgrade_until(
           const boost::chrono::time_point<Clock, Duration>& abs_time);
 #endif
 #if defined BOOST_THREAD_USES_DATETIME
@@ -605,15 +587,13 @@ namespace boost {
       bool try_unlock_shared_and_lock();
 #ifdef BOOST_THREAD_USES_CHRONO
       template <class Rep, class Period>
-      bool
-      try_unlock_shared_and_lock_for(
+      bool try_unlock_shared_and_lock_for(
           const boost::chrono::duration<Rep, Period>& rel_time)
       {
         return try_unlock_shared_and_lock_until(chrono::steady_clock::now() + rel_time);
       }
       template <class Clock, class Duration>
-      bool
-      try_unlock_shared_and_lock_until(
+      bool try_unlock_shared_and_lock_until(
           const boost::chrono::time_point<Clock, Duration>& abs_time);
 #endif
 #endif
@@ -626,15 +606,13 @@ namespace boost {
       bool try_unlock_shared_and_lock_upgrade();
 #ifdef BOOST_THREAD_USES_CHRONO
       template <class Rep, class Period>
-      bool
-      try_unlock_shared_and_lock_upgrade_for(
+      bool try_unlock_shared_and_lock_upgrade_for(
           const boost::chrono::duration<Rep, Period>& rel_time)
       {
         return try_unlock_shared_and_lock_upgrade_until(chrono::steady_clock::now() + rel_time);
       }
       template <class Clock, class Duration>
-      bool
-      try_unlock_shared_and_lock_upgrade_until(
+      bool try_unlock_shared_and_lock_upgrade_until(
           const boost::chrono::time_point<Clock, Duration>& abs_time);
 #endif
 #endif
@@ -646,15 +624,13 @@ namespace boost {
       bool try_unlock_upgrade_and_lock();
 #ifdef BOOST_THREAD_USES_CHRONO
       template <class Rep, class Period>
-      bool
-      try_unlock_upgrade_and_lock_for(
+      bool try_unlock_upgrade_and_lock_for(
           const boost::chrono::duration<Rep, Period>& rel_time)
       {
         return try_unlock_upgrade_and_lock_until(chrono::steady_clock::now() + rel_time);
       }
       template <class Clock, class Duration>
-      bool
-      try_unlock_upgrade_and_lock_until(
+      bool try_unlock_upgrade_and_lock_until(
           const boost::chrono::time_point<Clock, Duration>& abs_time);
 #endif
       void unlock_and_lock_upgrade();
@@ -674,8 +650,7 @@ namespace boost {
 
     // Exclusive ownership
 
-    inline void
-    upgrade_mutex::lock()
+    inline void upgrade_mutex::lock()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader, boost::ref(*this)));
@@ -683,8 +658,7 @@ namespace boost {
       gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, boost::ref(*this)));
     }
 
-    inline bool
-    upgrade_mutex::try_lock()
+    inline bool upgrade_mutex::try_lock()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!no_writer_no_upgrader_no_readers())
@@ -697,8 +671,7 @@ namespace boost {
 
 #ifdef BOOST_THREAD_USES_CHRONO
     template <class Clock, class Duration>
-    inline bool
-    upgrade_mutex::try_lock_until(
+    bool upgrade_mutex::try_lock_until(
         const boost::chrono::time_point<Clock, Duration>& abs_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
@@ -720,8 +693,7 @@ namespace boost {
 
 #if defined BOOST_THREAD_USES_DATETIME
     template<typename T>
-    inline bool
-    upgrade_mutex::timed_lock(T const & abs_or_rel_time)
+    bool upgrade_mutex::timed_lock(T const & abs_or_rel_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
@@ -740,8 +712,7 @@ namespace boost {
     }
 #endif
 
-    inline void
-    upgrade_mutex::unlock()
+    inline void upgrade_mutex::unlock()
     {
       boost::lock_guard<mutex_t> _(mut_);
       BOOST_ASSERT(one_writer());
@@ -755,8 +726,7 @@ namespace boost {
 
     // Shared ownership
 
-    inline void
-    upgrade_mutex::lock_shared()
+    inline void upgrade_mutex::lock_shared()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_max_readers, boost::ref(*this)));
@@ -765,8 +735,7 @@ namespace boost {
       state_ |= num_readers;
     }
 
-    inline bool
-    upgrade_mutex::try_lock_shared()
+    inline bool upgrade_mutex::try_lock_shared()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!no_writer_no_max_readers())
@@ -781,8 +750,7 @@ namespace boost {
 
 #ifdef BOOST_THREAD_USES_CHRONO
     template <class Clock, class Duration>
-    inline bool
-    upgrade_mutex::try_lock_shared_until(
+    bool upgrade_mutex::try_lock_shared_until(
         const boost::chrono::time_point<Clock, Duration>& abs_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
@@ -800,8 +768,7 @@ namespace boost {
 
 #if defined BOOST_THREAD_USES_DATETIME
     template<typename T>
-    inline bool
-    upgrade_mutex::timed_lock_shared(T const & abs_or_rel_time)
+    bool upgrade_mutex::timed_lock_shared(T const & abs_or_rel_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
@@ -816,8 +783,7 @@ namespace boost {
     }
 #endif
 
-    inline void
-    upgrade_mutex::unlock_shared()
+    inline void upgrade_mutex::unlock_shared()
     {
       boost::lock_guard<mutex_t> _(mut_);
       BOOST_ASSERT(one_or_more_readers());
@@ -838,8 +804,7 @@ namespace boost {
 
     // Upgrade ownership
 
-    inline void
-    upgrade_mutex::lock_upgrade()
+    inline void upgrade_mutex::lock_upgrade()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this)));
@@ -848,8 +813,7 @@ namespace boost {
       state_ |= upgradable_entered_ | num_readers;
     }
 
-    inline bool
-    upgrade_mutex::try_lock_upgrade()
+    inline bool upgrade_mutex::try_lock_upgrade()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!no_writer_no_upgrader_no_max_readers())
@@ -864,8 +828,7 @@ namespace boost {
 
 #ifdef BOOST_THREAD_USES_CHRONO
     template <class Clock, class Duration>
-    inline bool
-    upgrade_mutex::try_lock_upgrade_until(
+    bool upgrade_mutex::try_lock_upgrade_until(
         const boost::chrono::time_point<Clock, Duration>& abs_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
@@ -883,8 +846,7 @@ namespace boost {
 
 #if defined BOOST_THREAD_USES_DATETIME
     template<typename T>
-    inline bool
-    upgrade_mutex::timed_lock_upgrade(T const & abs_or_rel_time)
+    bool upgrade_mutex::timed_lock_upgrade(T const & abs_or_rel_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
@@ -899,8 +861,7 @@ namespace boost {
     }
 #endif
 
-    inline void
-    upgrade_mutex::unlock_upgrade()
+    inline void upgrade_mutex::unlock_upgrade()
     {
       boost::lock_guard<mutex_t> _(mut_);
       BOOST_ASSERT(no_writer());
@@ -917,8 +878,7 @@ namespace boost {
     // Shared <-> Exclusive
 
 #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
-    inline bool
-    upgrade_mutex::try_unlock_shared_and_lock()
+    inline bool upgrade_mutex::try_unlock_shared_and_lock()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       BOOST_ASSERT(one_or_more_readers());
@@ -932,8 +892,7 @@ namespace boost {
 
 #ifdef BOOST_THREAD_USES_CHRONO
     template <class Clock, class Duration>
-    inline bool
-    upgrade_mutex::try_unlock_shared_and_lock_until(
+    bool upgrade_mutex::try_unlock_shared_and_lock_until(
         const boost::chrono::time_point<Clock, Duration>& abs_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
@@ -959,8 +918,7 @@ namespace boost {
 #endif
 #endif
 
-    inline void
-    upgrade_mutex::unlock_and_lock_shared()
+    inline void upgrade_mutex::unlock_and_lock_shared()
     {
       boost::lock_guard<mutex_t> _(mut_);
       BOOST_ASSERT(one_writer());
@@ -975,8 +933,7 @@ namespace boost {
     // Shared <-> Upgrade
 
 #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS
-    inline bool
-    upgrade_mutex::try_unlock_shared_and_lock_upgrade()
+    inline bool upgrade_mutex::try_unlock_shared_and_lock_upgrade()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       BOOST_ASSERT(one_or_more_readers());
@@ -990,8 +947,7 @@ namespace boost {
 
 #ifdef BOOST_THREAD_USES_CHRONO
     template <class Clock, class Duration>
-    inline bool
-    upgrade_mutex::try_unlock_shared_and_lock_upgrade_until(
+    bool upgrade_mutex::try_unlock_shared_and_lock_upgrade_until(
         const boost::chrono::time_point<Clock, Duration>& abs_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
@@ -1007,8 +963,7 @@ namespace boost {
 #endif
 #endif
 
-    inline void
-    upgrade_mutex::unlock_upgrade_and_lock_shared()
+    inline void upgrade_mutex::unlock_upgrade_and_lock_shared()
     {
       boost::lock_guard<mutex_t> _(mut_);
       BOOST_ASSERT(no_writer());
@@ -1023,8 +978,7 @@ namespace boost {
 
     // Upgrade <-> Exclusive
 
-    inline void
-    upgrade_mutex::unlock_upgrade_and_lock()
+    inline void upgrade_mutex::unlock_upgrade_and_lock()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       BOOST_ASSERT(no_writer());
@@ -1036,8 +990,7 @@ namespace boost {
       gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, boost::ref(*this)));
     }
 
-    inline bool
-    upgrade_mutex::try_unlock_upgrade_and_lock()
+    inline bool upgrade_mutex::try_unlock_upgrade_and_lock()
     {
       boost::unique_lock<mutex_t> lk(mut_);
       BOOST_ASSERT(no_writer());
@@ -1053,8 +1006,7 @@ namespace boost {
 
 #ifdef BOOST_THREAD_USES_CHRONO
     template <class Clock, class Duration>
-    inline bool
-    upgrade_mutex::try_unlock_upgrade_and_lock_until(
+    bool upgrade_mutex::try_unlock_upgrade_and_lock_until(
         const boost::chrono::time_point<Clock, Duration>& abs_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
@@ -1076,8 +1028,7 @@ namespace boost {
     }
 #endif
 
-    inline void
-    upgrade_mutex::unlock_and_lock_upgrade()
+    inline void upgrade_mutex::unlock_and_lock_upgrade()
     {
       boost::lock_guard<mutex_t> _(mut_);
       BOOST_ASSERT(one_writer());

include/boost/thread/win32/basic_recursive_mutex.hpp

@@ -67,7 +67,7 @@ namespace boost
             template<typename Duration>
             bool timed_lock(Duration const& target)
             {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=boost::winapi::GetCurrentThreadId();
                 return try_recursive_lock(current_thread_id) || try_timed_lock(current_thread_id,target);
             }
 #endif
@@ -76,13 +76,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=boost::winapi::GetCurrentThreadId();
                 return try_recursive_lock(current_thread_id) || try_timed_lock_for(current_thread_id,rel_time);
             }
             template <class Clock, class Duration>
             bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
             {
-                long const current_thread_id=boost::detail::winapi::GetCurrentThreadId();
+                long const current_thread_id=boost::winapi::GetCurrentThreadId();
                 return try_recursive_lock(current_thread_id) || try_timed_lock_until(current_thread_id,t);
             }
 #endif

include/boost/thread/win32/interlocked_read.hpp

@@ -87,9 +87,9 @@ namespace boost
         {
             void* const res=
 #if defined(_M_ARM64)
-                __iso_volatile_load64((const volatile __int64*)x);
+                (void*)__iso_volatile_load64((const volatile __int64*)x);
 #else
-                __iso_volatile_load32((const volatile __int32*)x);
+                (void*)__iso_volatile_load32((const volatile __int32*)x);
 #endif
             BOOST_THREAD_DETAIL_COMPILER_BARRIER();
             __dmb(0xB); // _ARM_BARRIER_ISH, see armintr.h from MSVC 11 and later

include/boost/thread/win32/once.hpp

@@ -225,7 +225,7 @@ namespace boost
     }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-//#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR)
+//#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR)
     inline void call_once(once_flag& flag, void (*f)())
     {
         // Try for a quick win: if the procedure has already been called
@@ -709,7 +709,7 @@ namespace boost
     }
 #endif
 #if 1
-#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR)
+#if defined(BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR)
         inline void call_once(once_flag& flag, void (*f)())
         {
             // Try for a quick win: if the procedure has already been called

include/boost/thread/win32/shared_mutex.hpp

@@ -8,6 +8,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
+#include <cstring>
 #include <boost/assert.hpp>
 #include <boost/detail/interlocked.hpp>
 #include <boost/thread/win32/thread_primitives.hpp>
@@ -39,16 +40,22 @@ namespace boost
 
             friend bool operator==(state_data const& lhs,state_data const& rhs)
             {
-                return *reinterpret_cast<unsigned long const*>(&lhs)==*reinterpret_cast<unsigned long const*>(&rhs);
+                return std::memcmp(&lhs, &rhs, sizeof(lhs)) == 0;
             }
         };
 
-        state_data interlocked_compare_exchange(state_data* target, state_data new_value, state_data comparand)
+        static state_data interlocked_compare_exchange(state_data* target, state_data new_value, state_data comparand)
         {
+            BOOST_STATIC_ASSERT(sizeof(state_data) == sizeof(long));
+            long new_val, comp;
+            std::memcpy(&new_val, &new_value, sizeof(new_value));
+            std::memcpy(&comp, &comparand, sizeof(comparand));
             long const res=BOOST_INTERLOCKED_COMPARE_EXCHANGE(reinterpret_cast<long*>(target),
-                                                              *reinterpret_cast<long*>(&new_value),
-                                                              *reinterpret_cast<long*>(&comparand));
-            return *reinterpret_cast<state_data const*>(&res);
+                                                              new_val,
+                                                              comp);
+            state_data result;
+            std::memcpy(&result, &res, sizeof(result));
+            return result;
         }
 
         enum

include/boost/thread/win32/thread_data.hpp

@@ -80,12 +80,15 @@ namespace boost
         struct thread_exit_callback_node;
         struct tss_data_node
         {
-            boost::shared_ptr<boost::detail::tss_cleanup_function> func;
+            typedef void(*cleanup_func_t)(void*);
+            typedef void(*cleanup_caller_t)(cleanup_func_t, void*);
+
+            cleanup_caller_t caller;
+            cleanup_func_t func;
             void* value;
 
-            tss_data_node(boost::shared_ptr<boost::detail::tss_cleanup_function> func_,
-                          void* value_):
-                func(func_),value(value_)
+            tss_data_node(cleanup_caller_t caller_,cleanup_func_t func_,void* value_):
+                caller(caller_),func(func_),value(value_)
             {}
         };
 
@@ -113,8 +116,10 @@ namespace boost
             > notify_list_t;
             notify_list_t notify;
 
+//#ifndef BOOST_NO_EXCEPTIONS
             typedef std::vector<shared_ptr<shared_state_base> > async_states_t;
             async_states_t async_states_;
+//#endif
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             // These data must be at the end so that the access to the other fields doesn't change
             // when BOOST_THREAD_PROVIDES_INTERRUPTIONS is defined
@@ -129,8 +134,10 @@ namespace boost
                 thread_exit_callbacks(0),
                 id(0),
                 tss_data(),
-                notify(),
-                async_states_()
+                notify()
+//#ifndef BOOST_NO_EXCEPTIONS
+                , async_states_()
+//#endif
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 , interruption_handle(create_anonymous_event(detail::win32::manual_reset_event,detail::win32::event_initially_reset))
                 , interruption_enabled(true)
@@ -166,11 +173,12 @@ namespace boost
               notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
             }
 
+//#ifndef BOOST_NO_EXCEPTIONS
             void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
             {
               async_states_.push_back(as);
             }
-
+//#endif
         };
         BOOST_THREAD_DECL thread_data_base* get_current_thread_data();
 
@@ -185,7 +193,7 @@ namespace boost
 
 #if defined BOOST_THREAD_USES_DATETIME
         template<typename TimeDuration>
-        inline BOOST_SYMBOL_VISIBLE void sleep(TimeDuration const& rel_time)
+        BOOST_SYMBOL_VISIBLE void sleep(TimeDuration const& rel_time)
         {
           interruptible_wait(detail::win32::invalid_handle_value, detail::internal_platform_clock::now() + detail::platform_duration(rel_time));
         }
@@ -205,19 +213,19 @@ namespace boost
 
 #ifdef BOOST_THREAD_USES_CHRONO
         template <class Rep, class Period>
-        inline void sleep_for(const chrono::duration<Rep, Period>& d)
+        void sleep_for(const chrono::duration<Rep, Period>& d)
         {
           interruptible_wait(detail::win32::invalid_handle_value, detail::internal_platform_clock::now() + detail::platform_duration(d));
         }
 
         template <class Duration>
-        inline void sleep_until(const chrono::time_point<chrono::steady_clock, Duration>& t)
+        void sleep_until(const chrono::time_point<chrono::steady_clock, Duration>& t)
         {
           sleep_for(t - chrono::steady_clock::now());
         }
 
         template <class Clock, class Duration>
-        inline void sleep_until(const chrono::time_point<Clock, Duration>& t)
+        void sleep_until(const chrono::time_point<Clock, Duration>& t)
         {
           typedef typename common_type<Duration, typename Clock::duration>::type common_duration;
           common_duration d(t - Clock::now());
@@ -236,7 +244,7 @@ namespace boost
 
 #if defined BOOST_THREAD_USES_DATETIME
           template<typename TimeDuration>
-          inline BOOST_SYMBOL_VISIBLE void sleep(TimeDuration const& rel_time)
+          BOOST_SYMBOL_VISIBLE void sleep(TimeDuration const& rel_time)
           {
             non_interruptible_wait(detail::win32::invalid_handle_value, detail::internal_platform_clock::now() + detail::platform_duration(rel_time));
           }
@@ -256,19 +264,19 @@ namespace boost
 
 #ifdef BOOST_THREAD_USES_CHRONO
           template <class Rep, class Period>
-          inline void sleep_for(const chrono::duration<Rep, Period>& d)
+          void sleep_for(const chrono::duration<Rep, Period>& d)
           {
             non_interruptible_wait(detail::win32::invalid_handle_value, detail::internal_platform_clock::now() + detail::platform_duration(d));
           }
 
           template <class Duration>
-          inline void sleep_until(const chrono::time_point<chrono::steady_clock, Duration>& t)
+          void sleep_until(const chrono::time_point<chrono::steady_clock, Duration>& t)
           {
             sleep_for(t - chrono::steady_clock::now());
           }
 
           template <class Clock, class Duration>
-          inline void sleep_until(const chrono::time_point<Clock, Duration>& t)
+          void sleep_until(const chrono::time_point<Clock, Duration>& t)
           {
             typedef typename common_type<Duration, typename Clock::duration>::type common_duration;
             common_duration d(t - Clock::now());

include/boost/thread/win32/thread_primitives.hpp

@@ -18,10 +18,9 @@
 #include <boost/detail/interlocked.hpp>
 
 #include <boost/winapi/config.hpp>
+#include <boost/winapi/basic_types.hpp>
 #include <boost/winapi/semaphore.hpp>
-#include <boost/winapi/dll.hpp>
 #include <boost/winapi/system.hpp>
-#include <boost/winapi/time.hpp>
 #include <boost/winapi/event.hpp>
 #include <boost/winapi/thread.hpp>
 #include <boost/winapi/get_current_thread.hpp>
@@ -48,8 +47,7 @@ namespace boost
         {
             typedef ::boost::winapi::HANDLE_ handle;
             typedef ::boost::winapi::SYSTEM_INFO_ system_info;
-            typedef unsigned __int64 ticks_type;
-            typedef ::boost::winapi::FARPROC_ farproc_t;
+            typedef ::boost::winapi::ULONGLONG_ ticks_type;
             unsigned const infinite=::boost::winapi::INFINITE_;
             unsigned const timeout=::boost::winapi::WAIT_TIMEOUT_;
             handle const invalid_handle_value=::boost::winapi::INVALID_HANDLE_VALUE_;
@@ -72,96 +70,8 @@ namespace boost
     {
         namespace win32
         {
-            namespace detail { typedef ticks_type (__stdcall *gettickcount64_t)(); }
-#if !BOOST_PLAT_WINDOWS_RUNTIME
-            extern "C"
-            {
-#ifdef _MSC_VER
-                long _InterlockedCompareExchange(long volatile *, long, long);
-#pragma intrinsic(_InterlockedCompareExchange)
-#elif defined(__MINGW64_VERSION_MAJOR)
-                long _InterlockedCompareExchange(long volatile *, long, long);
-#else
-                // Mingw doesn't provide intrinsics
-#define _InterlockedCompareExchange InterlockedCompareExchange
-#endif
-            }
-            // Borrowed from https://stackoverflow.com/questions/8211820/userland-interrupt-timer-access-such-as-via-kequeryinterrupttime-or-similar
-            inline ticks_type __stdcall GetTickCount64emulation()
-            {
-                static long count = -1l;
-                unsigned long previous_count, current_tick32, previous_count_zone, current_tick32_zone;
-                ticks_type current_tick64;
-
-                previous_count = (unsigned long) boost::detail::interlocked_read_acquire(&count);
-                current_tick32 = ::boost::winapi::GetTickCount();
-
-                if(previous_count == (unsigned long)-1l)
-                {
-                    // count has never been written
-                    unsigned long initial_count;
-                    initial_count = current_tick32 >> 28;
-                    previous_count = (unsigned long) _InterlockedCompareExchange(&count, (long)initial_count, -1l);
-
-                    current_tick64 = initial_count;
-                    current_tick64 <<= 28;
-                    current_tick64 += current_tick32 & 0x0FFFFFFF;
-                    return current_tick64;
-                }
-
-                previous_count_zone = previous_count & 15;
-                current_tick32_zone = current_tick32 >> 28;
-
-                if(current_tick32_zone == previous_count_zone)
-                {
-                    // The top four bits of the 32-bit tick count haven't changed since count was last written.
-                    current_tick64 = previous_count;
-                    current_tick64 <<= 28;
-                    current_tick64 += current_tick32 & 0x0FFFFFFF;
-                    return current_tick64;
-                }
-
-                if(current_tick32_zone == previous_count_zone + 1 || (current_tick32_zone == 0 && previous_count_zone == 15))
-                {
-                    // The top four bits of the 32-bit tick count have been incremented since count was last written.
-                    unsigned long new_count = previous_count + 1;
-                    _InterlockedCompareExchange(&count, (long)new_count, (long)previous_count);
-                    current_tick64 = new_count;
-                    current_tick64 <<= 28;
-                    current_tick64 += current_tick32 & 0x0FFFFFFF;
-                    return current_tick64;
-                }
-
-                // Oops, we weren't called often enough, we're stuck
-                return 0xFFFFFFFF;
-            }
-#else
-#endif
-            inline detail::gettickcount64_t GetTickCount64_()
-            {
-                static detail::gettickcount64_t gettickcount64impl;
-                if(gettickcount64impl)
-                    return gettickcount64impl;
-
-                // 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::winapi::GetTickCount64;
-#else
-                farproc_t addr=GetProcAddress(
-#if !defined(BOOST_NO_ANSI_APIS)
-                    ::boost::winapi::GetModuleHandleA("KERNEL32.DLL"),
-#else
-                    ::boost::winapi::GetModuleHandleW(L"KERNEL32.DLL"),
-#endif
-                    "GetTickCount64");
-                if(addr)
-                    gettickcount64impl=(detail::gettickcount64_t) addr;
-                else
-                    gettickcount64impl=&GetTickCount64emulation;
-#endif
-                return gettickcount64impl;
-            }
+            namespace detail { typedef ticks_type (BOOST_WINAPI_WINAPI_CC *gettickcount64_t)(); }
+            extern BOOST_THREAD_DECL boost::detail::win32::detail::gettickcount64_t gettickcount64;
 
             enum event_type
             {

include/boost/thread/xtime.hpp

@@ -57,17 +57,17 @@ struct xtime
 
 };
 
-inline xtime get_xtime(boost::system_time const& abs_time)
+inline ::boost::xtime get_xtime(boost::system_time const& abs_time)
 {
-    xtime res;
+    ::boost::xtime res;
     boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);
 
-    res.sec=static_cast<xtime::xtime_sec_t>(time_since_epoch.total_seconds());
-    res.nsec=static_cast<xtime::xtime_nsec_t>(time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second()));
+    res.sec=static_cast< ::boost::xtime::xtime_sec_t>(time_since_epoch.total_seconds());
+    res.nsec=static_cast< ::boost::xtime::xtime_nsec_t>(time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second()));
     return res;
 }
 
-inline int xtime_get(struct xtime* xtp, int clock_type)
+inline int xtime_get(struct ::boost::xtime* xtp, int clock_type)
 {
     if (clock_type == TIME_UTC_)
     {
@@ -78,7 +78,7 @@ inline int xtime_get(struct xtime* xtp, int clock_type)
 }
 
 
-inline int xtime_cmp(const xtime& xt1, const xtime& xt2)
+inline int xtime_cmp(const ::boost::xtime& xt1, const ::boost::xtime& xt2)
 {
     if (xt1.sec == xt2.sec)
         return (int)(xt1.nsec - xt2.nsec);

meta/libraries.json

@@ -7,11 +7,10 @@
       "Vicente J. Botet Escriba"
     ],
     "maintainers": [
-      "Vicente J. Botet Escriba <vicente.botet -at- wanadoo.fr>",
-      "Niall Douglas <niall -at- nedprod.com>"
+      "Vicente J. Botet Escriba <vicente.botet -at- wanadoo.fr>"
     ],
     "description":
-      "Portable C++ multi-threading. C++11, C++14.",
+      "Portable C++ multi-threading. C++03, C++11, C++14, C++17.",
     "std": [ "proposal" ],    
     "category": [
       "Concurrent", "System"

src/future.cpp

@@ -4,8 +4,8 @@
 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/thread/detail/config.hpp>
-#ifndef BOOST_NO_EXCEPTIONS
 
+#ifndef BOOST_NO_EXCEPTIONS
 
 #include <boost/thread/futures/future_error_code.hpp>
 #include <string>

src/pthread/thread.cpp

@@ -27,9 +27,9 @@
 #include <unistd.h>
 #endif
 
-#if defined(__VXWORKS__) 
+#if defined(__VXWORKS__)
 #include <vxCpuLib.h>
-#endif 
+#endif
 
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/trim.hpp>
@@ -53,11 +53,13 @@ namespace boost
                 i->second->unlock();
                 i->first->notify_all();
             }
+//#ifndef BOOST_NO_EXCEPTIONS
             for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                     i != e; ++i)
             {
                 (*i)->notify_deferred();
             }
+//#endif
         }
 
         struct thread_exit_callback_node
@@ -109,7 +111,7 @@ namespace boost
                                     = thread_info->tss_data.begin();
                                 if(current->second.func && (current->second.value!=0))
                                 {
-                                    (*current->second.func)(current->second.value);
+                                    (*current->second.caller)(current->second.func,current->second.value);
                                 }
                                 thread_info->tss_data.erase(current);
                             }
@@ -147,7 +149,7 @@ namespace boost
 
         boost::detail::thread_data_base* get_current_thread_data()
         {
-            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
+            boost::call_once(current_thread_tls_init_flag,&create_current_thread_tls_key);
             return (boost::detail::thread_data_base*)pthread_getspecific(current_thread_tls_key);
         }
 
@@ -213,8 +215,10 @@ namespace boost
             ~externally_launched_thread() {
               BOOST_ASSERT(notify.empty());
               notify.clear();
+//#ifndef BOOST_NO_EXCEPTIONS
               BOOST_ASSERT(async_states_.empty());
               async_states_.clear();
+//#endif
             }
             void run()
             {}
@@ -466,7 +470,7 @@ namespace boost
 #   elif defined(BOOST_HAS_PTHREAD_YIELD)
             BOOST_VERIFY(!pthread_yield());
 //#   elif defined BOOST_THREAD_USES_DATETIME
-//            xtime xt;
+//            ::boost::xtime xt;
 //            xtime_get(&xt, TIME_UTC_);
 //            sleep(xt);
 //            sleep_for(chrono::milliseconds(0));
@@ -474,7 +478,7 @@ namespace boost
             mutex mx;
             unique_lock<mutex> lock(mx);
             condition_variable cond;
-            cond.do_wait_until(lock, detail::internal_platform_clock::now())
+            cond.do_wait_until(lock, detail::internal_platform_clock::now());
 #   endif
         }
     }
@@ -498,9 +502,9 @@ namespace boost
            set &= set -1;
         }
         return(i);
-  #else  
+  #else
         return (__builtin_popcount(set) );
-  #endif  
+  #endif
 #elif defined(__GLIBC__)
         return get_nprocs();
 #else
@@ -722,11 +726,12 @@ namespace boost
         }
 
         void add_new_tss_node(void const* key,
-                              boost::shared_ptr<tss_cleanup_function> func,
+                              detail::tss_data_node::cleanup_caller_t caller,
+                              detail::tss_data_node::cleanup_func_t func,
                               void* tss_data)
         {
             detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
-            current_thread_data->tss_data.insert(std::make_pair(key,tss_data_node(func,tss_data)));
+            current_thread_data->tss_data.insert(std::make_pair(key,tss_data_node(caller,func,tss_data)));
         }
 
         void erase_tss_node(void const* key)
@@ -739,17 +744,19 @@ namespace boost
         }
 
         void set_tss_data(void const* key,
-                          boost::shared_ptr<tss_cleanup_function> func,
+                          detail::tss_data_node::cleanup_caller_t caller,
+                          detail::tss_data_node::cleanup_func_t func,
                           void* tss_data,bool cleanup_existing)
         {
             if(tss_data_node* const current_node=find_tss_data(key))
             {
                 if(cleanup_existing && current_node->func && (current_node->value!=0))
                 {
-                    (*current_node->func)(current_node->value);
+                    (*current_node->caller)(current_node->func,current_node->value);
                 }
                 if(func || (tss_data!=0))
                 {
+                    current_node->caller=caller;
                     current_node->func=func;
                     current_node->value=tss_data;
                 }
@@ -760,7 +767,7 @@ namespace boost
             }
             else if(func || (tss_data!=0))
             {
-                add_new_tss_node(key,func,tss_data);
+                add_new_tss_node(key,caller,func,tss_data);
             }
         }
     }
@@ -773,6 +780,8 @@ namespace boost
         current_thread_data->notify_all_at_thread_exit(&cond, lk.release());
       }
     }
+
+//#ifndef BOOST_NO_EXCEPTIONS
 namespace detail {
 
     void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
@@ -784,7 +793,7 @@ namespace detail {
       }
     }
 }
-
+//#endif
 
 
 }

src/tss_null.cpp

@@ -6,7 +6,7 @@
 
 #include <boost/thread/detail/config.hpp>
 
-#if defined(BOOST_HAS_WINTHREADS) && (defined(BOOST_THREAD_BUILD_LIB) || defined(BOOST_THREAD_TEST) || defined(UNDER_CE)) && (!defined(_MSC_VER) || defined(UNDER_CE))
+#if defined(BOOST_THREAD_WIN32) && (defined(BOOST_THREAD_BUILD_LIB) || defined(BOOST_THREAD_TEST) || defined(UNDER_CE)) && (!defined(_MSC_VER) || defined(UNDER_CE))
 
 namespace boost
 {
@@ -35,4 +35,4 @@ namespace boost
 
 }
 
-#endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB) && !defined(_MSC_VER)
+#endif //defined(BOOST_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_LIB) && !defined(_MSC_VER)

src/win32/thread.cpp

@@ -54,11 +54,13 @@ namespace boost
             i->second->unlock();
             i->first->notify_all();
         }
+//#ifndef BOOST_NO_EXCEPTIONS
         for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                 i != e; ++i)
         {
             (*i)->notify_deferred();
         }
+//#endif
     }
   }
 
@@ -274,7 +276,7 @@ namespace boost
                             = current_thread_data->tss_data.begin();
                         if(current->second.func && (current->second.value!=0))
                         {
-                            (*current->second.func)(current->second.value);
+                            (*current->second.caller)(current->second.func,current->second.value);
                         }
                         current_thread_data->tss_data.erase(current);
                     }
@@ -370,8 +372,10 @@ namespace boost
             ~externally_launched_thread() {
               BOOST_ASSERT(notify.empty());
               notify.clear();
+//#ifndef BOOST_NO_EXCEPTIONS
               BOOST_ASSERT(async_states_.empty());
               async_states_.clear();
+//#endif
             }
 
             void run()
@@ -518,12 +522,12 @@ namespace boost
         GetLogicalProcessorInformation(NULL, &size);
         if (ERROR_INSUFFICIENT_BUFFER != GetLastError())
             return 0;
+        const size_t Elements = size / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
 
-        std::vector<SYSTEM_LOGICAL_PROCESSOR_INFORMATION> buffer(size);
+        std::vector<SYSTEM_LOGICAL_PROCESSOR_INFORMATION> buffer(Elements);
         if (GetLogicalProcessorInformation(&buffer.front(), &size) == FALSE)
             return 0;
 
-        const size_t Elements = size / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
 
         for (size_t i = 0; i < Elements; ++i) {
             if (buffer[i].Relationship == RelationProcessorCore)
@@ -905,11 +909,12 @@ namespace boost
         }
 
         void add_new_tss_node(void const* key,
-                              boost::shared_ptr<tss_cleanup_function> func,
+                              detail::tss_data_node::cleanup_caller_t caller,
+                              detail::tss_data_node::cleanup_func_t func,
                               void* tss_data)
         {
             detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
-            current_thread_data->tss_data.insert(std::make_pair(key,tss_data_node(func,tss_data)));
+            current_thread_data->tss_data.insert(std::make_pair(key,tss_data_node(caller,func,tss_data)));
         }
 
         void erase_tss_node(void const* key)
@@ -919,17 +924,19 @@ namespace boost
         }
 
         void set_tss_data(void const* key,
-                          boost::shared_ptr<tss_cleanup_function> func,
+                          detail::tss_data_node::cleanup_caller_t caller,
+                          detail::tss_data_node::cleanup_func_t func,
                           void* tss_data,bool cleanup_existing)
         {
             if(tss_data_node* const current_node=find_tss_data(key))
             {
                 if(cleanup_existing && current_node->func && (current_node->value!=0))
                 {
-                    (*current_node->func)(current_node->value);
+                    (*current_node->caller)(current_node->func,current_node->value);
                 }
                 if(func || (tss_data!=0))
                 {
+                    current_node->caller=caller;
                     current_node->func=func;
                     current_node->value=tss_data;
                 }
@@ -940,7 +947,7 @@ namespace boost
             }
             else if(func || (tss_data!=0))
             {
-                add_new_tss_node(key,func,tss_data);
+                add_new_tss_node(key,caller,func,tss_data);
             }
         }
     }

src/win32/thread_primitives.cpp

@@ -0,0 +1,156 @@
+//  thread_primitives.cpp
+//
+//  (C) Copyright 2018 Andrey Semashev
+//
+//  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)
+
+#include <boost/winapi/config.hpp>
+#include <boost/winapi/dll.hpp>
+#include <boost/winapi/time.hpp>
+#include <boost/winapi/event.hpp>
+#include <boost/winapi/handles.hpp>
+#include <boost/winapi/thread_pool.hpp>
+#include <cstdlib>
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/memory_order.hpp>
+#include <boost/atomic/atomic.hpp>
+#include <boost/thread/win32/interlocked_read.hpp>
+#include <boost/thread/win32/thread_primitives.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+
+#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
+
+// Directly use API from Vista and later
+BOOST_THREAD_DECL boost::detail::win32::detail::gettickcount64_t gettickcount64 = &::boost::winapi::GetTickCount64;
+
+#else // BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
+
+namespace {
+
+enum init_state
+{
+    uninitialized = 0,
+    in_progress,
+    initialized
+};
+
+struct get_tick_count64_state
+{
+    boost::atomic< uint64_t > ticks;
+    boost::atomic< init_state > init;
+    boost::winapi::HANDLE_ wait_event;
+    boost::winapi::HANDLE_ wait_handle;
+};
+
+// Zero-initialized initially
+BOOST_ALIGNMENT(64) static get_tick_count64_state g_state;
+
+//! Artifical implementation of GetTickCount64
+ticks_type WINAPI get_tick_count64()
+{
+    uint64_t old_state = g_state.ticks.load(boost::memory_order_acquire);
+
+    uint32_t new_ticks = boost::winapi::GetTickCount();
+
+    uint32_t old_ticks = static_cast< uint32_t >(old_state & UINT64_C(0x00000000ffffffff));
+    uint64_t new_state = ((old_state & UINT64_C(0xffffffff00000000)) + (static_cast< uint64_t >(new_ticks < old_ticks) << 32)) | static_cast< uint64_t >(new_ticks);
+
+    g_state.ticks.store(new_state, boost::memory_order_release);
+
+    return new_state;
+}
+
+//! The function is called periodically in the system thread pool to make sure g_state.ticks is timely updated
+void NTAPI refresh_get_tick_count64(boost::winapi::PVOID_, boost::winapi::BOOLEAN_)
+{
+    get_tick_count64();
+}
+
+//! Cleanup function to stop get_tick_count64 refreshes
+void cleanup_get_tick_count64()
+{
+    if (g_state.wait_handle)
+    {
+        boost::winapi::UnregisterWait(g_state.wait_handle);
+        g_state.wait_handle = NULL;
+    }
+
+    if (g_state.wait_event)
+    {
+        boost::winapi::CloseHandle(g_state.wait_event);
+        g_state.wait_event = NULL;
+    }
+}
+
+ticks_type WINAPI get_tick_count_init()
+{
+    boost::winapi::HMODULE_ hKernel32 = boost::winapi::GetModuleHandleW(L"kernel32.dll");
+    if (hKernel32)
+    {
+      // GetProcAddress returns a pointer to some function. It can return
+      // pointers to different functions, so it has to return something that is
+      // suitable to store any pointer to function. Microsoft chose FARPROC,
+      // which is int (WINAPI *)() on 32-bit Windows. The user is supposed to
+      // know the signature of the function he requests and perform a cast
+      // (which is a nop on this platform). The result is a pointer to function
+      // with the required signature, which is bitwise equal to what
+      // GetProcAddress returned.
+      // However, gcc >= 8 warns about that.
+#if defined(BOOST_GCC) && BOOST_GCC >= 80000
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-function-type"
+#endif
+        boost::detail::win32::detail::gettickcount64_t p =
+            (boost::detail::win32::detail::gettickcount64_t)boost::winapi::get_proc_address(hKernel32, "GetTickCount64");
+#if defined(BOOST_GCC) && BOOST_GCC >= 80000
+#pragma GCC diagnostic pop
+#endif
+        if (p)
+        {
+            // Use native API
+            boost::detail::interlocked_write_release((void**)&gettickcount64, (void*)p);
+            return p();
+        }
+    }
+
+    // No native API available. Use emulation with periodic refreshes to make sure the GetTickCount wrap arounds are properly counted.
+    init_state old_init = uninitialized;
+    if (g_state.init.compare_exchange_strong(old_init, in_progress, boost::memory_order_acq_rel, boost::memory_order_relaxed))
+    {
+        if (!g_state.wait_event)
+            g_state.wait_event = boost::winapi::create_anonymous_event(NULL, false, false);
+        if (g_state.wait_event)
+        {
+            boost::winapi::BOOL_ res = boost::winapi::RegisterWaitForSingleObject(&g_state.wait_handle, g_state.wait_event, &refresh_get_tick_count64, NULL, 0x7fffffff, boost::winapi::WT_EXECUTEINWAITTHREAD_);
+            if (res)
+            {
+                std::atexit(&cleanup_get_tick_count64);
+
+                boost::detail::interlocked_write_release((void**)&gettickcount64, (void*)&get_tick_count64);
+                g_state.init.store(initialized, boost::memory_order_release);
+                goto finish;
+            }
+        }
+
+        g_state.init.store(uninitialized, boost::memory_order_release);
+    }
+
+finish:
+    return get_tick_count64();
+}
+
+} // namespace
+
+BOOST_THREAD_DECL boost::detail::win32::detail::gettickcount64_t gettickcount64 = &get_tick_count_init;
+
+#endif // BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
+
+} // namespace win32
+} // namespace detail
+} // namespace boost

src/win32/tss_dll.cpp

@@ -7,7 +7,7 @@
 #include <boost/thread/detail/config.hpp>
 
 
-#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_DLL)
+#if defined(BOOST_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_DLL)
 
     #include <boost/thread/detail/tss_hooks.hpp>
 
@@ -73,7 +73,7 @@ namespace boost
     }
 }
 
-#else //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_DLL)
+#else //defined(BOOST_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_DLL)
 
 #ifdef _MSC_VER
 // Prevent LNK4221 warning with link=static
@@ -82,4 +82,4 @@ namespace boost { namespace link_static_warning_inhibit {
 } }
 #endif
 
-#endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_DLL)
+#endif //defined(BOOST_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_DLL)

src/win32/tss_pe.cpp

@@ -10,7 +10,7 @@
 #include <boost/winapi/config.hpp>
 #include <boost/thread/detail/config.hpp>
 
-#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB)
+#if defined(BOOST_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_LIB)
 
 #if (defined(__MINGW32__) && !defined(_WIN64)) || defined(__MINGW64__) || (__MINGW64_VERSION_MAJOR)
 
@@ -334,4 +334,4 @@ namespace boost
 
 #endif //defined(_MSC_VER) && !defined(UNDER_CE)
 
-#endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB)
+#endif //defined(BOOST_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_LIB)

test/Jamfile.v2

@@ -18,6 +18,9 @@
 
 # bring in rules for testing
 import testing ;
+import regex ;
+import path ;
+import os ;
 
 project
     : requirements
@@ -180,7 +183,6 @@ rule thread-run2-h ( sources : name )
     sources = $(sources) winrt_init.cpp ;
     return
     [ run $(sources) : : :
-      <library>/boost/system//boost_system
       <define>BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
       <define>BOOST_THREAD_VERSION=3
     : $(name)_h ]
@@ -208,6 +210,36 @@ rule thread-compile-fail ( sources : reqs * : name )
     ;
 }
 
+rule clang-thread-safety ( properties * )
+{
+    if <toolset>clang in $(properties)
+    {
+        return <cxxflags>-Werror=thread-safety  <define>BOOST_THREAD_ENABLE_THREAD_SAFETY_ANALYSIS ;
+    }
+    else
+    {
+        return <build>no ;
+    }
+}
+
+rule thread-safety-compile ( sources : reqs * : name )
+{
+    return
+    [ compile $(sources)
+        : $(reqs) <conditional>@clang-thread-safety
+        : $(name) ]
+    ;
+}
+
+rule thread-safety-compile-fail ( sources : reqs * : name )
+{
+    return
+    [ compile-fail $(sources)
+        : $(reqs) <conditional>@clang-thread-safety
+        : $(name) ]
+    ;
+}
+
 rule thread-compile ( sources : reqs * : name )
 {
     return
@@ -217,6 +249,42 @@ rule thread-compile ( sources : reqs * : name )
     ;
 }
 
+rule windows-cygwin-specific ( properties * )
+{
+    if <target-os>windows in $(properties) || <target-os>cygwin in $(properties)
+    {
+        return <build>yes ;
+    }
+    else
+    {
+        return <build>no ;
+    }
+}
+
+rule generate_self_contained_header_tests
+{
+    local all_rules ;
+    local file ;
+
+    if ! [ os.environ BOOST_THREAD_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS ]
+    {
+        local headers_path = [ path.make $(BOOST_ROOT)/libs/thread/include/boost/thread ] ;
+        for file in [ path.glob-tree $(headers_path) : *.hpp : detail pthread win32 ]
+        {
+            local rel_file = [ path.relative-to $(headers_path) $(file) ] ;
+            # Note: The test name starts with '~' in order to group these tests in the test report table, preferably at the end.
+            #       All '/' are replaced with '-' because apparently test scripts have a problem with test names containing slashes.
+            local test_name = [ regex.replace ~hdr/$(rel_file) "/" "-" ] ;
+            #ECHO $(rel_file) ;
+            all_rules += [ compile self_contained_header.cpp : <define>"BOOST_THREAD_TEST_HEADER=$(rel_file)" <dependency>$(file) : $(test_name) ] ;
+            all_rules += [ compile self_contained_header.cpp : <define>"BOOST_THREAD_TEST_HEADER=$(rel_file)" <define>"BOOST_THREAD_TEST_POST_WINDOWS_H" <dependency>$(file) <conditional>@windows-cygwin-specific : $(test_name)-post_winh ] ;
+        }
+    }
+
+    #ECHO All rules: $(all_rules) ;
+    return $(all_rules) ;
+}
+
 {
     test-suite t_threads
     :
@@ -266,8 +334,8 @@ rule thread-compile ( sources : reqs * : name )
           #[ thread-test test_vhh_shared_mutex_timed_locks.cpp ]
     ;
 
-    #explicit t_futures ;
-    test-suite t_futures
+    explicit t_futures_too_long ;
+    test-suite t_futures_too_long
     :
           [ thread-test test_futures.cpp ]
     ;
@@ -461,6 +529,10 @@ rule thread-compile ( sources : reqs * : name )
     :
           [ thread-compile-fail ./sync/mutual_exclusion/locks/lock_guard/copy_assign_fail.cpp : : lock_guard__cons__copy_assign_f ]
           [ thread-compile-fail ./sync/mutual_exclusion/locks/lock_guard/copy_ctor_fail.cpp : : lock_guard__cons__copy_ctor_f ]
+          [ thread-safety-compile ./sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_pass.cpp : : lock_guard__lock_compile_p ]
+          [ thread-safety-compile-fail ./sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_fail.cpp : : lock_guard__lock_compile_f ]
+          [ thread-safety-compile ./sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_pass.cpp : : lock_guard__adopt_lock_compile_p ]
+          [ thread-safety-compile-fail ./sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_fail.cpp : : lock_guard__adopt_lock_compile_f ]
           [ thread-run2-noit ./sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp : lock_guard__cons__adopt_lock_p ]
           [ thread-run2-noit ./sync/mutual_exclusion/locks/lock_guard/default_pass.cpp : lock_guard__cons__default_p ]
           [ thread-run2-noit ./sync/mutual_exclusion/locks/lock_guard/types_pass.cpp : lock_guard__types_p ]
@@ -615,6 +687,12 @@ rule thread-compile ( sources : reqs * : name )
     :
           [ thread-compile-fail ./sync/mutual_exclusion/mutex/assign_fail.cpp : : mutex__assign_f ]
           [ thread-compile-fail ./sync/mutual_exclusion/mutex/copy_fail.cpp : : mutex__copy_f ]
+          [ thread-safety-compile ./sync/mutual_exclusion/mutex/lock_compile_pass.cpp : : mutex__lock_compile_p ]
+          [ thread-safety-compile-fail ./sync/mutual_exclusion/mutex/lock_compile_fail.cpp : : mutex__lock_compile_f ]
+          # https://bugs.llvm.org/show_bug.cgi?id=32954
+          # http://clang-developers.42468.n3.nabble.com/thread-safety-warnings-specifically-try-acquire-capability-td4059337.html
+          #[ thread-safety-compile ./sync/mutual_exclusion/mutex/try_lock_compile_pass.cpp : : mutex__try_lock_compile_p ]
+          [ thread-safety-compile-fail ./sync/mutual_exclusion/mutex/try_lock_compile_fail.cpp : : mutex__try_lock_compile_f ]
           [ thread-run2-noit ./sync/mutual_exclusion/mutex/default_pass.cpp : mutex__default_p ]
           [ thread-run2-noit ./sync/mutual_exclusion/mutex/lock_pass.cpp : mutex__lock_p ]
           [ thread-run2-noit-pthread ./sync/mutual_exclusion/mutex/native_handle_pass.cpp : mutex__native_handle_p ]
@@ -775,6 +853,12 @@ rule thread-compile ( sources : reqs * : name )
           [ thread-run2-noit ./threads/container/thread_ptr_list_pass.cpp : container__thread_ptr_list_p ]
     ;
 
+    explicit ts_examples_too_long ;
+    test-suite ts_examples_too_long
+    :
+          [ thread-run2 ../example/shared_mutex.cpp : ex_shared_mutex ]
+    ;
+
     #explicit ts_examples ;
     test-suite ts_examples
     :
@@ -790,7 +874,6 @@ rule thread-compile ( sources : reqs * : name )
           [ thread-run2-noit ../example/tss.cpp : ex_tss ]
           [ thread-run2 ../example/xtime.cpp : ex_xtime ]
           [ thread-run2 ../example/shared_monitor.cpp : ex_shared_monitor ]
-          [ thread-run2 ../example/shared_mutex.cpp : ex_shared_mutex ]
           #[ thread-run ../example/vhh_shared_monitor.cpp ]
           #[ thread-run ../example/vhh_shared_mutex.cpp ]
           [ thread-run2 ../example/make_future.cpp : ex_make_future ]
@@ -970,7 +1053,9 @@ rule thread-compile ( sources : reqs * : name )
           #[ thread-run test_11818.cpp ]
           #[ thread-run test_11796.cpp ]
           #[ thread-run test_12293.cpp ]
-          [ thread-run test_12949.cpp ]
+          #[ thread-run test_12949.cpp ]
+          #[ thread-run test_13480b.cpp ]
+          [ thread-run test_13561.cpp ]
           
     ;
 
@@ -1009,4 +1094,5 @@ rule thread-compile ( sources : reqs * : name )
           [ exe test_time_jumps_3 : test_time_jumps_3_obj ../build//boost_thread ]
     ;
 
+    test-suite test_self_contained_headers : [ generate_self_contained_header_tests ] ;
 }

test/self_contained_header.cpp

@@ -0,0 +1,26 @@
+/*
+ *             Copyright Andrey Semashev 2019.
+ * 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)
+ */
+/*!
+ * \file   self_contained_header.cpp
+ * \author Andrey Semashev
+ * \date   2019-01-19
+ *
+ * \brief  This file contains a test boilerplate for checking that every public header is self-contained and does not have any missing #includes.
+ */
+
+#if defined(BOOST_THREAD_TEST_POST_WINDOWS_H)
+#include <windows.h>
+#endif
+
+#define BOOST_THREAD_TEST_INCLUDE_HEADER() <boost/thread/BOOST_THREAD_TEST_HEADER>
+
+#include BOOST_THREAD_TEST_INCLUDE_HEADER()
+
+int main(int, char*[])
+{
+    return 0;
+}

test/sync/conditions/condition_variable/lost_notif_pass.cpp

@@ -237,5 +237,5 @@ int main()
     test_chrono_wait_function(wait_for_with_pred);
 #endif
 
-    return 0;
+    return boost::report_errors();
 }

test/sync/conditions/condition_variable/wait_for_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <cassert>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -37,12 +38,10 @@ int runs = 0;
 typedef boost::chrono::steady_clock Clock;
 typedef boost::chrono::milliseconds milliseconds;
 typedef boost::chrono::nanoseconds nanoseconds;
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const milliseconds max_diff(250);
-#else
-const milliseconds max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {

test/sync/conditions/condition_variable/wait_for_pred_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <cassert>
 #include <iostream>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -51,12 +52,10 @@ int runs = 0;
 
 typedef boost::chrono::system_clock Clock;
 typedef boost::chrono::milliseconds milliseconds;
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const milliseconds max_diff(250);
-#else
-const milliseconds max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {

test/sync/conditions/condition_variable/wait_until_pass.cpp

@@ -23,9 +23,11 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <cassert>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
-
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 struct Clock
 {
   typedef boost::chrono::milliseconds duration;
@@ -44,16 +46,13 @@ struct Clock
 boost::condition_variable cv;
 boost::mutex mut;
 
+
 int test1 = 0;
 int test2 = 0;
 
 int runs = 0;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const Clock::duration max_diff(250);
-#else
-const Clock::duration max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -68,12 +67,14 @@ void f()
     Clock::time_point t1 = Clock::now();
     if (runs == 0)
     {
-      assert(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
       assert(test2 != 0);
     }
     else
     {
-      assert(t1 - t0 - Clock::duration(250) < max_diff);
+      ns d = t1 - t0 - Clock::duration(250);
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
       assert(test2 == 0);
     }
     ++runs;

test/sync/conditions/condition_variable/wait_until_pred_pass.cpp

@@ -23,11 +23,13 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <cassert>
 #include <iostream>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::milliseconds milliseconds;
 typedef boost::chrono::nanoseconds nanoseconds;
-
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 struct Clock
 {
   typedef boost::chrono::milliseconds duration;
@@ -66,11 +68,7 @@ int test2 = 0;
 
 int runs = 0;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const Clock::duration max_diff(250);
-#else
-const Clock::duration max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {

test/sync/conditions/condition_variable_any/lost_notif_pass.cpp

@@ -237,5 +237,5 @@ int main()
     test_chrono_wait_function(wait_for_with_pred);
 #endif
 
-    return 0;
+    return boost::report_errors();
 }

test/sync/conditions/condition_variable_any/wait_for_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -38,12 +39,10 @@ int runs = 0;
 
 typedef boost::chrono::system_clock Clock;
 typedef boost::chrono::milliseconds milliseconds;
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const milliseconds max_diff(250);
-#else
-const milliseconds max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -57,12 +56,14 @@ void f()
     Clock::time_point t1 = Clock::now();
     if (runs == 0)
     {
-        BOOST_TEST(t1 - t0 < max_diff);
+        ns d = t1 - t0;
+        BOOST_THREAD_TEST_IT(d, ns(max_diff));
         BOOST_TEST(test2 != 0);
     }
     else
     {
-        BOOST_TEST(t1 - t0 - milliseconds(250) < max_diff);
+        ns d = t1 - t0 - ms(250);
+        BOOST_THREAD_TEST_IT(d, ns(max_diff));
         BOOST_TEST(test2 == 0);
     }
     ++runs;

test/sync/conditions/condition_variable_any/wait_for_pred_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -53,12 +54,10 @@ int runs = 0;
 
 typedef boost::chrono::system_clock Clock;
 typedef boost::chrono::milliseconds milliseconds;
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const milliseconds max_diff(250);
-#else
-const milliseconds max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -71,13 +70,15 @@ void f()
   Clock::time_point t1 = Clock::now();
   if (runs == 0)
   {
-    BOOST_TEST(t1 - t0 < max_diff);
-    BOOST_TEST(test2 != 0);
+      ns d = t1 - t0 ;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
+      BOOST_TEST(test2 != 0);
   }
   else
   {
-    BOOST_TEST(t1 - t0 - milliseconds(250) < max_diff);
-    BOOST_TEST(test2 == 0);
+      ns d = t1 - t0 - ms(250);
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
+      BOOST_TEST(test2 == 0);
   }
   ++runs;
 }

test/sync/conditions/condition_variable_any/wait_until_pass.cpp

@@ -21,9 +21,11 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
-
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 struct Clock
 {
   typedef boost::chrono::milliseconds duration;
@@ -51,11 +53,7 @@ int test2 = 0;
 
 int runs = 0;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const Clock::duration max_diff(250);
-#else
-const Clock::duration max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -69,13 +67,15 @@ void f()
   Clock::time_point t1 = Clock::now();
   if (runs == 0)
   {
-    BOOST_TEST(t1 - t0 < max_diff);
-    BOOST_TEST(test2 != 0);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
+      BOOST_TEST(test2 != 0);
   }
   else
   {
-    BOOST_TEST(t1 - t0 - Clock::duration(250) < max_diff);
-    BOOST_TEST(test2 == 0);
+      ns d = t1 - t0 - ms(250);
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
+      BOOST_TEST(test2 == 0);
   }
   ++runs;
 }

test/sync/conditions/condition_variable_any/wait_until_pred_pass.cpp

@@ -21,9 +21,13 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
+
 struct Clock
 {
   typedef boost::chrono::milliseconds duration;
@@ -66,11 +70,7 @@ int test2 = 0;
 
 int runs = 0;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const Clock::duration max_diff(250);
-#else
-const Clock::duration max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -84,13 +84,15 @@ void f()
   Clock::time_point t1 = Clock::now();
   if (runs == 0)
   {
-    BOOST_TEST(t1 - t0 < max_diff);
+    ns d = t1 - t0;
+    BOOST_THREAD_TEST_IT(d, ns(max_diff));
     BOOST_TEST(test2 != 0);
     BOOST_TEST(r);
   }
   else
   {
-    BOOST_TEST(t1 - t0 - Clock::duration(250) < max_diff);
+    ns d = t1 - t0 - ms(250);
+    BOOST_THREAD_TEST_IT(d, ns(max_diff));
     BOOST_TEST(test2 == 0);
     BOOST_TEST(!r);
   }

test/sync/futures/async/async_executor_pass.cpp

@@ -18,8 +18,7 @@
 //     future<typename result_of<F(Args...)>::type>
 //     async(Executor& ex, F&& f, Args&&... args);
 
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
+#define BOOST_THREAD_VERSION 5
 #include <boost/config.hpp>
 #if ! defined  BOOST_NO_CXX11_DECLTYPE
 #define BOOST_RESULT_OF_USE_DECLTYPE

test/sync/futures/future/then_executor_pass.cpp

@@ -10,8 +10,7 @@
 // template<typename F>
 // auto then(F&& func) -> future<decltype(func(*this))>;
 
-#define BOOST_THREAD_VERSION 4
-#define BOOST_THREAD_PROVIDES_EXECUTORS
+#define BOOST_THREAD_VERSION 5
 //#define BOOST_THREAD_USES_LOG
 #define BOOST_THREAD_USES_LOG_THREAD_ID
 #include <boost/thread/detail/log.hpp>

test/sync/futures/future/wait_for_pass.cpp

@@ -24,6 +24,7 @@
 //#define BOOST_THREAD_USES_LOG
 #define BOOST_THREAD_USES_LOG_THREAD_ID
 #include <boost/thread/detail/log.hpp>
+#include "../../../timming.hpp"
 
 #include <boost/thread/future.hpp>
 #include <boost/thread/thread.hpp>
@@ -37,6 +38,7 @@
 #endif
 
 typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
 namespace boost
 {
@@ -85,11 +87,7 @@ void func5(boost::promise<void> p)
   p.set_value();
 }
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 int main()
 {
@@ -116,7 +114,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef int& T;
@@ -138,7 +137,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef void T;
@@ -160,7 +160,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
   }
   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;

test/sync/futures/future/wait_until_pass.cpp

@@ -30,6 +30,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/chrono/chrono_io.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -38,6 +39,7 @@
 #endif
 
 typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
 namespace boost
 {
@@ -86,11 +88,7 @@ void func5(boost::promise<void> p)
   p.set_value();
 }
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 int main()
 {
@@ -117,7 +115,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef int& T;
@@ -139,7 +138,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef void T;
@@ -161,7 +161,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
   }
   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;

test/sync/futures/packaged_task/non_member_swap_pass.cpp

@@ -59,6 +59,7 @@ int main()
       BOOST_TEST(!p0.valid());
       BOOST_TEST(!p.valid());
   }
+  return boost::report_errors();
 
 }
 

test/sync/futures/shared_future/wait_for_pass.cpp

@@ -29,6 +29,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/chrono/chrono_io.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -37,6 +38,7 @@
 #endif
 
 typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
 namespace boost
 {
@@ -85,11 +87,7 @@ void func5(boost::promise<void> p)
   p.set_value();
 }
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 int main()
 {
@@ -116,7 +114,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef int& T;
@@ -138,7 +137,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef void T;
@@ -160,7 +160,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
   }
   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;

test/sync/futures/shared_future/wait_until_pass.cpp

@@ -30,6 +30,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/chrono/chrono_io.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -38,6 +39,7 @@
 #endif
 
 typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
 namespace boost
 {
@@ -86,11 +88,7 @@ void func5(boost::promise<void> p)
   p.set_value();
 }
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 int main()
 {
@@ -117,7 +115,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef int& T;
@@ -139,7 +138,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
     {
       typedef void T;
@@ -161,7 +161,8 @@ int main()
       f.wait();
       Clock::time_point t1 = Clock::now();
       BOOST_TEST(f.valid());
-      BOOST_TEST(t1 - t0 < max_diff);
+      ns d = t1 - t0;
+      BOOST_THREAD_TEST_IT(d, ns(max_diff));
     }
   }
   BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;

test/sync/futures/when_any/iterators_pass.cpp

@@ -205,7 +205,6 @@ int main()
     BOOST_TEST(all.valid());
     BOOST_TEST(! all.is_ready());
     pt1();
-    BOOST_TEST(! all.is_ready());
     pt2();
     boost::this_thread::sleep_for(boost::chrono::milliseconds(300));
     BOOST_TEST(all.is_ready());

test/sync/futures/when_any/variadic_pass.cpp

@@ -169,7 +169,6 @@ int main()
     BOOST_TEST(all.valid());
     BOOST_TEST(! all.is_ready());
     pt1();
-    BOOST_TEST(! all.is_ready());
     pt2();
     boost::this_thread::sleep_for(boost::chrono::milliseconds(300));
     BOOST_TEST(all.is_ready());

test/sync/mutual_exclusion/locks/lock_guard/adopt_lock_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -29,27 +30,22 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 boost::mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #ifdef BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     m.lock();
     boost::lock_guard<boost::mutex> lg(m, boost::adopt_lock);
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -68,11 +64,22 @@ int main()
   m.lock();
   boost::thread t(f);
 #ifdef BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }
 

test/sync/mutual_exclusion/locks/lock_guard/default_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -29,27 +30,22 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 
 boost::mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #ifdef BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     boost::lock_guard<boost::mutex> lg(m);
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -67,10 +63,21 @@ int main()
   m.lock();
   boost::thread t(f);
 #ifdef BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #endif
   m.unlock();
   t.join();
 
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
   return boost::report_errors();
 }

test/sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_fail.cpp

@@ -0,0 +1,21 @@
+// Copyright (C) 2018 Tom Hughes
+//
+//  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)
+
+// <boost/thread/lock_guard.hpp>
+
+// template <class Mutex> class lock_guard;
+
+// lock_guard(Mutex& m_, adopt_lock_t)
+
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::mutex m;
+
+void fail()
+{
+  boost::lock_guard<boost::mutex> lk(m, boost::adopt_lock);
+}

test/sync/mutual_exclusion/locks/lock_guard/lock_guard_adopt_lock_compile_pass.cpp

@@ -0,0 +1,22 @@
+// Copyright (C) 2018 Tom Hughes
+//
+//  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)
+
+// <boost/thread/lock_guard.hpp>
+
+// template <class Mutex> class lock_guard;
+
+// lock_guard(Mutex& m_, adopt_lock_t)
+
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::mutex m;
+
+void pass()
+{
+  m.lock();
+  boost::lock_guard<boost::mutex> lk(m, boost::adopt_lock);
+}

test/sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_fail.cpp

@@ -0,0 +1,22 @@
+// Copyright (C) 2018 Tom Hughes
+//
+//  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)
+
+// <boost/thread/lock_guard.hpp>
+
+// template <class Mutex> class lock_guard;
+
+// lock_guard(Mutex& m_)
+
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::mutex m;
+
+void fail()
+{
+  boost::lock_guard<boost::mutex> lk0(m);
+  boost::lock_guard<boost::mutex> lk1(m);
+}

test/sync/mutual_exclusion/locks/lock_guard/lock_guard_compile_pass.cpp

@@ -0,0 +1,24 @@
+// Copyright (C) 2018 Tom Hughes
+//
+//  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)
+
+// <boost/thread/lock_guard.hpp>
+
+// template <class Mutex> class lock_guard;
+
+// lock_guard(Mutex& m_)
+
+#include <boost/thread/lock_guard.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+boost::mutex m;
+
+void pass()
+{
+  {
+    boost::lock_guard<boost::mutex> lk0(m);
+  }
+  boost::lock_guard<boost::mutex> lk1(m);
+}

test/sync/mutual_exclusion/locks/lock_guard/make_lock_guard_adopt_lock_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 
 #ifdef BOOST_THREAD_USES_CHRONO
@@ -31,30 +32,25 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 boost::mutex m;
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #ifdef BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     m.lock();
     auto&& lg = boost::make_lock_guard(m, boost::adopt_lock); (void)lg;
 
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -75,10 +71,22 @@ int main()
   m.lock();
   boost::thread t(f);
 #ifdef BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #endif
   m.unlock();
   t.join();
+
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
+
 #endif
   return boost::report_errors();
 }

test/sync/mutual_exclusion/locks/lock_guard/make_lock_guard_pass.cpp

@@ -24,6 +24,7 @@
 #include <boost/thread/thread.hpp>
 
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -31,41 +32,45 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 
 boost::mutex m;
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD && defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   {
     const auto&& lg = boost::make_lock_guard(m); (void)lg;
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 }
 #endif
 
 int main()
 {
 
-#if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD
+#if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD && defined BOOST_THREAD_USES_CHRONO
   {
     m.lock();
     boost::thread t(f);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
 #endif
   return boost::report_errors();

test/sync/mutual_exclusion/locks/nested_strict_lock/default_pass.cpp

@@ -14,6 +14,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -21,28 +22,23 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 
 boost::mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
 #ifdef BOOST_THREAD_USES_CHRONO
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   boost::unique_lock<boost::mutex> lg(m);
   {
     boost::nested_strict_lock<boost::unique_lock<boost::mutex> > nlg(lg);
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 #else
   //time_point t0 = Clock::now();
   //time_point t1;
@@ -62,10 +58,21 @@ int main()
   m.lock();
   boost::thread t(f);
 #ifdef BOOST_THREAD_USES_CHRONO
+  time_point t2 = Clock::now();
   boost::this_thread::sleep_for(ms(250));
+  time_point t3 = Clock::now();
 #endif
   m.unlock();
   t.join();
+
+#if defined BOOST_THREAD_USES_CHRONO
+  ns sleep_time = t3 - t2;
+  ns d_ns = t1 - t0 - sleep_time;
+  ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+  // BOOST_TEST_GE(d_ms.count(), 0);
+  BOOST_THREAD_TEST_IT(d_ms, max_diff);
+  BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
+#endif
   }
 
   return boost::report_errors();

test/sync/mutual_exclusion/locks/nested_strict_lock/make_nested_strict_lock_pass.cpp

@@ -16,6 +16,7 @@
 #include <boost/thread/thread.hpp>
 
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -23,42 +24,46 @@ typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
+time_point t0;
+time_point t1;
 #endif
 
 boost::mutex m;
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_NESTED_STRICT_LOCK && defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
-  time_point t0 = Clock::now();
-  time_point t1;
+  t0 = Clock::now();
   boost::unique_lock<boost::mutex> lg(m);
   {
     const auto&& nlg = boost::make_nested_strict_lock(lg); (void)nlg;
     t1 = Clock::now();
   }
-  ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
 }
 #endif
 
 int main()
 {
 
-#if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_NESTED_STRICT_LOCK
+#if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_NESTED_STRICT_LOCK && defined BOOST_THREAD_USES_CHRONO
   {
     m.lock();
     boost::thread t(f);
+    time_point t2 = Clock::now();
     boost::this_thread::sleep_for(ms(250));
+    time_point t3 = Clock::now();
     m.unlock();
     t.join();
+
+    ns sleep_time = t3 - t2;
+    ns d_ns = t1 - t0 - sleep_time;
+    ms d_ms = boost::chrono::duration_cast<boost::chrono::milliseconds>(d_ns);
+    // BOOST_TEST_GE(d_ms.count(), 0);
+    BOOST_THREAD_TEST_IT(d_ms, max_diff);
+    BOOST_THREAD_TEST_IT(d_ns, ns(max_diff));
   }
 #endif
   return boost::report_errors();