Increased BOOST_THREAD_TEST_TIME_MS yet more because of test failures on Windows.

Fixed more MSVC warnings about variables shadowing other variables.
Try to gracefully finish the timed_join test in case of timeout.
2026-07-22 13:43:42 +00:00 · 2026-07-03 21:57:51 +03:00 · 2026-07-03 19:17:31 +03:00 · 2026-07-03 19:17:31 +03:00 · 2026-07-03 19:17:31 +03:00 · 2026-07-03 19:17:31 +03:00
511 changed files with 7530 additions and 4131 deletions
@@ -4,13 +4,7 @@

 language: cpp

-sudo: false
-
-python: "2.7"
-
-os:
-  - linux
-  - osx
+os: linux

 branches:
  only:
@@ -29,123 +23,88 @@ matrix:

  include:
    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++11
-
-#    - os: linux
-#      compiler: g++-4.7
-#      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-4.7
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-4.8
-#      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-4.8
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-4.9
-#      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-4.9
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-5
-#      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++98
-#      addons:
-#        apt:
-#          packages:
-#            - g++-5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-5
-#      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-5
-#      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
-#      addons:
-#        apt:
-#          packages:
-#            - g++-5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-5
-#      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++1z
-#      addons:
-#        apt:
-#          packages:
-#            - g++-5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-6
-#      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++98
-#      addons:
-#        apt:
-#          packages:
-#            - g++-6
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-6
-#      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - g++-6
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-6
-#      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
-#      addons:
-#        apt:
-#          packages:
-#            - g++-6
-#          sources:
-#            - ubuntu-toolchain-r-test
-#
-#    - os: linux
-#      compiler: g++-6
-#      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
-#      addons:
-#        apt:
-#          packages:
-#            - g++-6
-#          sources:
-#            - ubuntu-toolchain-r-test
+      compiler: g++-4.4
+      env: TOOLSET=gcc CXXSTD=98,0x HEADERS_ONLY=1
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.6
+      env: TOOLSET=gcc CXXSTD=98,0x HEADERS_ONLY=1
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.7
+      env: TOOLSET=gcc CXXSTD=03,11 HEADERS_ONLY=1
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.8
+      env: TOOLSET=gcc CXXSTD=03,11 HEADERS_ONLY=1
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.9
+      env: TOOLSET=gcc CXXSTD=03,11 HEADERS_ONLY=1
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc CXXSTD=03
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc CXXSTD=11
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc CXXSTD=14,1z HEADERS_ONLY=1
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test

    - os: linux
-      dist: trusty
      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++98
+      env: TOOLSET=gcc CXXSTD=14,17 HEADERS_ONLY=1
      addons:
        apt:
          packages:
@@ -154,215 +113,199 @@ matrix:
            - ubuntu-toolchain-r-test

    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++11
+      compiler: g++-8
+      env: TOOLSET=gcc CXXSTD=14,17 HEADERS_ONLY=1
      addons:
        apt:
          packages:
-            - g++-7
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-9
+      env: TOOLSET=gcc CXXSTD=14
+      addons:
+        apt:
+          packages:
+            - g++-9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-9
+      env: TOOLSET=gcc CXXSTD=17
+      addons:
+        apt:
+          packages:
+            - g++-9
          sources:
            - ubuntu-toolchain-r-test

    - os: linux
      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++14
+      compiler: clang++-3.5
+      env: TOOLSET=clang CXXSTD=03,11 HEADERS_ONLY=1
      addons:
        apt:
          packages:
-            - g++-7
+            - clang-3.5
          sources:
            - ubuntu-toolchain-r-test

    - os: linux
-      dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++1z
+      compiler: clang++-3.6
+      env: TOOLSET=clang CXXSTD=03,11,14 HEADERS_ONLY=1
      addons:
        apt:
          packages:
-            - g++-7
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.7
+      env: TOOLSET=clang CXXSTD=03,11,14 HEADERS_ONLY=1
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang CXXSTD=03,11,14 HEADERS_ONLY=1
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang CXXSTD=03,11,14,1z HEADERS_ONLY=1
+      addons:
+        apt:
+          packages:
+            - clang-3.9
          sources:
            - ubuntu-toolchain-r-test

-#    - os: linux
-#      compiler: clang++-3.5
-#      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.5
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.5#
-#
-#    - os: linux
-#      compiler: clang++-3.6
-#      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.6
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.6
-#
-#    - os: linux
-#      compiler: clang++-3.7
-#      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.7
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.7
-#
-#    - os: linux
-#      compiler: clang++-3.8
-#      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.8
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.8
-#
-#    - os: linux
-#      compiler: clang++-3.8
-#      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.8
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.8
-#
-#    - os: linux
-#      compiler: clang++-3.8
-#      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.8
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.8
-#
-#    - os: linux
-#      compiler: clang++-3.9
-#      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++11
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.9
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.9
-#
-#    - os: linux
-#      compiler: clang++-3.9
-#      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++14
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.9
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.9
-#
-#    - os: linux
-#      compiler: clang++-3.9
-#      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++1z
-#      addons:
-#        apt:
-#          packages:
-#            - clang-3.9
-#          sources:
-#            - ubuntu-toolchain-r-test
-#            - llvm-toolchain-precise-3.9
-#
    - os: linux
      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++98
+      env: TOOLSET=clang CXXSTD=03,11,14,1z HEADERS_ONLY=1
      addons:
        apt:
          packages:
            - clang-4.0
          sources:
            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0

    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++11
+      compiler: clang++-5.0
+      env: TOOLSET=clang CXXSTD=03,11,14,1z HEADERS_ONLY=1
      addons:
        apt:
          packages:
-            - clang-4.0
+            - clang-5.0
          sources:
            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0

    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++14
+      compiler: clang++-6.0
+      env: TOOLSET=clang CXXSTD=14,17 HEADERS_ONLY=1
      addons:
        apt:
          packages:
-            - clang-4.0
+            - clang-6.0
          sources:
            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0

    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++1z
+      compiler: clang++-7
+      env: TOOLSET=clang CXXSTD=14,17,2a HEADERS_ONLY=1
      addons:
        apt:
          packages:
-            - clang-4.0
+            - clang-7
          sources:
            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
+            - llvm-toolchain-xenial-7
+
+    - os: linux
+      compiler: clang++-8
+      env: TOOLSET=clang CXXSTD=14,17,2a HEADERS_ONLY=1
+      addons:
+        apt:
+          packages:
+            - clang-8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-xenial-8
+
+    - os: linux
+      compiler: clang++-9
+      env: TOOLSET=clang CXXSTD=14
+      addons:
+        apt:
+          packages:
+            - clang-9
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+
+    - os: linux
+      compiler: clang++-9
+      env: TOOLSET=clang CXXSTD=17
+      addons:
+        apt:
+          packages:
+            - clang-9
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'

    - os: osx
      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++98
+      env: TOOLSET=clang CXXSTD=98

 #    - os: osx
 #      compiler: clang++
-#      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
+#      env: TOOLSET=clang CXXSTD=11

 #    - os: osx
 #      compiler: clang++
-#      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
+#      env: TOOLSET=clang CXXSTD=14

    - os: osx
      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++1z
+      env: TOOLSET=clang CXXSTD=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
+    echo "using $TOOLSET : : $TRAVIS_COMPILER ;" > ~/user-config.jam
+  - ./b2 -j3 -l60 libs/thread/test${HEADERS_ONLY:+//test_self_contained_headers} toolset=$TOOLSET cxxstd=$CXXSTD

 notifications:
  email:
@@ -0,0 +1,99 @@
+# Generated by `boostdep --cmake thread`
+# Copyright 2020, 2021 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.8...3.20)
+
+project(boost_thread VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+set(_default_threadapi pthread)
+
+if(WIN32 AND NOT CMAKE_CXX_PLATFORM_ID MATCHES "Cygwin")
+  set(_default_threadapi win32)
+endif()
+
+set(BOOST_THREAD_THREADAPI ${_default_threadapi} CACHE STRING "Boost.Thread threading API (pthread or win32)")
+set_property(CACHE BOOST_THREAD_THREADAPI PROPERTY STRINGS pthread win32)
+
+unset(_default_threadapi)
+
+message(STATUS "Boost.Thread: threading API is ${BOOST_THREAD_THREADAPI}")
+
+if(BOOST_THREAD_THREADAPI STREQUAL win32)
+
+  set(THREAD_SOURCES
+    src/win32/thread.cpp
+    src/win32/tss_dll.cpp
+    src/win32/tss_pe.cpp
+    src/win32/thread_primitives.cpp
+    src/future.cpp
+  )
+
+else()
+
+  set(THREAD_SOURCES
+    src/pthread/thread.cpp
+    src/pthread/once.cpp
+    src/future.cpp
+  )
+
+endif()
+
+add_library(boost_thread ${THREAD_SOURCES})
+
+add_library(Boost::thread ALIAS boost_thread)
+
+target_include_directories(boost_thread PUBLIC include)
+
+target_link_libraries(boost_thread
+  PUBLIC
+    Boost::assert
+    Boost::atomic
+    Boost::bind
+    Boost::chrono
+    Boost::concept_check
+    Boost::config
+    Boost::container
+    Boost::container_hash
+    Boost::core
+    Boost::date_time
+    Boost::exception
+    Boost::function
+    Boost::io
+    Boost::move
+    Boost::optional
+    Boost::predef
+    Boost::preprocessor
+    Boost::smart_ptr
+    Boost::system
+    Boost::throw_exception
+    Boost::tuple
+    Boost::type_traits
+    Boost::utility
+    Boost::winapi
+
+    Threads::Threads
+)
+
+target_compile_features(boost_thread PUBLIC cxx_std_11)
+
+target_compile_definitions(boost_thread
+  PUBLIC BOOST_THREAD_NO_LIB
+  PRIVATE BOOST_THREAD_SOURCE
+)
+
+if(BUILD_SHARED_LIBS)
+  target_compile_definitions(boost_thread PUBLIC BOOST_THREAD_DYN_LINK INTERFACE BOOST_THREAD_USE_DLL PRIVATE BOOST_THREAD_BUILD_DLL)
+else()
+  target_compile_definitions(boost_thread PUBLIC BOOST_THREAD_STATIC_LINK INTERFACE BOOST_THREAD_USE_LIB PRIVATE BOOST_THREAD_BUILD_LIB)
+endif()
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()
@@ -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,68 @@ branches:
    - develop
    - /feature\/.*/

-platform:
-  - x64
+image: Visual Studio 2015

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

+    - TOOLSET: msvc-14.0
+      ADDRMD: 32
+      VARIANT: debug

+    - TOOLSET: msvc-14.1
+      ADDRMD: 64
+      VARIANT: release
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017

-#    - 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.2
+      CXXSTD: 17
+      ADDRMD: 32
+      VARIANT: debug
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+
+    - TOOLSET: msvc-14.2
+      ADDRMD: 64
+      VARIANT: release
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+
+    - ADDPATH: C:\cygwin\bin;
+      TOOLSET: gcc
+      VARIANT: release
+
+    - ADDPATH: C:\cygwin64\bin;
+      TOOLSET: gcc
+      VARIANT: debug
+
+    - ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      TOOLSET: gcc
+      VARIANT: debug
+
+    - ADDPATH: C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin;
+      TOOLSET: gcc
+      VARIANT: release

 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 not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+  - if not "%VARIANT%" == "" set VARIANT=variant=%VARIANT%
+  - b2 -j2 --abbreviate-paths libs/thread/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% %VARIANT%
@@ -0,0 +1,45 @@
+# Copyright René Ferdinand Rivera Morell 2023-2024
+# 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)
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/assert//boost_assert
+    /boost/atomic//boost_atomic
+    /boost/bind//boost_bind
+    /boost/chrono//boost_chrono
+    /boost/concept_check//boost_concept_check
+    /boost/config//boost_config
+    /boost/container//boost_container
+    /boost/container_hash//boost_container_hash
+    /boost/core//boost_core
+    /boost/date_time//boost_date_time
+    /boost/exception//boost_exception
+    /boost/function//boost_function
+    /boost/io//boost_io
+    /boost/move//boost_move
+    /boost/optional//boost_optional
+    /boost/predef//boost_predef
+    /boost/preprocessor//boost_preprocessor
+    /boost/smart_ptr//boost_smart_ptr
+    /boost/system//boost_system
+    /boost/throw_exception//boost_throw_exception
+    /boost/tuple//boost_tuple
+    /boost/type_traits//boost_type_traits
+    /boost/utility//boost_utility
+    /boost/winapi//boost_winapi ;
+
+project /boost/thread
+    ;
+
+explicit
+    [ alias boost_thread : build//boost_thread ]
+    [ alias all : boost_thread example test ]
+    ;
+
+call-if : boost-library thread
+    : install boost_thread
+    ;
+
@@ -35,16 +35,22 @@
 import os ;
 import indirect ;
 import path ;
-import configure ; 
+import configure ;
 import threadapi-feature ;

-project boost/thread
+exe has_atomic_flag_lockfree : ../build/has_atomic_flag_lockfree_test.cpp ;
+
+project
    : source-location ../src
+    : common-requirements
+        <library>$(boost_dependencies)
+        <include>../include
    : requirements <threading>multi
      #<link>static:<define>BOOST_THREAD_STATIC_LINK=1
      #<link>shared:<define>BOOST_THREAD_DYN_LINK=1
      <link>static:<define>BOOST_THREAD_BUILD_LIB=1
      <link>shared:<define>BOOST_THREAD_BUILD_DLL=1
+      -<tag>@%boostcpp.tag
      -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
      <tag>@$(__name__).tag
      <toolset>gcc:<cxxflags>-Wno-long-long
@@ -52,7 +58,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 +143,9 @@ 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
+      <define>BOOST_THREAD_NO_LIB=1
    ;

-exe has_atomic_flag_lockfree : ../build/has_atomic_flag_lockfree_test.cpp ; 
-
 rule tag ( name : type ? : property-set )
 {
    local result = $(name) ;
@@ -158,8 +161,15 @@ rule tag ( name : type ? : property-set )
    }

    # forward to the boost tagging rule
-    return  [ indirect.call $(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
-                $(result) : $(type) : $(property-set) ] ;
+    if $(BOOST_JAMROOT_MODULE)
+    {
+        return  [ indirect.call $(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
+                    $(result) : $(type) : $(property-set) ] ;
+    }
+    else
+    {
+        return $(result) ;
+    }
 }

 rule win32_pthread_paths ( properties * )
@@ -238,6 +248,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)
    #{
@@ -267,11 +281,15 @@ rule requirements ( properties * )
            }
        }
        result += <define>BOOST_THREAD_DONT_USE_CHRONO ;
-        if ! [ configure.builds has_atomic_flag_lockfree 
-            : $(properties) : "lockfree boost::atomic_flag" ]  { 
-           result += <library>/boost/atomic//boost_atomic ; 
-        } 
+        if ! [ configure.builds has_atomic_flag_lockfree
+            : $(properties) : "lockfree boost::atomic_flag" ]  {
+           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 +302,7 @@ alias thread_sources
      win32/thread.cpp
      win32/tss_dll.cpp
      win32/tss_pe.cpp
+      win32/thread_primitives.cpp
      future.cpp
    : ## requirements ##
      <threadapi>win32
@@ -308,5 +327,3 @@ lib boost_thread
      <link>static:<define>BOOST_THREAD_USE_LIB=1
      <conditional>@usage-requirements
    ;
-
-boost-install boost_thread ;
@@ -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
+
@@ -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.]]

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

 ]

@@ -303,7 +303,7 @@ When `BOOST_THREAD_VERSION>=4` define `BOOST_THREAD_DONT_PROVIDE_SIGNATURE_PACKA

 [section:thread_const-var thread constructor with variadic rvalue parameters]

-C++11 thread constructor accep a variable number of rvalue argumentshas. When `BOOST_THREAD_PROVIDES_VARIADIC_THREAD ` is defined Boost.Thread provides this C++ feature if the following are not defined 
+C++11 thread constructor accept a variable number of rvalue arguments has. When `BOOST_THREAD_PROVIDES_VARIADIC_THREAD ` is defined Boost.Thread provides this C++ feature if the following are not defined 

 * BOOST_NO_SFINAE_EXPR
 * BOOST_NO_CXX11_VARIADIC_TEMPLATES
@@ -1,5 +1,5 @@
 [/
-  (C) Copyright 20012 Vicente J. Botet Escriba.
+  (C) Copyright 2012 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).
@@ -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;
    };
@@ -1,6 +1,6 @@
 [/
  (C) Copyright 2007-12 Anthony Williams.
-  (C) Copyright 20012 Vicente J. Botet Escriba.
+  (C) Copyright 2012 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).
@@ -1,6 +1,6 @@
 [/
  (C) Copyright 2008-9 Anthony Williams.
-  (C) Copyright 12 Vicente J. Botet Escriba.
+  (C) Copyright 2012 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).
@@ -4,7 +4,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)

-project boost/thread/example 
+project 
    : requirements <library>../build//boost_thread <threading>multi
    ;
       
@@ -112,21 +112,21 @@ int main()
 #if __cplusplus > 201103L
  {
    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    int i = 0;
-    boost::future<int&> f = boost::make_ready_future(std::ref(i));
+    int x = 0;
+    boost::future<int&> f = boost::make_ready_future(std::ref(x));
    std::cout << f.get() << std::endl;
  }
 #endif
  {
    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    int i = 0;
-    boost::future<int&> f = boost::make_ready_future(boost::ref(i));
+    int x = 0;
+    boost::future<int&> f = boost::make_ready_future(boost::ref(x));
    std::cout << f.get() << std::endl;
  }
  {
    std::cout << __FILE__ << " "<< __LINE__ << std::endl;
-    const int i = 0;
-    boost::future<int const&> f = boost::make_ready_future(boost::cref(i));
+    const int x = 0;
+    boost::future<int const&> f = boost::make_ready_future(boost::cref(x));
    std::cout << f.get() << std::endl;
  }
  {
@@ -142,12 +142,12 @@ int main()
  }
  catch (std::exception& ex)
  {
-    std::cout << "ERRORRRRR "<<ex.what() << "" << std::endl;
+    std::cout << "ERRORRRRR " << ex.what() << std::endl;
    return 1;
  }
  catch (...)
  {
-    std::cout << "ERRORRRRR "<<"ERRORRRRR exception thrown" << std::endl;
+    std::cout << "ERRORRRRR ERRORRRRR exception thrown" << std::endl;
    return 2;
  }
  return 0;
@@ -8,7 +8,7 @@
 #include <boost/thread/thread.hpp>
 #include <iostream>

-boost::mutex io_mutex; // The iostreams are not guaranteed to be thread-safe!
+boost::mutex g_io_mutex; // The iostreams are not guaranteed to be thread-safe!

 class counter
 {
@@ -25,12 +25,12 @@ private:
    int count;
 };

-counter c;
+counter g_counter;

 void change_count()
 {
-    int i = c.increment();
-    boost::unique_lock<boost::mutex> scoped_lock(io_mutex);
+    int i = g_counter.increment();
+    boost::unique_lock<boost::mutex> scoped_lock(g_io_mutex);
    std::cout << "count == " << i << std::endl;
 }

@@ -10,23 +10,23 @@
 #include <boost/thread/once.hpp>
 #include <cassert>

-int value=0;
+int g_value=0;
 #ifdef BOOST_THREAD_PROVIDES_ONCE_CXX11
-static boost::once_flag once;
-//static boost::once_flag once2 = BOOST_ONCE_INIT;
+static boost::once_flag g_once;
+//static boost::once_flag g_once2 = BOOST_ONCE_INIT;
 #else
-static boost::once_flag once = BOOST_ONCE_INIT;
-//static boost::once_flag once2 = once;
+static boost::once_flag g_once = BOOST_ONCE_INIT;
+//static boost::once_flag g_once2 = g_once;
 #endif

 void init()
 {
-    ++value;
+    ++g_value;
 }

 void thread_proc()
 {
-    boost::call_once(&init, once);
+    boost::call_once(&init, g_once);
 }

 int main()
@@ -35,5 +35,5 @@ int main()
    for (int i=0; i<5; ++i)
        threads.create_thread(&thread_proc);
    threads.join_all();
-    assert(value == 1);
+    assert(g_value == 1);
 }
@@ -54,6 +54,7 @@ void consumer(
  try {
    for(int i=0; ;++i)
    {
+      (void)i;
      int r;
      sbq.pull(r);
      //sbq >> r;
@@ -77,6 +78,7 @@ void consumer2(the_ostream &/*mos*/, boost::sync_queue<int> & sbq)
  try {
    for(int i=0; ;++i)
    {
+      (void)i;
      int r;
      queue_op_status st = sbq.try_pull(r);
      if (queue_op_status::closed == st) break;
@@ -97,6 +99,7 @@ void consumer3(the_ostream &/*mos*/, boost::sync_queue<int> & sbq)
  try {
    for(int i=0; ;++i)
    {
+      (void)i;
      int r;
      queue_op_status res = sbq.wait_pull(r);
      if (res==queue_op_status::closed) break;
@@ -57,6 +57,7 @@ void consumer(
  try {
    for(int i=0; ;++i)
    {
+      (void)i;
      int r;
      sbq.pull(r);
      //sbq >> r;
@@ -80,6 +81,7 @@ void consumer2(the_ostream &/*mos*/, boost::queue_front<int> sbq)
  try {
    for(int i=0; ;++i)
    {
+      (void)i;
      int r;
      queue_op_status st = sbq.try_pull(r);
      if (queue_op_status::closed == st) break;
@@ -100,6 +102,7 @@ void consumer3(the_ostream &/*mos*/, boost::queue_front<int> sbq)
  try {
    for(int i=0; ;++i)
    {
+      (void)i;
      int r;
      queue_op_status res = sbq.wait_pull(r);
      if (res==queue_op_status::closed) break;
@@ -55,6 +55,7 @@ void consumer(the_ostream &/*mos*/, boost::sync_bounded_queue<int> & sbq)
  try {
    for(int i=0; ;++i)
    {
+      (void)i;
      int r;
      sbq.pull_front(r);
      //sbq >> r;
@@ -77,6 +78,7 @@ void consumer2(the_ostream &/*mos*/,  boost::sync_bounded_queue<int> & sbq)
  try {
    for(int i=0; ;++i)
    {
+      (void)i;
      int r;
      queue_op_status st = sbq.try_pull_front(r);
      if (queue_op_status::closed == st) break;
@@ -28,11 +28,11 @@ private:
    int count;
 };

-counter c;
+counter g_counter;

 void change_count()
 {
-    //std::cout << "count == " << c.increment() << std::endl;
+    //std::cout << "count == " << g_counter.increment() << std::endl;
 }

 int main(int, char*[])
@@ -26,6 +26,7 @@ struct func
    int& i;

    func(int& i_):i(i_){}
+    func(func const& that):i(that.i){}

    void operator()()
    {
@@ -28,9 +28,9 @@ enum game_state
    BOTH_PLAYERS_GONE
 };

-int state;
-boost::mutex mutex;
-boost::condition cond;
+int g_state;
+boost::mutex g_mutex;
+boost::condition g_cond;

 const char* player_name(int state)
 {
@@ -44,29 +44,29 @@ const char* player_name(int state)

 void player(int active)
 {
-    boost::unique_lock<boost::mutex> lock(mutex);
+    boost::unique_lock<boost::mutex> lock(g_mutex);

    int other = active == PLAYER_A ? PLAYER_B : PLAYER_A;

-    while (state < GAME_OVER)
+    while (g_state < GAME_OVER)
    {
        //std::cout << player_name(active) << ": Play." << std::endl;
-        state = other;
-        cond.notify_all();
+        g_state = other;
+        g_cond.notify_all();
        do
        {
-            cond.wait(lock);
-            if (state == other)
+            g_cond.wait(lock);
+            if (g_state == other)
            {
                std::cout << "---" << player_name(active)
                          << ": Spurious wakeup!" << std::endl;
            }
-        } while (state == other);
+        } while (g_state == other);
    }

-    ++state;
+    ++g_state;
    std::cout << player_name(active) << ": Gone." << std::endl;
-    cond.notify_all();
+    g_cond.notify_all();
 }

 struct thread_adapt
@@ -100,7 +100,7 @@ private:

 int main()
 {
-    state = START;
+    g_state = START;

    boost::thread thrda(&player, PLAYER_A);
    boost::thread thrdb(&player, PLAYER_B);
@@ -110,22 +110,22 @@ int main()
    xt.sec += 1;
    boost::thread::sleep(xt);
    {
-        boost::unique_lock<boost::mutex> lock(mutex);
+        boost::unique_lock<boost::mutex> lock(g_mutex);
        std::cout << "---Noise ON..." << std::endl;
    }

    for (int i = 0; i < 10; ++i)
-        cond.notify_all();
+        g_cond.notify_all();

    {
-        boost::unique_lock<boost::mutex> lock(mutex);
+        boost::unique_lock<boost::mutex> lock(g_mutex);
        std::cout << "---Noise OFF..." << std::endl;
-        state = GAME_OVER;
-        cond.notify_all();
+        g_state = GAME_OVER;
+        g_cond.notify_all();
        do
        {
-            cond.wait(lock);
-        } while (state != BOTH_PLAYERS_GONE);
+            g_cond.wait(lock);
+        } while (g_state != BOTH_PLAYERS_GONE);
    }

    std::cout << "GAME OVER" << std::endl;
@@ -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>
@@ -8,23 +8,22 @@
 #include <iostream>
 #include <boost/detail/lightweight_test.hpp>

-int count = 0;
-boost::mutex mutex;
+int g_count = 0;
+boost::mutex g_mutex;

 void increment_count()
 {
-    boost::unique_lock<boost::mutex> lock(mutex);
-    std::cout << "count = " << ++count << std::endl;
+    boost::unique_lock<boost::mutex> lock(g_mutex);
+    std::cout << "count = " << ++g_count << std::endl;
 }

-boost::thread_group threads2;
-boost::thread* th2 = 0;
+boost::thread_group g_threads2;

 void increment_count_2()
 {
-    boost::unique_lock<boost::mutex> lock(mutex);
-    BOOST_TEST(threads2.is_this_thread_in());
-    std::cout << "count = " << ++count << std::endl;
+    boost::unique_lock<boost::mutex> lock(g_mutex);
+    BOOST_TEST(g_threads2.is_this_thread_in());
+    std::cout << "count = " << ++g_count << std::endl;
 }

 int main()
@@ -63,11 +62,11 @@ int main()
  }
  {
    {
-      boost::unique_lock<boost::mutex> lock(mutex);
+      boost::unique_lock<boost::mutex> lock(g_mutex);
      boost::thread* th2 = new boost::thread(&increment_count_2);
-      threads2.add_thread(th2);
+      g_threads2.add_thread(th2);
    }
-    threads2.join_all();
+    g_threads2.join_all();
  }
  return boost::report_errors();
 }
@@ -20,6 +20,7 @@ struct func
    int& i;

    func(int& i_):i(i_){}
+    func(func const& other):i(other.i){}

    void operator()()
    {
@@ -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>

@@ -8,21 +8,21 @@
 #include <boost/thread/tss.hpp>
 #include <cassert>

-boost::thread_specific_ptr<int> value;
+boost::thread_specific_ptr<int> g_value;

 void increment()
 {
-    int* p = value.get();
+    int* p = g_value.get();
    ++*p;
 }

 void thread_proc()
 {
-    value.reset(new int(0)); // initialize the thread's storage
+    g_value.reset(new int(0)); // initialize the thread's storage
    for (int i=0; i<10; ++i)
    {
        increment();
-        int* p = value.get();
+        int* p = g_value.get();
        assert(*p == i+1);
        (void)(p);
    }
@@ -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
@@ -12,18 +12,18 @@
 #include <boost/thread/scoped_thread.hpp>
 #include <boost/thread/with_lock_guard.hpp>

-boost::mutex m; // protection for 'x' and 'std::cout'
-int x;
+boost::mutex g_mutex; // protection for 'g_x' and 'std::cout'
+int g_x = 0;

 #if defined(BOOST_NO_CXX11_LAMBDAS)  || (defined BOOST_MSVC && _MSC_VER < 1700)
 void print_x() {
-  ++x;
-  std::cout << "x = " << x << std::endl;
+  ++g_x;
+  std::cout << "x = " << g_x << std::endl;
 }

 void job() {
  for (int i = 0; i < 10; ++i) {
-    boost::with_lock_guard(m, print_x);
+    boost::with_lock_guard(g_mutex, print_x);
    boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
  }
 }
@@ -31,10 +31,10 @@ void job() {
 void job() {
  for (int i = 0; i < 10; ++i) {
    boost::with_lock_guard(
-        m,
+        g_mutex,
        []() {
-          ++x;
-          std::cout << "x = " << x << std::endl;
+          ++g_x;
+          std::cout << "x = " << g_x << std::endl;
        }
    );
    boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
@@ -148,7 +148,7 @@ namespace detail
  template <class Q, class T,
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 #if defined __GNUC__ && ! defined __clang__
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
          bool Copyable = is_copy_constructible<T>::value,
          bool Movable = true
 #else
@@ -140,7 +140,7 @@ namespace detail
  template <class T, class ST,
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 #if defined __GNUC__ && ! defined __clang__
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
          bool Copyable = is_copy_constructible<T>::value,
          bool Movable = true
 #else
@@ -11,7 +11,8 @@
 //
 //////////////////////////////////////////////////////////////////////////////

-#include <boost/bind.hpp>
+#include <boost/bind/bind.hpp>
+#include <boost/core/ref.hpp>

 #include <boost/thread/detail/config.hpp>
 #include <boost/thread/condition_variable.hpp>
@@ -63,7 +64,7 @@ namespace detail

  protected:
    mutable mutex mtx_;
-    condition_variable not_empty_;
+    condition_variable cond_;
    underlying_queue_type data_;
    bool closed_;

@@ -91,16 +92,14 @@ namespace detail
    inline bool wait_until_not_empty_or_closed(unique_lock<mutex>& lk);
    template <class WClock, class Duration>
    queue_op_status wait_until_not_empty_or_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp);
-    template <class WClock, class Duration>
-    queue_op_status wait_until_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp);

-    inline void notify_not_empty_if_needed(unique_lock<mutex>& )
+    inline void notify_elem_added(unique_lock<mutex>& )
    {
-      not_empty_.notify_one();
+      cond_.notify_all();
    }
-    inline void notify_not_empty_if_needed(lock_guard<mutex>& )
+    inline void notify_elem_added(lock_guard<mutex>& )
    {
-      not_empty_.notify_one();
+      cond_.notify_all();
    }

  };
@@ -124,7 +123,7 @@ namespace detail
      lock_guard<mutex> lk(mtx_);
      closed_ = true;
    }
-    not_empty_.notify_all();
+    cond_.notify_all();
  }

  template <class ValueType, class Queue>
@@ -189,7 +188,7 @@ namespace detail
  template <class ValueType, class Queue>
  bool sync_deque_base<ValueType, Queue>::wait_until_not_empty_or_closed(unique_lock<mutex>& lk)
  {
-    not_empty_.wait(lk, boost::bind(&sync_deque_base<ValueType, Queue>::not_empty_or_closed, boost::ref(*this), boost::ref(lk)));
+    cond_.wait(lk, boost::bind(&sync_deque_base<ValueType, Queue>::not_empty_or_closed, this, boost::ref(lk)));
    if (! empty(lk)) return false; // success
    return true; // closed
  }
@@ -198,22 +197,12 @@ namespace detail
  template <class WClock, class Duration>
  queue_op_status sync_deque_base<ValueType, Queue>::wait_until_not_empty_or_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp)
  {
-    if (! not_empty_.wait_until(lk, tp, boost::bind(&sync_deque_base<ValueType, Queue>::not_empty_or_closed, boost::ref(*this), boost::ref(lk))))
+    if (! cond_.wait_until(lk, tp, boost::bind(&sync_deque_base<ValueType, Queue>::not_empty_or_closed, this, boost::ref(lk))))
      return queue_op_status::timeout;
    if (! empty(lk)) return queue_op_status::success;
    return queue_op_status::closed;
  }

-  template <class ValueType, class Queue>
-  template <class WClock, class Duration>
-  queue_op_status sync_deque_base<ValueType, Queue>::wait_until_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp)
-  {
-    bool (sync_queue_base<ValueType, Queue>::*closed_function_ptr)(unique_lock<mutex>&) const = &sync_queue_base<ValueType, Queue>::closed;
-    if (! not_empty_.wait_until(lk, tp, boost::bind(closed_function_ptr, boost::ref(*this), boost::ref(lk))))
-      return queue_op_status::timeout;
-    return queue_op_status::closed;
-  }
-
 } // detail
 } // concurrent
 } // boost
@@ -11,7 +11,8 @@
 //
 //////////////////////////////////////////////////////////////////////////////

-#include <boost/bind.hpp>
+#include <boost/bind/bind.hpp>
+#include <boost/core/ref.hpp>

 #include <boost/thread/detail/config.hpp>
 #include <boost/thread/condition_variable.hpp>
@@ -63,7 +64,7 @@ namespace detail

  protected:
    mutable mutex mtx_;
-    condition_variable not_empty_;
+    condition_variable cond_;
    underlying_queue_type data_;
    bool closed_;

@@ -91,16 +92,14 @@ namespace detail
    inline bool wait_until_not_empty_or_closed(unique_lock<mutex>& lk);
    template <class WClock, class Duration>
    queue_op_status wait_until_not_empty_or_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp);
-    template <class WClock, class Duration>
-    queue_op_status wait_until_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp);

-    inline void notify_not_empty_if_needed(unique_lock<mutex>& )
+    inline void notify_elem_added(unique_lock<mutex>& )
    {
-      not_empty_.notify_one();
+      cond_.notify_all();
    }
-    inline void notify_not_empty_if_needed(lock_guard<mutex>& )
+    inline void notify_elem_added(lock_guard<mutex>& )
    {
-      not_empty_.notify_one();
+      cond_.notify_all();
    }

  };
@@ -124,7 +123,7 @@ namespace detail
      lock_guard<mutex> lk(mtx_);
      closed_ = true;
    }
-    not_empty_.notify_all();
+    cond_.notify_all();
  }

  template <class ValueType, class Queue>
@@ -189,7 +188,7 @@ namespace detail
  template <class ValueType, class Queue>
  bool sync_queue_base<ValueType, Queue>::wait_until_not_empty_or_closed(unique_lock<mutex>& lk)
  {
-    not_empty_.wait(lk, boost::bind(&sync_queue_base<ValueType, Queue>::not_empty_or_closed, boost::ref(*this), boost::ref(lk)));
+    cond_.wait(lk, boost::bind(&sync_queue_base<ValueType, Queue>::not_empty_or_closed, this, boost::ref(lk)));
    if (! empty(lk)) return false; // success
    return true; // closed
  }
@@ -198,22 +197,12 @@ namespace detail
  template <class WClock, class Duration>
  queue_op_status sync_queue_base<ValueType, Queue>::wait_until_not_empty_or_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp)
  {
-    if (! not_empty_.wait_until(lk, tp, boost::bind(&sync_queue_base<ValueType, Queue>::not_empty_or_closed, boost::ref(*this), boost::ref(lk))))
+    if (! cond_.wait_until(lk, tp, boost::bind(&sync_queue_base<ValueType, Queue>::not_empty_or_closed, this, boost::ref(lk))))
      return queue_op_status::timeout;
    if (! empty(lk)) return queue_op_status::success;
    return queue_op_status::closed;
  }

-  template <class ValueType, class Queue>
-  template <class WClock, class Duration>
-  queue_op_status sync_queue_base<ValueType, Queue>::wait_until_closed_until(unique_lock<mutex>& lk, chrono::time_point<WClock,Duration> const&tp)
-  {
-    bool (sync_queue_base<ValueType, Queue>::*closed_function_ptr)(unique_lock<mutex>&) const = &sync_queue_base<ValueType, Queue>::closed;
-    if (! not_empty_.wait_until(lk, tp, boost::bind(closed_function_ptr, boost::ref(*this), boost::ref(lk))))
-      return queue_op_status::timeout;
-    return queue_op_status::closed;
-  }
-
 } // detail
 } // concurrent
 } // boost
@@ -148,7 +148,7 @@ namespace detail
  template <class Q, class T,
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 #if defined __GNUC__ && ! defined __clang__
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
          bool Copyable = is_copy_constructible<T>::value,
          bool Movable = true
 #else
@@ -140,7 +140,7 @@ namespace detail
  template <class T, class ST,
 #if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
 #if defined __GNUC__ && ! defined __clang__
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
          bool Copyable = is_copy_constructible<T>::value,
          bool Movable = true
 #else
@@ -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
  {
  };

@@ -655,7 +655,7 @@ namespace concurrent
  queue_op_status sync_bounded_queue<ValueType>::wait_push_back(BOOST_THREAD_RV_REF(ValueType) elem)
  {
      unique_lock<mutex> lk(mtx_);
-      return try_push_back(boost::move(elem), lk);
+      return wait_push_back(boost::move(elem), lk);
  }


@@ -92,13 +92,13 @@ namespace concurrent
    inline void push_back(const value_type& elem, unique_lock<mutex>& lk)
    {
      super::data_.push_back(elem);
-      super::notify_not_empty_if_needed(lk);
+      super::notify_elem_added(lk);
    }

    inline void push_back(BOOST_THREAD_RV_REF(value_type) elem, unique_lock<mutex>& lk)
    {
      super::data_.push_back(boost::move(elem));
-      super::notify_not_empty_if_needed(lk);
+      super::notify_elem_added(lk);
    }
  };

@@ -122,7 +122,7 @@ namespace concurrent
 //      {
 //        data_.push(boost::move(*cur));;
 //      }
-//      notify_not_empty_if_needed(lk);
+//      notify_elem_added(lk);
 //    }
 //    catch (...)
 //    {
@@ -174,14 +174,14 @@ namespace concurrent
  {
    super::throw_if_closed(lk);
    super::data_.push(elem);
-    super::notify_not_empty_if_needed(lk);
+    super::notify_elem_added(lk);
  }
  template <class T, class Container,class Cmp>
  void sync_priority_queue<T,Container,Cmp>::push(lock_guard<mutex>& lk, const T& elem)
  {
    super::throw_if_closed(lk);
    super::data_.push(elem);
-    super::notify_not_empty_if_needed(lk);
+    super::notify_elem_added(lk);
  }
  template <class T, class Container,class Cmp>
  void sync_priority_queue<T,Container,Cmp>::push(const T& elem)
@@ -196,14 +196,14 @@ namespace concurrent
  {
    super::throw_if_closed(lk);
    super::data_.push(boost::move(elem));
-    super::notify_not_empty_if_needed(lk);
+    super::notify_elem_added(lk);
  }
  template <class T, class Container,class Cmp>
  void sync_priority_queue<T,Container,Cmp>::push(lock_guard<mutex>& lk, BOOST_THREAD_RV_REF(T) elem)
  {
    super::throw_if_closed(lk);
    super::data_.push(boost::move(elem));
-    super::notify_not_empty_if_needed(lk);
+    super::notify_elem_added(lk);
  }
  template <class T, class Container,class Cmp>
  void sync_priority_queue<T,Container,Cmp>::push(BOOST_THREAD_RV_REF(T) elem)
@@ -92,13 +92,13 @@ namespace concurrent
    inline void push(const value_type& elem, unique_lock<mutex>& lk)
    {
      super::data_.push_back(elem);
-      super::notify_not_empty_if_needed(lk);
+      super::notify_elem_added(lk);
    }

    inline void push(BOOST_THREAD_RV_REF(value_type) elem, unique_lock<mutex>& lk)
    {
      super::data_.push_back(boost::move(elem));
-      super::notify_not_empty_if_needed(lk);
+      super::notify_elem_added(lk);
    }
  };

@@ -122,7 +122,7 @@ namespace concurrent
 //      {
 //        data_.push(boost::move(*cur));;
 //      }
-//      notify_not_empty_if_needed(lk);
+//      notify_elem_added(lk);
 //    }
 //    catch (...)
 //    {
@@ -16,6 +16,8 @@
 #include <boost/chrono/system_clocks.hpp>
 #include <boost/chrono/chrono_io.hpp>

+#include <algorithm> // std::min
+
 #include <boost/config/abi_prefix.hpp>

 namespace boost
@@ -59,6 +61,45 @@ namespace detail
    }
  }; //end struct

+  template <class Duration>
+  chrono::time_point<chrono::steady_clock,Duration>
+  limit_timepoint(chrono::time_point<chrono::steady_clock,Duration> const& tp)
+  {
+    // Clock == chrono::steady_clock
+    return tp;
+  }
+
+  template <class Clock, class Duration>
+  chrono::time_point<Clock,Duration>
+  limit_timepoint(chrono::time_point<Clock,Duration> const& tp)
+  {
+    // Clock != chrono::steady_clock
+    // The system time may jump while wait_until() is waiting. To compensate for this and time out near
+    // the correct time, we limit how long wait_until() can wait before going around the loop again.
+    const chrono::time_point<Clock,Duration> tpmax(chrono::time_point_cast<Duration>(Clock::now() + chrono::milliseconds(BOOST_THREAD_POLL_INTERVAL_MILLISECONDS)));
+    return (std::min)(tp, tpmax);
+  }
+
+  template <class Duration>
+  chrono::steady_clock::time_point
+  convert_to_steady_clock_timepoint(chrono::time_point<chrono::steady_clock,Duration> const& tp)
+  {
+    // Clock == chrono::steady_clock
+    return chrono::time_point_cast<chrono::steady_clock::duration>(tp);
+  }
+
+  template <class Clock, class Duration>
+  chrono::steady_clock::time_point
+  convert_to_steady_clock_timepoint(chrono::time_point<Clock,Duration> const& tp)
+  {
+    // Clock != chrono::steady_clock
+    // The system time may jump while wait_until() is waiting. To compensate for this and time out near
+    // the correct time, we limit how long wait_until() can wait before going around the loop again.
+    const chrono::steady_clock::duration dura(chrono::duration_cast<chrono::steady_clock::duration>(tp - Clock::now()));
+    const chrono::steady_clock::duration duramax(chrono::milliseconds(BOOST_THREAD_POLL_INTERVAL_MILLISECONDS));
+    return chrono::steady_clock::now() + (std::min)(dura, duramax);
+  }
+
 } //end detail namespace

  template <class T, class Clock = chrono::steady_clock, class TimePoint=typename Clock::time_point>
@@ -88,8 +129,8 @@ namespace detail
    T pull();
    void pull(T& elem);

-    template <class WClock, class Duration>
-    queue_op_status pull_until(chrono::time_point<WClock,Duration> const& tp, T& elem);
+    template <class Duration>
+    queue_op_status pull_until(chrono::time_point<clock,Duration> const& tp, T& elem);
    template <class Rep, class Period>
    queue_op_status pull_for(chrono::duration<Rep,Period> const& dura, T& elem);

@@ -122,8 +163,9 @@ namespace detail
    inline bool not_empty_and_time_reached(lock_guard<mutex>& lk) const;

    bool wait_to_pull(unique_lock<mutex>&);
-    template <class WClock, class Duration>
-    queue_op_status wait_to_pull_until(unique_lock<mutex>&, chrono::time_point<WClock, Duration> const& tp);
+    queue_op_status wait_to_pull_until(unique_lock<mutex>&, TimePoint const& tp);
+    template <class Rep, class Period>
+    queue_op_status wait_to_pull_for(unique_lock<mutex>& lk, chrono::duration<Rep,Period> const& dura);

    T pull(unique_lock<mutex>&);
    T pull(lock_guard<mutex>&);
@@ -228,14 +270,13 @@ namespace detail
      if (not_empty_and_time_reached(lk)) return false; // success
      if (super::closed(lk)) return true; // closed

-      const time_point tp(super::data_.top().time);
-      super::wait_until_closed_until(lk, tp);
+      const time_point tpmin(detail::limit_timepoint(super::data_.top().time));
+      super::cond_.wait_until(lk, tpmin);
    }
  }

  template <class T, class Clock, class TimePoint>
-  template <class WClock, class Duration>
-  queue_op_status sync_timed_queue<T, Clock, TimePoint>::wait_to_pull_until(unique_lock<mutex>& lk, chrono::time_point<WClock, Duration> const& tp)
+  queue_op_status sync_timed_queue<T, Clock, TimePoint>::wait_to_pull_until(unique_lock<mutex>& lk, TimePoint const& tp)
  {
    for (;;)
    {
@@ -249,8 +290,30 @@ namespace detail
      if (super::closed(lk)) return queue_op_status::closed;
      if (clock::now() >= tp) return super::empty(lk) ? queue_op_status::timeout : queue_op_status::not_ready;

-      const time_point tpmin(tp < super::data_.top().time ? tp : super::data_.top().time);
-      super::wait_until_closed_until(lk, tpmin);
+      const time_point tpmin((std::min)(tp, detail::limit_timepoint(super::data_.top().time)));
+      super::cond_.wait_until(lk, tpmin);
+    }
+  }
+
+  template <class T, class Clock, class TimePoint>
+  template <class Rep, class Period>
+  queue_op_status sync_timed_queue<T, Clock, TimePoint>::wait_to_pull_for(unique_lock<mutex>& lk, chrono::duration<Rep,Period> const& dura)
+  {
+    const chrono::steady_clock::time_point tp(chrono::steady_clock::now() + chrono::duration_cast<chrono::steady_clock::duration>(dura));
+    for (;;)
+    {
+      if (not_empty_and_time_reached(lk)) return queue_op_status::success;
+      if (super::closed(lk)) return queue_op_status::closed;
+      if (chrono::steady_clock::now() >= tp) return super::empty(lk) ? queue_op_status::timeout : queue_op_status::not_ready;
+
+      super::wait_until_not_empty_or_closed_until(lk, tp);
+
+      if (not_empty_and_time_reached(lk)) return queue_op_status::success;
+      if (super::closed(lk)) return queue_op_status::closed;
+      if (chrono::steady_clock::now() >= tp) return super::empty(lk) ? queue_op_status::timeout : queue_op_status::not_ready;
+
+      const chrono::steady_clock::time_point tpmin((std::min)(tp, detail::convert_to_steady_clock_timepoint(super::data_.top().time)));
+      super::cond_.wait_until(lk, tpmin);
    }
  }

@@ -315,12 +378,12 @@ namespace detail

  //////////////////////
  template <class T, class Clock, class TimePoint>
-  template <class WClock, class Duration>
+  template <class Duration>
  queue_op_status
-  sync_timed_queue<T, Clock, TimePoint>::pull_until(chrono::time_point<WClock, Duration> const& tp, T& elem)
+  sync_timed_queue<T, Clock, TimePoint>::pull_until(chrono::time_point<clock,Duration> const& tp, T& elem)
  {
    unique_lock<mutex> lk(super::mtx_);
-    const queue_op_status rc = wait_to_pull_until(lk, tp);
+    const queue_op_status rc = wait_to_pull_until(lk, chrono::time_point_cast<typename time_point::duration>(tp));
    if (rc == queue_op_status::success) pull(lk, elem);
    return rc;
  }
@@ -331,7 +394,10 @@ namespace detail
  queue_op_status
  sync_timed_queue<T, Clock, TimePoint>::pull_for(chrono::duration<Rep,Period> const& dura, T& elem)
  {
-    return pull_until(chrono::steady_clock::now() + dura, elem);
+    unique_lock<mutex> lk(super::mtx_);
+    const queue_op_status rc = wait_to_pull_for(lk, dura);
+    if (rc == queue_op_status::success) pull(lk, elem);
+    return rc;
  }

  ///////////////////////////
@@ -9,37 +9,14 @@
 #ifndef BOOST_CSBL_DEQUE_HPP
 #define BOOST_CSBL_DEQUE_HPP

-#include <boost/config.hpp>
-// MSVC has some trouble instantiating a non_copyable type
-//C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\INCLUDE\xmemory0(606) : error C2248: 'non_copyable::non_copyable' : cannot access private member declared in class 'non_copyable'
-//        ..\libs\thread\test\sync\mutual_exclusion\queue_views\single_thread_pass.cpp(24) : see declaration of 'non_copyable::non_copyable'
-//        ..\libs\thread\test\sync\mutual_exclusion\queue_views\single_thread_pass.cpp(23) : see declaration of 'non_copyable'
-//        C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\INCLUDE\xmemory0(605) : while compiling class template member function 'void std::allocator<_Ty>::construct(_Ty *,const _Ty &)'
-//        with
-//        [
-//            _Ty=non_copyable
-//        ]
-#if defined BOOST_THREAD_USES_BOOST_DEQUE || defined BOOST_NO_CXX11_RVALUE_REFERENCES || (defined _MSC_VER && _MSC_FULL_VER < 180020827)
-#ifndef BOOST_THREAD_USES_BOOST_DEQUE
-#define BOOST_THREAD_USES_BOOST_DEQUE
-#endif
-#include <boost/container/deque.hpp>
-#else
 #include <deque>
-#endif

 namespace boost
 {
  namespace csbl
  {
-#if defined BOOST_THREAD_USES_BOOST_DEQUE
-    using ::boost::container::deque;
-
-#else
    using ::std::deque;
-
-#endif
-
  }
 }
+
 #endif // header
@@ -9,24 +9,12 @@
 #ifndef BOOST_CSBL_FUNCTIONAL_HPP
 #define BOOST_CSBL_FUNCTIONAL_HPP

-#include <boost/config.hpp>
-
 #include <functional>

-#if defined BOOST_THREAD_USES_BOOST_FUNCTIONAL || defined BOOST_NO_CXX11_HDR_FUNCTIONAL || defined BOOST_NO_CXX11_RVALUE_REFERENCES
-#ifndef BOOST_THREAD_USES_BOOST_FUNCTIONAL
-#define BOOST_THREAD_USES_BOOST_FUNCTIONAL
-#endif
-#include <boost/function.hpp>
-#endif
-
 namespace boost
 {
  namespace csbl
  {
-#if defined BOOST_THREAD_USES_BOOST_FUNCTIONAL
-    using ::boost::function;
-#else
    // D.8.1, base (deprecated):
    // 20.9.3, reference_wrapper:
    // 20.9.4, arithmetic operations:
@@ -42,8 +30,7 @@ namespace boost
    // 20.9.11 polymorphic function wrappers:
    using ::std::function;
    // 20.9.12, hash function primary template:
-#endif
-
  }
 }
+
 #endif // header
@@ -9,27 +9,14 @@
 #ifndef BOOST_CSBL_LIST_HPP
 #define BOOST_CSBL_LIST_HPP

-#include <boost/config.hpp>
-
-#if defined BOOST_THREAD_USES_BOOST_LIST || defined BOOST_NO_CXX11_RVALUE_REFERENCES
-#ifndef BOOST_THREAD_USES_BOOST_LIST
-#define BOOST_THREAD_USES_BOOST_LIST
-#endif
-#include <boost/container/list.hpp>
-#else
 #include <list>
-#endif

 namespace boost
 {
  namespace csbl
  {
-#if defined BOOST_THREAD_USES_BOOST_LIST
-    using ::boost::container::list;
-#else
    using ::std::list;
-#endif
-
  }
 }
+
 #endif // header
@@ -12,18 +12,7 @@
 #include <boost/thread/csbl/memory/config.hpp>

 // 20.7.6, allocator argument tag
-#if defined BOOST_NO_CXX11_ALLOCATOR
-#include <boost/container/scoped_allocator.hpp>

-namespace boost
-{
-  namespace csbl
-  {
-    using ::boost::container::allocator_arg_t;
-    using ::boost::container::allocator_arg;
-  }
-}
-#else
 namespace boost
 {
  namespace csbl
@@ -32,10 +21,11 @@ namespace boost
    using ::std::allocator_arg;
  }
 }
-#endif // BOOST_NO_CXX11_ALLOCATOR
+
 namespace boost
 {
  using ::boost::csbl::allocator_arg_t;
  using ::boost::csbl::allocator_arg;
 }
+
 #endif // header
@@ -12,17 +12,7 @@
 #include <boost/thread/csbl/memory/config.hpp>

 // 20.7.8, allocator traits
-#if defined BOOST_NO_CXX11_ALLOCATOR
-#include <boost/container/allocator_traits.hpp>

-namespace boost
-{
-  namespace csbl
-  {
-    using ::boost::container::allocator_traits;
-  }
-}
-#else
 namespace boost
 {
  namespace csbl
@@ -30,6 +20,5 @@ namespace boost
    using ::std::allocator_traits;
  }
 }
-#endif // BOOST_NO_CXX11_POINTER_TRAITS

 #endif // header
@@ -9,8 +9,6 @@
 #ifndef BOOST_CSBL_MEMORY_CONFIG_HPP
 #define BOOST_CSBL_MEMORY_CONFIG_HPP

-#include <boost/config.hpp>
-
 #include <memory>

 #endif // header
@@ -14,17 +14,6 @@
 // 20.8.1 class template unique_ptr:
 // default_delete

-#if defined BOOST_NO_CXX11_SMART_PTR
-#include <boost/move/unique_ptr.hpp>
-
-namespace boost
-{
-  namespace csbl
-  {
-    using ::boost::movelib::default_delete;
-  }
-}
-#else
 namespace boost
 {
  namespace csbl
@@ -32,10 +21,5 @@ namespace boost
    using ::std::default_delete;
  }
 }
-#endif // defined  BOOST_NO_CXX11_SMART_PTR

-namespace boost
-{
-  using ::boost::csbl::default_delete;
-}
 #endif // header
@@ -12,17 +12,7 @@
 #include <boost/thread/csbl/memory/config.hpp>

 // 20.7.3, pointer traits
-#if defined BOOST_NO_CXX11_ALLOCATOR
-#include <boost/intrusive/pointer_traits.hpp>

-namespace boost
-{
-  namespace csbl
-  {
-    using ::boost::intrusive::pointer_traits;
-  }
-}
-#else
 namespace boost
 {
  namespace csbl
@@ -30,6 +20,5 @@ namespace boost
    using ::std::pointer_traits;
  }
 }
-#endif // BOOST_NO_CXX11_ALLOCATOR

 #endif // header
@@ -12,17 +12,7 @@
 #include <boost/thread/csbl/memory/config.hpp>

 // 20.7.7, uses_allocator
-#if defined BOOST_NO_CXX11_ALLOCATOR
-#include <boost/container/scoped_allocator.hpp>

-namespace boost
-{
-  namespace csbl
-  {
-    using ::boost::container::uses_allocator;
-  }
-}
-#else
 namespace boost
 {
  namespace csbl
@@ -30,6 +20,5 @@ namespace boost
    using ::std::uses_allocator;
  }
 }
-#endif // BOOST_NO_CXX11_POINTER_TRAITS

 #endif // header
@@ -11,24 +11,6 @@

 #include <boost/thread/csbl/memory/config.hpp>

-#if defined BOOST_NO_CXX11_SMART_PTR
-
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
-
-namespace boost
-{
-  namespace csbl
-  {
-    using ::boost::shared_ptr;
-    using ::boost::make_shared;
-  }
-}
-
-#else
-
-#include <boost/shared_ptr.hpp>
-
 namespace boost
 {
  namespace csbl
@@ -38,5 +20,4 @@ namespace boost
  }
 }

-#endif
 #endif // header
@@ -12,17 +12,15 @@
 #define BOOST_CSBL_MEMORY_UNIQUE_PTR_HPP

 #include <boost/thread/csbl/memory/config.hpp>
-
-#include <boost/move/unique_ptr.hpp>
-#include <boost/move/make_unique.hpp>
+#include <boost/smart_ptr/make_unique.hpp>

 namespace boost
 {
  namespace csbl
  {
-    using ::boost::movelib::unique_ptr;
-    using ::boost::movelib::make_unique;
-
+    using ::std::unique_ptr;
+    using ::boost::make_unique;
  }
 }
+
 #endif // header
@@ -9,37 +9,14 @@
 #ifndef BOOST_CSBL_QUEUE_HPP
 #define BOOST_CSBL_QUEUE_HPP

-#include <boost/config.hpp>
-// MSVC has some trouble instantiating a non_copyable type
-//C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\INCLUDE\xmemory0(606) : error C2248: 'non_copyable::non_copyable' : cannot access private member declared in class 'non_copyable'
-//        ..\libs\thread\test\sync\mutual_exclusion\queue_views\single_thread_pass.cpp(24) : see declaration of 'non_copyable::non_copyable'
-//        ..\libs\thread\test\sync\mutual_exclusion\queue_views\single_thread_pass.cpp(23) : see declaration of 'non_copyable'
-//        C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\INCLUDE\xmemory0(605) : while compiling class template member function 'void std::allocator<_Ty>::construct(_Ty *,const _Ty &)'
-//        with
-//        [
-//            _Ty=non_copyable
-//        ]
-#if defined BOOST_THREAD_USES_BOOST_QUEUE || defined BOOST_NO_CXX11_RVALUE_REFERENCES || (defined _MSC_VER && _MSC_FULL_VER < 180020827)
-#ifndef BOOST_THREAD_USES_BOOST_QUEUE
-#define BOOST_THREAD_USES_BOOST_QUEUE
-#endif
-#include <boost/container/queue.hpp>
-#else
 #include <queue>
-#endif

 namespace boost
 {
  namespace csbl
  {
-#if defined BOOST_THREAD_USES_BOOST_QUEUE
-    using ::boost::container::queue;
-
-#else
    using ::std::queue;
-
-#endif
-
  }
 }
+
 #endif // header
@@ -9,28 +9,12 @@
 #ifndef BOOST_CSBL_TUPLE_HPP
 #define BOOST_CSBL_TUPLE_HPP

-#include <boost/config.hpp>
-
-#if defined BOOST_THREAD_USES_BOOST_TUPLE || defined BOOST_NO_CXX11_HDR_TUPLE || defined BOOST_NO_CXX11_RVALUE_REFERENCES
-#include <boost/tuple/tuple.hpp>
-#ifndef BOOST_THREAD_USES_BOOST_TUPLE
-#define BOOST_THREAD_USES_BOOST_TUPLE
-#endif
-
-#else
 #include <tuple>
-#endif

 namespace boost
 {
  namespace csbl
  {
-#if defined BOOST_THREAD_USES_BOOST_TUPLE
-    using ::boost::tuple;
-    using ::boost::get;
-    using ::boost::make_tuple;
-    //using ::boost::tuple_size;
-#else
    // 20.4.2, class template tuple:
    using ::std::tuple;
    using ::std::get;
@@ -42,8 +26,7 @@ namespace boost
    // 20.4.2.7, relational operators:
    // 20.4.2.8, allocator-related traits
    // 20.4.2.9, specialized algorithms:
-#endif
-
  }
 }
+
 #endif // header
@@ -9,27 +9,14 @@
 #ifndef BOOST_CSBL_VECTOR_HPP
 #define BOOST_CSBL_VECTOR_HPP

-#include <boost/config.hpp>
-
-#if defined BOOST_THREAD_USES_BOOST_VECTOR || defined BOOST_NO_CXX11_RVALUE_REFERENCES || defined BOOST_MSVC
-#ifndef BOOST_THREAD_USES_BOOST_VECTOR
-#define BOOST_THREAD_USES_BOOST_VECTOR
-#endif
-#include <boost/container/vector.hpp>
-#else
 #include <vector>
-#endif

 namespace boost
 {
  namespace csbl
  {
-#if defined BOOST_THREAD_USES_BOOST_VECTOR
-    using ::boost::container::vector;
-#else
    using ::std::vector;
-#endif
-
  }
 }
+
 #endif // header
@@ -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
@@ -396,7 +405,7 @@
 #define BOOST_THREAD_FUTURE_USES_OPTIONAL
 #endif

-#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600)
 #  pragma warn -8008 // Condition always true/false
 #  pragma warn -8080 // Identifier declared but never used
 #  pragma warn -8057 // Parameter never used
@@ -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)
@@ -456,7 +470,8 @@
 #else //Use default
 #   if defined(BOOST_THREAD_PLATFORM_WIN32)
 #       if defined(BOOST_MSVC) || defined(BOOST_INTEL_WIN) \
-      || defined(__MINGW32__) || defined(MINGW32) || defined(BOOST_MINGW32)
+      || defined(__MINGW32__) || defined(MINGW32) || defined(BOOST_MINGW32) \
+      || (defined(_MSC_VER) && defined(__clang__))
      //For compilers supporting auto-tss cleanup
            //with Boost.Threads lib, use Boost.Threads lib
 #           define BOOST_THREAD_USE_LIB
@@ -29,10 +29,10 @@
 #include <boost/static_assert.hpp>
 #include <boost/thread/detail/move.hpp>
 #include <boost/core/enable_if.hpp>
-#include <boost/mpl/bool.hpp>
 #include <boost/type_traits/is_base_of.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/type_traits/is_member_function_pointer.hpp>
+#include <boost/type_traits/is_member_object_pointer.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
 #include <functional>
@@ -86,7 +86,13 @@ namespace boost

    // bullets 3 and 4

-    template <class Fp, class A0>
+    // enable_if avoids
+    //
+    // ./boost/thread/detail/invoke.hpp:101:43: internal compiler error: in gimplify_expr, at gimplify.c:12039
+    // https://sourceforge.net/p/mingw-w64/bugs/694/
+    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83756
+
+    template <class Fp, class A0, class En = typename boost::enable_if<boost::is_member_object_pointer<Fp> >::type>
    inline auto
    invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
        -> decltype(boost::forward<A0>(a0).*f)
@@ -94,7 +100,7 @@ namespace boost
        return boost::forward<A0>(a0).*f;
    }

-    template <class Fp, class A0>
+    template <class Fp, class A0, class En = typename boost::enable_if<boost::is_member_object_pointer<Fp> >::type>
    inline auto
    invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
        -> decltype((*boost::forward<A0>(a0)).*f)
@@ -102,7 +108,7 @@ namespace boost
        return (*boost::forward<A0>(a0)).*f;
    }

-    template <class R, class Fp, class A0>
+    template <class R, class Fp, class A0, class En = typename boost::enable_if<boost::is_member_object_pointer<Fp> >::type>
    inline auto
    invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
        -> decltype(boost::forward<A0>(a0).*f)
@@ -110,7 +116,7 @@ namespace boost
        return boost::forward<A0>(a0).*f;
    }

-    template <class R, class Fp, class A0>
+    template <class R, class Fp, class A0, class En = typename boost::enable_if<boost::is_member_object_pointer<Fp> >::type>
    inline auto
    invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
        -> decltype((*boost::forward<A0>(a0)).*f)
@@ -531,13 +537,13 @@ namespace boost
    // f(t1, t2, ..., tN) in all other cases.

    template <class Ret, class Fp, class ...Args>
-    inline Ret do_invoke(mpl::false_, BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args)
+    inline Ret do_invoke(boost::false_type, BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args)
    {
      return boost::forward<Fp>(f)(boost::forward<Args>(args)...);
    }

    template <class Ret, class Fp, class ...Args>
-    inline Ret do_invoke(mpl::true_, BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args)
+    inline Ret do_invoke(boost::true_type, BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args)
    {
      return f(boost::forward<Args>(args)...);
    }
@@ -1360,12 +1366,12 @@ namespace boost
    // f(t1, t2, ..., tN) in all other cases.

    template <class Ret, class Fp>
-    inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f)
+    inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f)
    {
      return boost::forward<Fp>(f)();
    }
    template <class Ret, class Fp>
-    inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f)
+    inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f)
    {
      return f();
    }
@@ -1382,12 +1388,12 @@ namespace boost
    }

    template <class Ret, class Fp, class A1>
-    inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1)
+    inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1)
    {
      return boost::forward<Fp>(f)(boost::forward<A1>(a1));
    }
    template <class Ret, class Fp, class A1>
-    inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1)
+    inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1)
    {
      return f(boost::forward<A1>(a1));
    }
@@ -1404,12 +1410,12 @@ namespace boost
    }

    template <class Ret, class Fp, class A1, class A2>
-    inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
+    inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
    {
      return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
    }
    template <class Ret, class Fp, class A1, class A2>
-    inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
+    inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
    {
      return f(boost::forward<A1>(a1), boost::forward<A2>(a2));
    }
@@ -1426,12 +1432,12 @@ namespace boost
    }

    template <class Ret, class Fp, class A1, class A2, class A3>
-    inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
+    inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
    {
      return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
    }
    template <class Ret, class Fp, class A1, class A2, class A3>
-    inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
+    inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
    {
      return f(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
    }
@@ -1449,12 +1455,12 @@ namespace boost


    template <class Ret, class Fp, class A1>
-    inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f, A1 a1)
+    inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f, A1 a1)
    {
      return boost::forward<Fp>(f)(a1);
    }
    template <class Ret, class Fp, class A1>
-    inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f, A1 a1)
+    inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f, A1 a1)
    {
      return f(a1);
    }
@@ -1471,12 +1477,12 @@ namespace boost
    }

    template <class Ret, class Fp, class A1, class A2>
-    inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2)
+    inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2)
    {
      return boost::forward<Fp>(f)(a1, a2);
    }
    template <class Ret, class Fp, class A1, class A2>
-    inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2)
+    inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2)
    {
      return f(a1, a2);
    }
@@ -1493,12 +1499,12 @@ namespace boost
    }

    template <class Ret, class Fp, class A1, class A2, class A3>
-    inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2, A3 a3)
+    inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2, A3 a3)
    {
      return boost::forward<Fp>(f)(a1, a2, a3);
    }
    template <class Ret, class Fp, class A1, class A2, class A3>
-    inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2, A3 a3)
+    inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2, A3 a3)
    {
      return f(a1, a2, a3);
    }
@@ -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
@@ -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))))
      {}

@@ -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__)
@@ -22,8 +22,8 @@
 #endif

 #if defined(BOOST_THREAD_CHRONO_WINDOWS_API)
-#include <boost/detail/winapi/time.hpp>
-#include <boost/detail/winapi/timers.hpp>
+#include <boost/winapi/time.hpp>
+#include <boost/winapi/timers.hpp>
 #include <boost/thread/win32/thread_primitives.hpp>
 #elif defined(BOOST_THREAD_CHRONO_MAC_API)
 #include <sys/time.h> //for gettimeofday and timeval
@@ -293,8 +293,8 @@ inline FP init_steady_clock(kern_return_t & err)
      static real_platform_timepoint now()
      {
 #if defined(BOOST_THREAD_CHRONO_WINDOWS_API)
-        boost::detail::winapi::FILETIME_ ft;
-        boost::detail::winapi::GetSystemTimeAsFileTime(&ft);  // never fails
+        boost::winapi::FILETIME_ ft;
+        boost::winapi::GetSystemTimeAsFileTime(&ft);  // never fails
        boost::time_max_t ns = ((((static_cast<boost::time_max_t>(ft.dwHighDateTime) << 32) | ft.dwLowDateTime) - 116444736000000000LL) * 100LL);
        return real_platform_timepoint(ns);
 #elif defined(BOOST_THREAD_CHRONO_MAC_API)
@@ -401,8 +401,8 @@ inline FP init_steady_clock(kern_return_t & err)
      // Use QueryPerformanceCounter() to match the implementation in Boost
      // Chrono so that chrono::steady_clock::now() and this function share the
      // same epoch and so can be converted between each other.
-      boost::detail::winapi::LARGE_INTEGER_ freq;
-      if ( !boost::detail::winapi::QueryPerformanceFrequency( &freq ) )
+      boost::winapi::LARGE_INTEGER_ freq;
+      if ( !boost::winapi::QueryPerformanceFrequency( &freq ) )
      {
        BOOST_ASSERT(0 && "Boost::Thread - QueryPerformanceFrequency Internal Error");
        return mono_platform_timepoint(0);
@@ -413,9 +413,9 @@ inline FP init_steady_clock(kern_return_t & err)
        return mono_platform_timepoint(0);
      }

-      boost::detail::winapi::LARGE_INTEGER_ pcount;
+      boost::winapi::LARGE_INTEGER_ pcount;
      unsigned times=0;
-      while ( ! boost::detail::winapi::QueryPerformanceCounter( &pcount ) )
+      while ( ! boost::winapi::QueryPerformanceCounter( &pcount ) )
      {
        if ( ++times > 3 )
        {
@@ -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)
@@ -0,0 +1,55 @@
+#ifndef BOOST_THREAD_DETAIL_STRING_TO_UNSIGNED_HPP_INCLUDED
+#define BOOST_THREAD_DETAIL_STRING_TO_UNSIGNED_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <string>
+#include <climits>
+
+namespace boost
+{
+namespace thread_detail
+{
+
+inline bool string_to_unsigned( std::string const& s, unsigned& v )
+{
+    v = 0;
+
+    if( s.empty() )
+    {
+        return false;
+    }
+
+    for( char const* p = s.c_str(); *p; ++p )
+    {
+        unsigned char ch = static_cast<unsigned char>( *p );
+
+        if( ch < '0' || ch > '9' )
+        {
+            return false;
+        }
+
+        if( v > UINT_MAX / 10 )
+        {
+            return false;
+        }
+
+        unsigned q = static_cast<unsigned>( ch - '0' );
+
+        if( v == UINT_MAX / 10 && q > UINT_MAX % 10 )
+        {
+            return false;
+        }
+
+        v = v * 10 + q;
+    }
+
+    return true;
+}
+
+} // namespace thread_detail
+} // namespace boost
+
+#endif // #ifndef BOOST_THREAD_DETAIL_STRING_TO_UNSIGNED_HPP_INCLUDED
@@ -0,0 +1,29 @@
+#ifndef BOOST_THREAD_DETAIL_STRING_TRIM_HPP_INCLUDED
+#define BOOST_THREAD_DETAIL_STRING_TRIM_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <string>
+
+namespace boost
+{
+namespace thread_detail
+{
+
+inline std::string string_trim( std::string const& s )
+{
+    std::size_t i = s.find_first_not_of( " \t\r\n" );
+
+    if( i == std::string::npos ) return std::string();
+
+    std::size_t j = s.find_last_not_of( " \t\r\n" );
+
+    return s.substr( i, j + 1 - i );
+}
+
+} // namespace thread_detail
+} // namespace boost
+
+#endif // #ifndef BOOST_THREAD_DETAIL_STRING_TRIM_HPP_INCLUDED
@@ -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>
@@ -27,7 +30,6 @@
 #include <algorithm>
 #include <boost/core/ref.hpp>
 #include <boost/cstdint.hpp>
-#include <boost/bind.hpp>
 #include <stdlib.h>
 #include <memory>
 #include <boost/core/enable_if.hpp>
@@ -44,6 +46,8 @@

 #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 #include <tuple>
+#else
+#include <boost/bind/bind.hpp>
 #endif
 #include <boost/config/abi_prefix.hpp>

@@ -513,7 +517,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 +591,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));
        }
@@ -604,6 +602,9 @@ namespace boost
    class BOOST_SYMBOL_VISIBLE thread::id
    {
    private:
+    
+    #if !defined(BOOST_EMBTC)
+      
        friend inline
        std::size_t
        hash_value(const thread::id &v)
@@ -615,6 +616,14 @@ namespace boost
 #endif
        }

+    #else
+      
+        friend
+        std::size_t
+        hash_value(const thread::id &v);
+
+    #endif
+      
 #if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
 #if defined(BOOST_THREAD_PLATFORM_WIN32)
        typedef unsigned int data;
@@ -640,10 +649,6 @@ namespace boost
 #endif
        {}

-        id(const id& other) BOOST_NOEXCEPT :
-            thread_data(other.thread_data)
-        {}
-
        bool operator==(const id& y) const BOOST_NOEXCEPT
        {
            return thread_data==y.thread_data;
@@ -711,6 +716,21 @@ namespace boost
 #endif
 #endif
    };
+    
+#if defined(BOOST_EMBTC)
+
+        inline
+        std::size_t
+        hash_value(const thread::id &v)
+        {
+#if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
+          return hash_value(v.thread_data);
+#else
+          return hash_value(v.thread_data.get());
+#endif
+        }
+
+#endif

 #ifdef BOOST_THREAD_PLATFORM_PTHREAD
    inline thread::id thread::get_id() const BOOST_NOEXCEPT
@@ -811,6 +831,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 +845,7 @@ namespace boost
 #else
        void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as);
 #endif
+//#endif
    }

    namespace this_thread
@@ -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
@@ -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>

@@ -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
        {}

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

@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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>
@@ -47,7 +51,7 @@ BOOST_THREAD_INLINE_NAMESPACE(v2)

  namespace detail
  {
-    void handle_task_region_exceptions(exception_list& errors)
+    inline void handle_task_region_exceptions(exception_list& errors)
    {
      try {
        throw;
@@ -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:
@@ -18,12 +18,13 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/throw_exception.hpp>
-#include <boost/core/swap.hpp>
+#include <boost/core/invoke_swap.hpp>

 #include <boost/config/abi_prefix.hpp>

 namespace boost
 {
+  class mutex;

  /**
   * externally_locked cloaks an object of type T, and actually provides full
@@ -104,8 +105,8 @@ namespace boost

    void swap(externally_locked& rhs) //BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR)
    {
-      swap(obj_, rhs.obj_);
-      swap(mtx_, rhs.mtx_);
+      boost::core::invoke_swap(obj_, rhs.obj_);
+      boost::core::invoke_swap(mtx_, rhs.mtx_);
    }

    /**
@@ -244,8 +245,8 @@ namespace boost

    void swap(externally_locked& rhs) BOOST_NOEXCEPT
    {
-      swap(obj_, rhs.obj_);
-      swap(mtx_, rhs.mtx_);
+      boost::core::invoke_swap(obj_, rhs.obj_);
+      boost::core::invoke_swap(mtx_, rhs.mtx_);
    }
    /**
     * Requires: The lk parameter must be locking the associated mtx.
@@ -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>
@@ -45,7 +54,7 @@
 #endif

 #include <boost/assert.hpp>
-#include <boost/bind.hpp>
+#include <boost/bind/bind.hpp>
 #ifdef BOOST_THREAD_USES_CHRONO
 #include <boost/chrono/system_clocks.hpp>
 #endif
@@ -54,7 +63,6 @@
 #include <boost/enable_shared_from_this.hpp>
 #include <boost/exception_ptr.hpp>
 #include <boost/function.hpp>
-#include <boost/next_prior.hpp>
 #include <boost/scoped_array.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
@@ -109,6 +117,7 @@ namespace boost
    namespace executors {
        class executor;
    }
+    using executors::executor;
 #endif
    typedef shared_ptr<executor> executor_ptr_type;

@@ -383,7 +392,7 @@ namespace boost
                is_deferred_=false;
                execute(lk);
              }
-              waiters.wait(lk, boost::bind(&shared_state_base::is_done, boost::ref(*this)));
+              waiters.wait(lk, boost::bind(&shared_state_base::is_done, this));
              if(rethrow && exception)
              {
                  boost::rethrow_exception(exception);
@@ -410,7 +419,7 @@ namespace boost
                    return false;

                do_callback(lock);
-                return waiters.timed_wait(lock, rel_time, boost::bind(&shared_state_base::is_done, boost::ref(*this)));
+                return waiters.timed_wait(lock, rel_time, boost::bind(&shared_state_base::is_done, this));
            }

            bool timed_wait_until(boost::system_time const& target_time)
@@ -420,7 +429,7 @@ namespace boost
                    return false;

                do_callback(lock);
-                return waiters.timed_wait(lock, target_time, boost::bind(&shared_state_base::is_done, boost::ref(*this)));
+                return waiters.timed_wait(lock, target_time, boost::bind(&shared_state_base::is_done, this));
            }
 #endif
 #ifdef BOOST_THREAD_USES_CHRONO
@@ -433,7 +442,7 @@ namespace boost
              if (is_deferred_)
                  return future_status::deferred;
              do_callback(lock);
-              if(!waiters.wait_until(lock, abs_time, boost::bind(&shared_state_base::is_done, boost::ref(*this))))
+              if(!waiters.wait_until(lock, abs_time, boost::bind(&shared_state_base::is_done, this)))
              {
                  return future_status::timeout;
              }
@@ -577,11 +586,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 +770,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

@@ -939,7 +939,7 @@ namespace boost
            join();
 #elif defined BOOST_THREAD_ASYNC_FUTURE_WAITS
            unique_lock<boost::mutex> lk(this->mutex);
-            this->waiters.wait(lk, boost::bind(&shared_state_base::is_done, boost::ref(*this)));
+            this->waiters.wait(lk, boost::bind(&shared_state_base::is_done, this));
 #endif
          }

@@ -3189,7 +3189,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 +3531,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 +3621,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 +3642,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 +3859,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 +3918,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 +4147,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 +4163,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 +4182,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 +4212,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 +4268,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>
@@ -4649,32 +4649,34 @@ namespace detail
    shared_ptr<FutureExecutorContinuationSharedState> that_;

 #if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-      BOOST_THREAD_COPYABLE_AND_MOVABLE(run_it)
-      run_it(run_it const& x) //BOOST_NOEXCEPT
-      : that_(x.that_)
-      {}
-      run_it& operator=(BOOST_THREAD_COPY_ASSIGN_REF(run_it) x) //BOOST_NOEXCEPT
-      {
-        if (this != &x) {
-          that_=x.that_;
-        }
-        return *this;
+    BOOST_THREAD_COPYABLE_AND_MOVABLE(run_it)
+    run_it(run_it const& x) //BOOST_NOEXCEPT
+    : that_(x.that_)
+    {}
+    run_it& operator=(BOOST_THREAD_COPY_ASSIGN_REF(run_it) x) //BOOST_NOEXCEPT
+    {
+      if (this != &x) {
+        that_=x.that_;
      }
-      // move
-      run_it(BOOST_THREAD_RV_REF(run_it) x) BOOST_NOEXCEPT
-      : that_(x.that_)
-      {
-        x.that_.reset();
-      }
-      run_it& operator=(BOOST_THREAD_RV_REF(run_it) x) BOOST_NOEXCEPT {
-        if (this != &x) {
-          that_=x.that;
-          x.that_.reset();
-        }
-        return *this;
+      return *this;
+    }
+    // move
+    run_it(BOOST_THREAD_RV_REF(run_it) x) BOOST_NOEXCEPT
+    : that_(boost::move(x.that_))
+    {
+    }
+    run_it& operator=(BOOST_THREAD_RV_REF(run_it) x) BOOST_NOEXCEPT {
+      if (this != &x) {
+        that_ = boost::move(x.that_);
      }
+      return *this;
+    }
+    run_it(shared_ptr<FutureExecutorContinuationSharedState> that) : that_(boost::move(that))
+    {}
+#else
+    run_it(shared_ptr<FutureExecutorContinuationSharedState> that) : that_(that)
+    {}
 #endif
-    run_it(shared_ptr<FutureExecutorContinuationSharedState> that) : that_ (that) {}

    void operator()()
    {
@@ -14,9 +14,9 @@
 #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/scoped_array.hpp>

 #include <iterator>
@@ -154,7 +154,9 @@ namespace boost
    {
      waiter.add(*current);
    }
-    return boost::next(begin, waiter.wait());
+
+    std::advance( begin, waiter.wait() );
+    return begin;
  }
 }

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

    }

@@ -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
@@ -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
@@ -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);
@@ -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>
@@ -82,18 +76,18 @@ namespace boost
            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
            pthread_mutex_t* the_mutex = &internal_mutex;
            guard.activate(m);
-            res = pthread_cond_wait(&cond,the_mutex);
+            res = posix::pthread_cond_wait(&cond,the_mutex);
            check_for_interruption.unlock_if_locked();
            guard.deactivate();
 #else
            pthread_mutex_t* the_mutex = m.mutex()->native_handle();
-            res = pthread_cond_wait(&cond,the_mutex);
+            res = posix::pthread_cond_wait(&cond,the_mutex);
 #endif
        }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
        this_thread::interruption_point();
 #endif
-        if(res && res != EINTR)
+        if(res)
        {
            boost::throw_exception(condition_error(res, "boost::condition_variable::wait failed in pthread_cond_wait"));
        }
@@ -125,12 +119,12 @@ namespace boost
            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
            pthread_mutex_t* the_mutex = &internal_mutex;
            guard.activate(m);
-            cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout.getTs());
+            cond_res=posix::pthread_cond_timedwait(&cond,the_mutex,&timeout.getTs());
            check_for_interruption.unlock_if_locked();
            guard.deactivate();
 #else
            pthread_mutex_t* the_mutex = m.mutex()->native_handle();
-            cond_res=pthread_cond_timedwait(&cond,the_mutex,&timeout.getTs());
+            cond_res=posix::pthread_cond_timedwait(&cond,the_mutex,&timeout.getTs());
 #endif
        }
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
@@ -152,7 +146,7 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
 #endif
-        BOOST_VERIFY(!pthread_cond_signal(&cond));
+        BOOST_VERIFY(!posix::pthread_cond_signal(&cond));
    }

    inline void condition_variable::notify_all() BOOST_NOEXCEPT
@@ -160,7 +154,7 @@ namespace boost
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
 #endif
-        BOOST_VERIFY(!pthread_cond_broadcast(&cond));
+        BOOST_VERIFY(!posix::pthread_cond_broadcast(&cond));
    }

    class condition_variable_any
@@ -172,22 +166,22 @@ namespace boost
        BOOST_THREAD_NO_COPYABLE(condition_variable_any)
        condition_variable_any()
        {
-            int const res=pthread_mutex_init(&internal_mutex,NULL);
+            int const res=posix::pthread_mutex_init(&internal_mutex);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_mutex_init"));
            }
-            int const res2 = pthread::cond_init(cond);
+            int const res2 = posix::pthread_cond_init(&cond);
            if(res2)
            {
-                BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
-                boost::throw_exception(thread_resource_error(res2, "boost::condition_variable_any::condition_variable_any() failed in pthread::cond_init"));
+                BOOST_VERIFY(!posix::pthread_mutex_destroy(&internal_mutex));
+                boost::throw_exception(thread_resource_error(res2, "boost::condition_variable_any::condition_variable_any() failed in pthread_cond_init"));
            }
        }
        ~condition_variable_any()
        {
-            BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
-            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+            BOOST_VERIFY(!posix::pthread_mutex_destroy(&internal_mutex));
+            BOOST_VERIFY(!posix::pthread_cond_destroy(&cond));
        }

        template<typename lock_type>
@@ -202,7 +196,7 @@ namespace boost
                boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
 #endif
                guard.activate(m);
-                res=pthread_cond_wait(&cond,&internal_mutex);
+                res=posix::pthread_cond_wait(&cond,&internal_mutex);
                check_for_interruption.unlock_if_locked();
                guard.deactivate();
            }
@@ -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);
        }
@@ -444,13 +438,13 @@ namespace boost
        void notify_one() BOOST_NOEXCEPT
        {
            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
-            BOOST_VERIFY(!pthread_cond_signal(&cond));
+            BOOST_VERIFY(!posix::pthread_cond_signal(&cond));
        }

        void notify_all() BOOST_NOEXCEPT
        {
            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
-            BOOST_VERIFY(!pthread_cond_broadcast(&cond));
+            BOOST_VERIFY(!posix::pthread_cond_broadcast(&cond));
        }
    private:

@@ -477,7 +471,7 @@ namespace boost
              boost::pthread::pthread_mutex_scoped_lock check_for_interruption(&internal_mutex);
 #endif
              guard.activate(m);
-              res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout.getTs());
+              res=posix::pthread_cond_timedwait(&cond,&internal_mutex,&timeout.getTs());
              check_for_interruption.unlock_if_locked();
              guard.deactivate();
          }
@@ -58,36 +58,29 @@ namespace boost
            // above) and must be initialized (etc) in case some
            // compilation units provide interruptions and others
            // don't.
-            res=pthread_mutex_init(&internal_mutex,NULL);
+            res=posix::pthread_mutex_init(&internal_mutex);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread_mutex_init"));
            }
 //#endif
-            res = pthread::cond_init(cond);
+            res = posix::pthread_cond_init(&cond);
            if (res)
            {
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                // ditto
-                BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
+                BOOST_VERIFY(!posix::pthread_mutex_destroy(&internal_mutex));
 //#endif
-                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread::cond_init"));
+                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread_cond_init"));
            }
        }
        ~condition_variable()
        {
-            int ret;
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
            // ditto
-            do {
-              ret = pthread_mutex_destroy(&internal_mutex);
-            } while (ret == EINTR);
-            BOOST_ASSERT(!ret);
+            BOOST_VERIFY(!posix::pthread_mutex_destroy(&internal_mutex));
 //#endif
-            do {
-              ret = pthread_cond_destroy(&cond);
-            } while (ret == EINTR);
-            BOOST_ASSERT(!ret);
+            BOOST_VERIFY(!posix::pthread_cond_destroy(&cond));
        }

        void wait(unique_lock<mutex>& m);
@@ -128,7 +121,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 +187,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);
        }
@@ -33,59 +33,10 @@

 #include <boost/config/abi_prefix.hpp>

-#ifndef BOOST_THREAD_HAS_NO_EINTR_BUG
-#define BOOST_THREAD_HAS_EINTR_BUG
-#endif
-
 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;
@@ -94,7 +45,7 @@ namespace boost

        mutex()
        {
-            int const res=pthread_mutex_init(&m,NULL);
+            int const res=posix::pthread_mutex_init(&m);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost:: mutex constructor failed in pthread_mutex_init"));
@@ -102,12 +53,10 @@ namespace boost
        }
        ~mutex()
        {
-          int const res = posix::pthread_mutex_destroy(&m);
-          boost::ignore_unused(res);
-          BOOST_ASSERT(!res);
+          BOOST_VERIFY(!posix::pthread_mutex_destroy(&m));
        }

-        void lock()
+        void lock() BOOST_THREAD_ACQUIRE()
        {
            int res = posix::pthread_mutex_lock(&m);
            if (res)
@@ -116,24 +65,14 @@ namespace boost
            }
        }

-        void unlock()
+        void unlock() BOOST_THREAD_RELEASE()
        {
-            int res = posix::pthread_mutex_unlock(&m);
-            (void)res;
-            BOOST_ASSERT(res == 0);
-//            if (res)
-//            {
-//                boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_unlock"));
-//            }
+            BOOST_VERIFY(!posix::pthread_mutex_unlock(&m));
        }

-        bool try_lock()
+        bool try_lock() BOOST_THREAD_TRY_ACQUIRE(true)
        {
-            int res;
-            do
-            {
-                res = pthread_mutex_trylock(&m);
-            } while (res == EINTR);
+            int res = posix::pthread_mutex_trylock(&m);
            if (res==EBUSY)
            {
                return false;
@@ -169,17 +108,17 @@ namespace boost
        BOOST_THREAD_NO_COPYABLE(timed_mutex)
        timed_mutex()
        {
-            int const res=pthread_mutex_init(&m,NULL);
+            int const res=posix::pthread_mutex_init(&m);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost:: timed_mutex constructor failed in pthread_mutex_init"));
            }
 #ifndef BOOST_THREAD_USES_PTHREAD_TIMEDLOCK
-            int const res2=pthread::cond_init(cond);
+            int const res2=posix::pthread_cond_init(&cond);
            if(res2)
            {
                BOOST_VERIFY(!posix::pthread_mutex_destroy(&m));
-                boost::throw_exception(thread_resource_error(res2, "boost:: timed_mutex constructor failed in pthread::cond_init"));
+                boost::throw_exception(thread_resource_error(res2, "boost:: timed_mutex constructor failed in pthread_cond_init"));
            }
            is_locked=false;
 #endif
@@ -188,7 +127,7 @@ namespace boost
        {
            BOOST_VERIFY(!posix::pthread_mutex_destroy(&m));
 #ifndef BOOST_THREAD_USES_PTHREAD_TIMEDLOCK
-            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+            BOOST_VERIFY(!posix::pthread_cond_destroy(&cond));
 #endif
        }

@@ -237,22 +176,12 @@ namespace boost

        void unlock()
        {
-            int res = posix::pthread_mutex_unlock(&m);
-            (void)res;
-            BOOST_ASSERT(res == 0);
-//            if (res)
-//            {
-//                boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_unlock"));
-//            }
+            BOOST_VERIFY(!posix::pthread_mutex_unlock(&m));
        }

        bool try_lock()
        {
-          int res;
-          do
-          {
-              res = pthread_mutex_trylock(&m);
-          } while (res == EINTR);
+          int res = posix::pthread_mutex_trylock(&m);
          if (res==EBUSY)
          {
              return false;
@@ -277,7 +206,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 +215,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()
@@ -306,7 +235,7 @@ namespace boost
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
            while(is_locked)
            {
-                int const cond_res=pthread_cond_timedwait(&cond,&m,&timeout.getTs());
+                int const cond_res=posix::pthread_cond_timedwait(&cond,&m,&timeout.getTs());
                if(cond_res==ETIMEDOUT)
                {
                    break;
@@ -14,18 +14,22 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/detail/invoke.hpp>

+#include <boost/thread/pthread/pthread_helpers.hpp>
 #include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
 #include <boost/thread/detail/delete.hpp>
 #include <boost/core/no_exceptions_support.hpp>

-#include <boost/bind.hpp>
 #include <boost/assert.hpp>
-#include <boost/config/abi_prefix.hpp>
-
 #include <boost/cstdint.hpp>
 #include <pthread.h>
 #include <csignal>

+#if !defined(BOOST_THREAD_PROVIDES_INVOKE) && !defined(BOOST_THREAD_PROVIDES_INVOKE_RET)
+#include <boost/bind/bind.hpp>
+#endif
+
+#include <boost/config/abi_prefix.hpp>
+
 namespace boost
 {

@@ -149,18 +153,18 @@ namespace boost
                BOOST_CATCH (...)
                {
                    flag.epoch=uninitialized_flag;
-                    BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                    BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
                    BOOST_RETHROW
                }
                BOOST_CATCH_END
                flag.epoch=--thread_detail::once_global_epoch;
-                BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
            }
            else
            {
                while(flag.epoch==being_initialized)
                {
-                    BOOST_VERIFY(!pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
+                    BOOST_VERIFY(!posix::pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
                }
            }
        }
@@ -194,18 +198,18 @@ namespace boost
                BOOST_CATCH (...)
                {
                    flag.epoch=uninitialized_flag;
-                    BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                    BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
                    BOOST_RETHROW
                }
                BOOST_CATCH_END
                flag.epoch=--thread_detail::once_global_epoch;
-                BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
            }
            else
            {
                while(flag.epoch==being_initialized)
                {
-                    BOOST_VERIFY(!pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
+                    BOOST_VERIFY(!posix::pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
                }
            }
        }
@@ -238,18 +242,18 @@ namespace boost
                BOOST_CATCH (...)
                {
                    flag.epoch=uninitialized_flag;
-                    BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                    BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
                    BOOST_RETHROW
                }
                BOOST_CATCH_END
                flag.epoch=--thread_detail::once_global_epoch;
-                BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
            }
            else
            {
                while(flag.epoch==being_initialized)
                {
-                    BOOST_VERIFY(!pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
+                    BOOST_VERIFY(!posix::pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
                }
            }
        }
@@ -281,18 +285,18 @@ namespace boost
                BOOST_CATCH (...)
                {
                    flag.epoch=uninitialized_flag;
-                    BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                    BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
                    BOOST_RETHROW
                }
                BOOST_CATCH_END
                flag.epoch=--thread_detail::once_global_epoch;
-                BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
            }
            else
            {
                while(flag.epoch==being_initialized)
                {
-                    BOOST_VERIFY(!pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
+                    BOOST_VERIFY(!posix::pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
                }
            }
        }
@@ -325,18 +329,18 @@ namespace boost
                BOOST_CATCH (...)
                {
                    flag.epoch=uninitialized_flag;
-                    BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                    BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
                    BOOST_RETHROW
                }
                BOOST_CATCH_END
                flag.epoch=--thread_detail::once_global_epoch;
-                BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
            }
            else
            {
                while(flag.epoch==being_initialized)
                {
-                    BOOST_VERIFY(!pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
+                    BOOST_VERIFY(!posix::pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
                }
            }
        }
@@ -369,18 +373,18 @@ namespace boost
                BOOST_CATCH (...)
                {
                    flag.epoch=uninitialized_flag;
-                    BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                    BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
                    BOOST_RETHROW
                }
                BOOST_CATCH_END
                flag.epoch=--thread_detail::once_global_epoch;
-                BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
            }
            else
            {
                while(flag.epoch==being_initialized)
                {
-                    BOOST_VERIFY(!pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
+                    BOOST_VERIFY(!posix::pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
                }
            }
        }
@@ -416,18 +420,18 @@ namespace boost
                BOOST_CATCH (...)
                {
                    flag.epoch=uninitialized_flag;
-                    BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                    BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
                    BOOST_RETHROW
                }
                BOOST_CATCH_END
                flag.epoch=--thread_detail::once_global_epoch;
-                BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
            }
            else
            {
                while(flag.epoch==being_initialized)
                {
-                    BOOST_VERIFY(!pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
+                    BOOST_VERIFY(!posix::pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
                }
            }
        }
@@ -463,18 +467,18 @@ namespace boost
                BOOST_CATCH (...)
                {
                    flag.epoch=uninitialized_flag;
-                    BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                    BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
                    BOOST_RETHROW
                }
                BOOST_CATCH_END
                flag.epoch=--thread_detail::once_global_epoch;
-                BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
            }
            else
            {
                while(flag.epoch==being_initialized)
                {
-                    BOOST_VERIFY(!pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
+                    BOOST_VERIFY(!posix::pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
                }
            }
        }
@@ -512,18 +516,18 @@ namespace boost
                BOOST_CATCH (...)
                {
                    flag.epoch=uninitialized_flag;
-                    BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                    BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
                    BOOST_RETHROW
                }
                BOOST_CATCH_END
                flag.epoch=--thread_detail::once_global_epoch;
-                BOOST_VERIFY(!pthread_cond_broadcast(&thread_detail::once_epoch_cv));
+                BOOST_VERIFY(!posix::pthread_cond_broadcast(&thread_detail::once_epoch_cv));
            }
            else
            {
                while(flag.epoch==being_initialized)
                {
-                    BOOST_VERIFY(!pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
+                    BOOST_VERIFY(!posix::pthread_cond_wait(&thread_detail::once_epoch_cv,&thread_detail::once_epoch_mutex));
                }
            }
        }
@@ -16,8 +16,12 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/detail/invoke.hpp>
 #include <boost/core/no_exceptions_support.hpp>
-#include <boost/bind.hpp>
-#include <boost/atomic.hpp>
+#include <boost/atomic/capabilities.hpp>
+#include <boost/atomic/atomic.hpp>
+
+#if !defined(BOOST_THREAD_PROVIDES_INVOKE) && !defined(BOOST_THREAD_PROVIDES_INVOKE_RET)
+#include <boost/bind/bind.hpp>
+#endif

 #include <boost/config/abi_prefix.hpp>

@@ -8,33 +8,179 @@
 //  http://www.boost.org/LICENSE_1_0.txt)

 #include <boost/thread/detail/config.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/assert.hpp>
 #include <pthread.h>
+#include <errno.h>

 #include <boost/config/abi_prefix.hpp>

+#ifndef BOOST_THREAD_HAS_NO_EINTR_BUG
+#define BOOST_THREAD_HAS_EINTR_BUG
+#endif
+
 namespace boost
 {
-    namespace pthread
+  namespace posix
+  {
+    BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+    int pthread_mutex_init(pthread_mutex_t* m, const pthread_mutexattr_t* attr = NULL)
    {
-      inline int cond_init(pthread_cond_t& cond) {
-
-  #ifdef BOOST_THREAD_INTERNAL_CLOCK_IS_MONO
-              pthread_condattr_t attr;
-              int res = pthread_condattr_init(&attr);
-              if (res)
-              {
-                return res;
-              }
-              pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
-              res=pthread_cond_init(&cond,&attr);
-              pthread_condattr_destroy(&attr);
-              return res;
-  #else
-              return pthread_cond_init(&cond,NULL);
-  #endif
-
-      }
+      return ::pthread_mutex_init(m, attr);
    }
+
+    BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+    int pthread_cond_init(pthread_cond_t* c)
+    {
+#ifdef BOOST_THREAD_INTERNAL_CLOCK_IS_MONO
+      pthread_condattr_t attr;
+      int res = pthread_condattr_init(&attr);
+      if (res)
+      {
+        return res;
+      }
+      BOOST_VERIFY(!pthread_condattr_setclock(&attr, CLOCK_MONOTONIC));
+      res = ::pthread_cond_init(c, &attr);
+      BOOST_VERIFY(!pthread_condattr_destroy(&attr));
+      return res;
+#else
+      return ::pthread_cond_init(c, NULL);
+#endif
+    }
+
+#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_cond_destroy(pthread_cond_t* c)
+    {
+      int ret;
+      do
+      {
+          ret = ::pthread_cond_destroy(c);
+      } 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_trylock(pthread_mutex_t* m)
+    {
+      int ret;
+      do
+      {
+          ret = ::pthread_mutex_trylock(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;
+    }
+
+    BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+    int pthread_cond_wait(pthread_cond_t* c, pthread_mutex_t* m)
+    {
+      int ret;
+      do
+      {
+          ret = ::pthread_cond_wait(c, m);
+      } while (ret == EINTR);
+      return ret;
+    }
+
+    BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+    int pthread_cond_timedwait(pthread_cond_t* c, pthread_mutex_t* m, const struct timespec* t)
+    {
+      int ret;
+      do
+      {
+          ret = ::pthread_cond_timedwait(c, m, t);
+      } 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_cond_destroy(pthread_cond_t* c)
+    {
+      return ::pthread_cond_destroy(c);
+    }
+
+    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_trylock(pthread_mutex_t* m)
+    {
+      return ::pthread_mutex_trylock(m);
+    }
+
+    BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+    int pthread_mutex_unlock(pthread_mutex_t* m)
+    {
+      return ::pthread_mutex_unlock(m);
+    }
+
+    BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+    int pthread_cond_wait(pthread_cond_t* c, pthread_mutex_t* m)
+    {
+      return ::pthread_cond_wait(c, m);
+    }
+
+    BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+    int pthread_cond_timedwait(pthread_cond_t* c, pthread_mutex_t* m, const struct timespec* t)
+    {
+      return ::pthread_cond_timedwait(c, m, t);
+    }
+#endif
+
+    BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+    int pthread_cond_signal(pthread_cond_t* c)
+    {
+      return ::pthread_cond_signal(c);
+    }
+
+    BOOST_FORCEINLINE BOOST_THREAD_DISABLE_THREAD_SAFETY_ANALYSIS
+    int pthread_cond_broadcast(pthread_cond_t* c)
+    {
+      return ::pthread_cond_broadcast(c);
+    }
+  }
 }

 #include <boost/config/abi_suffix.hpp>
@@ -8,6 +8,7 @@

 #include <pthread.h>
 #include <boost/assert.hpp>
+#include <boost/thread/pthread/pthread_helpers.hpp>

 #include <boost/config/abi_prefix.hpp>

@@ -23,11 +24,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 +55,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));
            }

        };
@@ -71,7 +71,7 @@ namespace boost
                boost::throw_exception(thread_resource_error(set_attr_res, "boost:: recursive_mutex constructor failed in pthread_mutexattr_settype"));
            }

-            int const res=pthread_mutex_init(&m,&attr);
+            int const res=posix::pthread_mutex_init(&m,&attr);
            if(res)
            {
                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
@@ -79,16 +79,16 @@ namespace boost
            }
            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
 #else
-            int const res=pthread_mutex_init(&m,NULL);
+            int const res=posix::pthread_mutex_init(&m);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost:: recursive_mutex constructor failed in pthread_mutex_init"));
            }
-            int const res2=pthread::cond_init(cond);
+            int const res2=posix::pthread_cond_init(&cond);
            if(res2)
            {
-                BOOST_VERIFY(!pthread_mutex_destroy(&m));
-                boost::throw_exception(thread_resource_error(res2, "boost:: recursive_mutex constructor failed in pthread::cond_init"));
+                BOOST_VERIFY(!posix::pthread_mutex_destroy(&m));
+                boost::throw_exception(thread_resource_error(res2, "boost:: recursive_mutex constructor failed in pthread_cond_init"));
            }
            is_locked=false;
            count=0;
@@ -96,26 +96,26 @@ namespace boost
        }
        ~recursive_mutex()
        {
-            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_destroy(&m));
 #ifndef BOOST_THREAD_HAS_PTHREAD_MUTEXATTR_SETTYPE
-            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+            BOOST_VERIFY(!posix::pthread_cond_destroy(&cond));
 #endif
        }

 #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;
        }
@@ -138,7 +138,7 @@ namespace boost

            while(is_locked)
            {
-                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
+                BOOST_VERIFY(!posix::pthread_cond_wait(&cond,&m));
            }
            is_locked=true;
            ++count;
@@ -152,7 +152,7 @@ namespace boost
            {
                is_locked=false;
            }
-            BOOST_VERIFY(!pthread_cond_signal(&cond));
+            BOOST_VERIFY(!posix::pthread_cond_signal(&cond));
        }

        bool try_lock()
@@ -206,7 +206,7 @@ namespace boost
                boost::throw_exception(thread_resource_error(set_attr_res, "boost:: recursive_timed_mutex constructor failed in pthread_mutexattr_settype"));
            }

-            int const res=pthread_mutex_init(&m,&attr);
+            int const res=posix::pthread_mutex_init(&m,&attr);
            if(res)
            {
                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
@@ -214,16 +214,16 @@ namespace boost
            }
            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
 #else
-            int const res=pthread_mutex_init(&m,NULL);
+            int const res=posix::pthread_mutex_init(&m);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost:: recursive_timed_mutex constructor failed in pthread_mutex_init"));
            }
-            int const res2=pthread::cond_init(cond);
+            int const res2=posix::pthread_cond_init(&cond);
            if(res2)
            {
-                BOOST_VERIFY(!pthread_mutex_destroy(&m));
-                boost::throw_exception(thread_resource_error(res2, "boost:: recursive_timed_mutex constructor failed in pthread::cond_init"));
+                BOOST_VERIFY(!posix::pthread_mutex_destroy(&m));
+                boost::throw_exception(thread_resource_error(res2, "boost:: recursive_timed_mutex constructor failed in pthread_cond_init"));
            }
            is_locked=false;
            count=0;
@@ -231,9 +231,9 @@ namespace boost
        }
        ~recursive_timed_mutex()
        {
-            BOOST_VERIFY(!pthread_mutex_destroy(&m));
+            BOOST_VERIFY(!posix::pthread_mutex_destroy(&m));
 #ifndef BOOST_USE_PTHREAD_RECURSIVE_TIMEDLOCK
-            BOOST_VERIFY(!pthread_cond_destroy(&cond));
+            BOOST_VERIFY(!posix::pthread_cond_destroy(&cond));
 #endif
        }

@@ -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;
        }
@@ -306,7 +306,7 @@ namespace boost

            while(is_locked)
            {
-                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
+                BOOST_VERIFY(!posix::pthread_cond_wait(&cond,&m));
            }
            is_locked=true;
            ++count;
@@ -320,7 +320,7 @@ namespace boost
            {
                is_locked=false;
            }
-            BOOST_VERIFY(!pthread_cond_signal(&cond));
+            BOOST_VERIFY(!posix::pthread_cond_signal(&cond));
        }

        bool try_lock() BOOST_NOEXCEPT
@@ -347,7 +347,7 @@ namespace boost
            }
            while(is_locked)
            {
-                int const cond_res=pthread_cond_timedwait(&cond,&m,&timeout.getTs());
+                int const cond_res=posix::pthread_cond_timedwait(&cond,&m,&timeout.getTs());
                if(cond_res==ETIMEDOUT)
                {
                    break;
--- a/Show More
+++ b/Show More