Fix warnings about missing sized deallocation operator in C++14 mode.

Also fix code indentation.

.github/workflows/ci.yml

@@ -0,0 +1,124 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+      - feature/**
+
+env:
+  UBSAN_OPTIONS: print_stacktrace=1
+
+jobs:
+  posix:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: gcc-4.8
+            cxxstd: 11
+            container: ubuntu:18.04
+            os: ubuntu-latest
+            install: g++-4.8
+          - toolset: gcc-5
+            cxxstd: 11
+            container: ubuntu:18.04
+            os: ubuntu-latest
+            install: g++-5
+          - toolset: gcc-7
+            container: ubuntu:18.04
+            os: ubuntu-latest
+          - toolset: gcc-9
+            container: ubuntu:20.04
+            os: ubuntu-latest
+          - toolset: gcc-11
+            os: ubuntu-22.04
+          - toolset: gcc-13
+            os: ubuntu-24.04
+          - toolset: clang
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang
+          - toolset: clang
+            os: ubuntu-22.04
+          - toolset: clang
+            cxxstd: 20
+            os: ubuntu-24.04
+          - toolset: clang
+            os: macos-13
+            cxxstd: 11
+          - toolset: clang
+            os: macos-14
+            cxxstd: 14
+          - toolset: clang
+            os: macos-15
+            cxxstd: 17
+
+    runs-on: ${{matrix.os}}
+
+    container:
+      image: ${{matrix.container}}
+      volumes:
+        - /node20217:/node20217:rw,rshared
+        - ${{ startsWith(matrix.container, 'ubuntu:1') && '/node20217:/__e/node20:ro,rshared' || ' ' }}
+
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+      - name: Setup container environment
+        if: matrix.container
+        run: |
+          apt-get update
+          apt-get -y install sudo python3 git g++ curl xz-utils
+
+      - name: Install nodejs20glibc2.17
+        if: ${{ startsWith( matrix.container, 'ubuntu:1' ) }}
+        run: |
+          curl -LO https://archives.boost.io/misc/node/node-v20.9.0-linux-x64-glibc-217.tar.xz
+          tar -xf node-v20.9.0-linux-x64-glibc-217.tar.xz --strip-components 1 -C /node20217
+          ldd /__e/node20/bin/node
+
+      - uses: actions/checkout@v4
+
+      - name: Install packages
+        if: matrix.install
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python3 tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+          ./bootstrap.sh
+          ./b2 -d0 headers
+
+      - name: Create user-config.jam
+        if: matrix.compiler
+        run: |
+          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
+
+      - name: Run tests
+        run: |
+          cd ../boost-root
+          export CXXSTD=${{matrix.cxxstd}}
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} ${CXXSTD:+cxxstd=$CXXSTD} variant=debug,release

.travis.yml

@@ -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 SELF_CONTAINED_HEADER_TESTS=1
-
-#    - 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,196 +113,177 @@ 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 SELF_CONTAINED_HEADER_TESTS=1
+      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:
   - GIT_FETCH_JOBS=8
@@ -364,10 +304,8 @@ install:
 
 script:
   - |-
-    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
-  - BUILD_JOBS=`(nproc || sysctl -n hw.ncpu) 2> /dev/null`
-  - if [ -z "$SELF_CONTAINED_HEADER_TESTS" ]; then export BOOST_THREAD_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS=1; fi
-  - ./b2 -j $BUILD_JOBS -l60 libs/thread/test toolset=$TOOLSET
+    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:

CMakeLists.txt

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

appveyor.yml

@@ -13,39 +13,46 @@ branches:
     - develop
     - /feature\/.*/
 
+image: Visual Studio 2015
+
 environment:
   matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-#      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0
-      TOOLSET: msvc-12.0
-      SELF_CONTAINED_HEADER_TESTS: 1
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-14.0
+
+    - TOOLSET: msvc-14.0
       ADDRMD: 32
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: 17
+      VARIANT: debug
+
+    - TOOLSET: msvc-14.1
       ADDRMD: 64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\cygwin\bin;
+      VARIANT: release
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+
+    - 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
-      CXXSTD: 14
-      SELF_CONTAINED_HEADER_TESTS: 1
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\cygwin64\bin;
+      VARIANT: release
+
+    - ADDPATH: C:\cygwin64\bin;
       TOOLSET: gcc
-      CXXSTD: 14
-      SELF_CONTAINED_HEADER_TESTS: 1
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\mingw\bin;
+      VARIANT: debug
+
+    - ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
       TOOLSET: gcc
-      CXXSTD: 14
-      SELF_CONTAINED_HEADER_TESTS: 1
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      VARIANT: debug
+
+    - ADDPATH: C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin;
       TOOLSET: gcc
-      CXXSTD: 14
-      SELF_CONTAINED_HEADER_TESTS: 1
+      VARIANT: release
 
 install:
   - set GIT_FETCH_JOBS=8
@@ -67,7 +74,7 @@ build: off
 
 test_script:
   - PATH=%ADDPATH%%PATH%
-  - if "%SELF_CONTAINED_HEADER_TESTS%" == "" set BOOST_THREAD_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS=1
   - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
   - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - b2 -j %NUMBER_OF_PROCESSORS% libs/thread/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release
+  - if not "%VARIANT%" == "" set VARIANT=variant=%VARIANT%
+  - b2 -j2 --abbreviate-paths libs/thread/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% %VARIANT%

build.jam

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

build/Jamfile.v2

@@ -35,18 +35,22 @@
 import os ;
 import indirect ;
 import path ;
-import configure ; 
+import configure ;
 import threadapi-feature ;
 
 exe has_atomic_flag_lockfree : ../build/has_atomic_flag_lockfree_test.cpp ;
 
-project boost/thread
+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
@@ -139,6 +143,7 @@ project boost/thread
       #<define>BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED
       #<define>BOOST_SYSTEM_NO_DEPRECATED
       #<define>BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS
+      <define>BOOST_THREAD_NO_LIB=1
     ;
 
 rule tag ( name : type ? : property-set )
@@ -156,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 * )
@@ -269,10 +281,10 @@ 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)
         {
@@ -315,5 +327,3 @@ lib boost_thread
       <link>static:<define>BOOST_THREAD_USE_LIB=1
       <conditional>@usage-requirements
     ;
-
-boost-install boost_thread ;

doc/configuration.qbk

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

doc/emulations.qbk

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

doc/overview.qbk

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

doc/scoped_thread.qbk

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

example/Jamfile.v2

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

example/thread_guard.cpp

@@ -20,6 +20,7 @@ struct func
     int& i;
 
     func(int& i_):i(i_){}
+    func(func const& other):i(other.i){}
 
     void operator()()
     {

include/boost/thread/concurrent_queues/deque_adaptor.hpp

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

include/boost/thread/concurrent_queues/deque_base.hpp

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

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

@@ -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>
@@ -187,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)
   {
-    cond_.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
   }
@@ -196,7 +197,7 @@ 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 (! cond_.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;

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

@@ -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>
@@ -187,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)
   {
-    cond_.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
   }
@@ -196,7 +197,7 @@ 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 (! cond_.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;

include/boost/thread/concurrent_queues/queue_adaptor.hpp

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

include/boost/thread/concurrent_queues/queue_base.hpp

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

include/boost/thread/concurrent_queues/sync_bounded_queue.hpp

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

include/boost/thread/csbl/deque.hpp

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

include/boost/thread/csbl/functional.hpp

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

include/boost/thread/csbl/list.hpp

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

include/boost/thread/csbl/memory/allocator_arg.hpp

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

include/boost/thread/csbl/memory/allocator_traits.hpp

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

include/boost/thread/csbl/memory/config.hpp

@@ -9,8 +9,6 @@
 #ifndef BOOST_CSBL_MEMORY_CONFIG_HPP
 #define BOOST_CSBL_MEMORY_CONFIG_HPP
 
-#include <boost/config.hpp>
-
 #include <memory>
 
 #endif // header

include/boost/thread/csbl/memory/default_delete.hpp

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

include/boost/thread/csbl/memory/pointer_traits.hpp

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

include/boost/thread/csbl/memory/scoped_allocator.hpp

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

include/boost/thread/csbl/memory/shared_ptr.hpp

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

include/boost/thread/csbl/memory/unique_ptr.hpp

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

include/boost/thread/csbl/queue.hpp

@@ -5,42 +5,18 @@
 //
 // 2013/10 Vicente J. Botet Escriba
 //   Creation.
-#if 0
+
 #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
-#endif

include/boost/thread/csbl/tuple.hpp

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

include/boost/thread/csbl/vector.hpp

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

include/boost/thread/detail/config.hpp

@@ -405,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
@@ -470,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

include/boost/thread/detail/invoke.hpp

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

include/boost/thread/detail/platform_time.hpp

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

include/boost/thread/detail/string_to_unsigned.hpp

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

include/boost/thread/detail/string_trim.hpp

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

include/boost/thread/detail/thread.hpp

@@ -30,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>
@@ -47,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>
 
@@ -601,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)
@@ -612,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;
@@ -637,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;
@@ -708,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

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

@@ -51,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;

include/boost/thread/externally_locked.hpp

@@ -18,7 +18,7 @@
 #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>
 
@@ -105,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_);
     }
 
     /**
@@ -245,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.

include/boost/thread/future.hpp

@@ -54,7 +54,7 @@ struct shared_state_base {
 #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
@@ -63,7 +63,6 @@ struct shared_state_base {
 #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>
@@ -393,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);
@@ -420,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)
@@ -430,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
@@ -443,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;
               }
@@ -940,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
           }
 
@@ -4650,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()()
     {

include/boost/thread/futures/wait_for_any.hpp

@@ -17,7 +17,6 @@
 #include <boost/thread/condition_variable.hpp>
 
 #include <boost/core/enable_if.hpp>
-#include <boost/next_prior.hpp>
 #include <boost/scoped_array.hpp>
 
 #include <iterator>
@@ -155,7 +154,9 @@ namespace boost
     {
       waiter.add(*current);
     }
-    return boost::next(begin, waiter.wait());
+
+    std::advance( begin, waiter.wait() );
+    return begin;
   }
 }
 

include/boost/thread/pthread/once.hpp

@@ -19,14 +19,17 @@
 #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
 {
 

include/boost/thread/pthread/once_atomic.hpp

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

include/boost/thread/pthread/pthread_helpers.hpp

@@ -9,6 +9,7 @@
 
 #include <boost/thread/detail/config.hpp>
 #include <boost/throw_exception.hpp>
+#include <boost/assert.hpp>
 #include <pthread.h>
 #include <errno.h>
 

include/boost/thread/pthread/shared_mutex.hpp

@@ -9,7 +9,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/assert.hpp>
-#include <boost/bind.hpp>
+#include <boost/bind/bind.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition_variable.hpp>
@@ -171,7 +171,7 @@ namespace boost
             boost::this_thread::disable_interruption do_not_disturb;
 #endif
             boost::unique_lock<boost::mutex> lk(state_change);
-            shared_cond.wait(lk, boost::bind(&state_data::can_lock_shared, boost::ref(state)));
+            shared_cond.wait(lk, boost::bind(&state_data::can_lock_shared, &state));
             state.lock_shared();
         }
 
@@ -194,7 +194,7 @@ namespace boost
             boost::this_thread::disable_interruption do_not_disturb;
 #endif
             boost::unique_lock<boost::mutex> lk(state_change);
-            if(!shared_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock_shared, boost::ref(state))))
+            if(!shared_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock_shared, &state)))
             {
                 return false;
             }
@@ -209,7 +209,7 @@ namespace boost
             boost::this_thread::disable_interruption do_not_disturb;
 #endif
             boost::unique_lock<boost::mutex> lk(state_change);
-            if(!shared_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock_shared, boost::ref(state))))
+            if(!shared_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock_shared, &state)))
             {
                 return false;
             }
@@ -230,7 +230,7 @@ namespace boost
           boost::this_thread::disable_interruption do_not_disturb;
 #endif
           boost::unique_lock<boost::mutex> lk(state_change);
-          if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_shared, boost::ref(state))))
+          if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_shared, &state)))
           {
               return false;
           }
@@ -270,7 +270,7 @@ namespace boost
 #endif
             boost::unique_lock<boost::mutex> lk(state_change);
             state.exclusive_waiting_blocked=true;
-            exclusive_cond.wait(lk, boost::bind(&state_data::can_lock, boost::ref(state)));
+            exclusive_cond.wait(lk, boost::bind(&state_data::can_lock, &state));
             state.exclusive=true;
         }
 
@@ -282,7 +282,7 @@ namespace boost
 #endif
             boost::unique_lock<boost::mutex> lk(state_change);
             state.exclusive_waiting_blocked=true;
-            if(!exclusive_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock, boost::ref(state))))
+            if(!exclusive_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock, &state)))
             {
                 state.exclusive_waiting_blocked=false;
                 release_waiters();
@@ -300,7 +300,7 @@ namespace boost
 #endif
             boost::unique_lock<boost::mutex> lk(state_change);
             state.exclusive_waiting_blocked=true;
-            if(!exclusive_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock, boost::ref(state))))
+            if(!exclusive_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock, &state)))
             {
                 state.exclusive_waiting_blocked=false;
                 release_waiters();
@@ -324,7 +324,7 @@ namespace boost
 #endif
           boost::unique_lock<boost::mutex> lk(state_change);
           state.exclusive_waiting_blocked=true;
-          if(!exclusive_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock, boost::ref(state))))
+          if(!exclusive_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock, &state)))
           {
               state.exclusive_waiting_blocked=false;
               release_waiters();
@@ -362,7 +362,7 @@ namespace boost
             boost::this_thread::disable_interruption do_not_disturb;
 #endif
             boost::unique_lock<boost::mutex> lk(state_change);
-            shared_cond.wait(lk, boost::bind(&state_data::can_lock_upgrade, boost::ref(state)));
+            shared_cond.wait(lk, boost::bind(&state_data::can_lock_upgrade, &state));
             state.lock_shared();
             state.upgrade=true;
         }
@@ -374,7 +374,7 @@ namespace boost
             boost::this_thread::disable_interruption do_not_disturb;
 #endif
             boost::unique_lock<boost::mutex> lk(state_change);
-            if(!shared_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock_upgrade, boost::ref(state))))
+            if(!shared_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock_upgrade, &state)))
             {
                 return false;
             }
@@ -390,7 +390,7 @@ namespace boost
             boost::this_thread::disable_interruption do_not_disturb;
 #endif
             boost::unique_lock<boost::mutex> lk(state_change);
-            if(!shared_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock_upgrade, boost::ref(state))))
+            if(!shared_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock_upgrade, &state)))
             {
                 return false;
             }
@@ -412,7 +412,7 @@ namespace boost
           boost::this_thread::disable_interruption do_not_disturb;
 #endif
           boost::unique_lock<boost::mutex> lk(state_change);
-          if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_upgrade, boost::ref(state))))
+          if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_upgrade, &state)))
           {
               return false;
           }
@@ -457,7 +457,7 @@ namespace boost
             boost::unique_lock<boost::mutex> lk(state_change);
             state.assert_lock_upgraded();
             state.unlock_shared();
-            upgrade_cond.wait(lk, boost::bind(&state_data::no_shared, boost::ref(state)));
+            upgrade_cond.wait(lk, boost::bind(&state_data::no_shared, &state));
             state.upgrade=false;
             state.exclusive=true;
             state.assert_locked();
@@ -511,7 +511,7 @@ namespace boost
 #endif
           boost::unique_lock<boost::mutex> lk(state_change);
           state.assert_lock_upgraded();
-          if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::one_shared, boost::ref(state))))
+          if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::one_shared, &state)))
           {
               return false;
           }
@@ -569,7 +569,7 @@ namespace boost
 #endif
           boost::unique_lock<boost::mutex> lk(state_change);
           state.assert_lock_shared();
-          if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::one_shared, boost::ref(state))))
+          if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::one_shared, &state)))
           {
               return false;
           }
@@ -623,7 +623,7 @@ namespace boost
 #endif
           boost::unique_lock<boost::mutex> lk(state_change);
           state.assert_lock_shared();
-          if(!exclusive_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_upgrade, boost::ref(state))))
+          if(!exclusive_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_upgrade, &state)))
           {
               return false;
           }

include/boost/thread/pthread/thread_data.hpp

@@ -57,8 +57,8 @@ namespace boost
 #else
           std::size_t page_size = ::sysconf( _SC_PAGESIZE);
 #endif
-#if PTHREAD_STACK_MIN > 0
-          if (size<PTHREAD_STACK_MIN) size=PTHREAD_STACK_MIN;
+#ifdef PTHREAD_STACK_MIN
+          if (size<static_cast<std::size_t>(PTHREAD_STACK_MIN)) size=PTHREAD_STACK_MIN;
 #endif
           size = ((size+page_size-1)/page_size)*page_size;
           int res = pthread_attr_setstacksize(&val_, size);

include/boost/thread/scoped_thread.hpp

@@ -14,6 +14,7 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/thread_functors.hpp>
 #include <boost/thread/thread_only.hpp>
+#include <boost/thread/detail/thread_interruption.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -85,6 +86,10 @@ namespace boost
      */
     ~strict_scoped_thread()
     {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+      // exceptions from a destructor call std::terminate
+      boost::this_thread::disable_interruption do_not_disturb;
+#endif
       CallableThread on_destructor;
 
       on_destructor(t_);
@@ -188,6 +193,10 @@ namespace boost
      */
     ~scoped_thread()
     {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+      // exceptions from a destructor call std::terminate
+      boost::this_thread::disable_interruption do_not_disturb;
+#endif
       CallableThread on_destructor;
 
       on_destructor(t_);

include/boost/thread/synchronized_value.hpp

@@ -17,8 +17,8 @@
 #include <boost/thread/lock_algorithms.hpp>
 #include <boost/thread/lock_factories.hpp>
 #include <boost/thread/strict_lock.hpp>
-#include <boost/core/swap.hpp>
-#include <boost/utility/declval.hpp>
+#include <boost/core/invoke_swap.hpp>
+#include <boost/type_traits/declval.hpp>
 //#include <boost/type_traits.hpp>
 //#include <boost/thread/detail/is_nothrow_default_constructible.hpp>
 //#if ! defined BOOST_NO_CXX11_HDR_TYPE_TRAITS
@@ -582,7 +582,7 @@ namespace boost
       unique_lock<mutex_type> lk1(mtx_, defer_lock);
       unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock);
       lock(lk1,lk2);
-      boost::swap(value_, rhs.value_);
+      boost::core::invoke_swap(value_, rhs.value_);
     }
     /**
      * Swap with the underlying value type
@@ -592,7 +592,7 @@ namespace boost
     void swap(value_type & rhs)
     {
       strict_lock<mutex_type> lk(mtx_);
-      boost::swap(value_, rhs);
+      boost::core::invoke_swap(value_, rhs);
     }
 
     /**

include/boost/thread/thread_guard.hpp

@@ -12,6 +12,7 @@
 #include <boost/thread/detail/delete.hpp>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/thread_functors.hpp>
+#include <boost/thread/detail/thread_interruption.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -34,6 +35,10 @@ namespace boost
     }
     ~thread_guard()
     {
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+      // exceptions from a destructor call std::terminate
+      boost::this_thread::disable_interruption do_not_disturb;
+#endif
       CallableThread on_destructor;
 
       on_destructor(t_);

include/boost/thread/v2/shared_mutex.hpp

@@ -158,7 +158,7 @@ public:
 #endif
 #include <climits>
 #include <boost/system/system_error.hpp>
-#include <boost/bind.hpp>
+#include <boost/bind/bind.hpp>
 
 namespace boost {
   namespace thread_v2 {
@@ -275,9 +275,9 @@ namespace boost {
     inline void shared_mutex::lock()
     {
       boost::unique_lock<mutex_t> lk(mut_);
-      gate1_.wait(lk, boost::bind(&shared_mutex::no_writer, boost::ref(*this)));
+      gate1_.wait(lk, boost::bind(&shared_mutex::no_writer, this));
       state_ |= write_entered_;
-      gate2_.wait(lk, boost::bind(&shared_mutex::no_readers, boost::ref(*this)));
+      gate2_.wait(lk, boost::bind(&shared_mutex::no_readers, this));
     }
 
     inline bool shared_mutex::try_lock()
@@ -298,13 +298,13 @@ namespace boost {
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.wait_until(lk, abs_time, boost::bind(
-            &shared_mutex::no_writer, boost::ref(*this))))
+            &shared_mutex::no_writer, this)))
       {
         return false;
       }
       state_ |= write_entered_;
       if (!gate2_.wait_until(lk, abs_time, boost::bind(
-            &shared_mutex::no_readers, boost::ref(*this))))
+            &shared_mutex::no_readers, this)))
       {
         state_ &= ~write_entered_;
         return false;
@@ -319,13 +319,13 @@ namespace boost {
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
-            &shared_mutex::no_writer, boost::ref(*this))))
+            &shared_mutex::no_writer, this)))
       {
         return false;
       }
       state_ |= write_entered_;
       if (!gate2_.timed_wait(lk, abs_or_rel_time, boost::bind(
-            &shared_mutex::no_readers, boost::ref(*this))))
+            &shared_mutex::no_readers, this)))
       {
         state_ &= ~write_entered_;
         return false;
@@ -350,7 +350,7 @@ namespace boost {
     inline void shared_mutex::lock_shared()
     {
       boost::unique_lock<mutex_t> lk(mut_);
-      gate1_.wait(lk, boost::bind(&shared_mutex::no_writer_no_max_readers, boost::ref(*this)));
+      gate1_.wait(lk, boost::bind(&shared_mutex::no_writer_no_max_readers, this));
       count_t num_readers = (state_ & n_readers_) + 1;
       state_ &= ~n_readers_;
       state_ |= num_readers;
@@ -376,7 +376,7 @@ namespace boost {
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.wait_until(lk, abs_time, boost::bind(
-            &shared_mutex::no_writer_no_max_readers, boost::ref(*this))))
+            &shared_mutex::no_writer_no_max_readers, this)))
       {
         return false;
       }
@@ -393,7 +393,7 @@ namespace boost {
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
-            &shared_mutex::no_writer_no_max_readers, boost::ref(*this))))
+            &shared_mutex::no_writer_no_max_readers, this)))
       {
         return false;
       }
@@ -653,9 +653,9 @@ namespace boost {
     inline void upgrade_mutex::lock()
     {
       boost::unique_lock<mutex_t> lk(mut_);
-      gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader, boost::ref(*this)));
+      gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader, this));
       state_ |= write_entered_;
-      gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, boost::ref(*this)));
+      gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, this));
     }
 
     inline bool upgrade_mutex::try_lock()
@@ -676,13 +676,13 @@ namespace boost {
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.wait_until(lk, abs_time, boost::bind(
-            &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this))))
+            &upgrade_mutex::no_writer_no_upgrader, this)))
       {
         return false;
       }
       state_ |= write_entered_;
       if (!gate2_.wait_until(lk, abs_time, boost::bind(
-            &upgrade_mutex::no_readers, boost::ref(*this))))
+            &upgrade_mutex::no_readers, this)))
       {
         state_ &= ~write_entered_;
         return false;
@@ -697,13 +697,13 @@ namespace boost {
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
-            &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this))))
+            &upgrade_mutex::no_writer_no_upgrader, this)))
       {
         return false;
       }
       state_ |= write_entered_;
       if (!gate2_.timed_wait(lk, abs_or_rel_time, boost::bind(
-            &upgrade_mutex::no_readers, boost::ref(*this))))
+            &upgrade_mutex::no_readers, this)))
       {
         state_ &= ~write_entered_;
         return false;
@@ -729,7 +729,7 @@ namespace boost {
     inline void upgrade_mutex::lock_shared()
     {
       boost::unique_lock<mutex_t> lk(mut_);
-      gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_max_readers, boost::ref(*this)));
+      gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_max_readers, this));
       count_t num_readers = (state_ & n_readers_) + 1;
       state_ &= ~n_readers_;
       state_ |= num_readers;
@@ -755,7 +755,7 @@ namespace boost {
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.wait_until(lk, abs_time, boost::bind(
-            &upgrade_mutex::no_writer_no_max_readers, boost::ref(*this))))
+            &upgrade_mutex::no_writer_no_max_readers, this)))
       {
         return false;
       }
@@ -772,7 +772,7 @@ namespace boost {
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
-            &upgrade_mutex::no_writer_no_max_readers, boost::ref(*this))))
+            &upgrade_mutex::no_writer_no_max_readers, this)))
       {
         return false;
       }
@@ -807,7 +807,7 @@ namespace boost {
     inline void upgrade_mutex::lock_upgrade()
     {
       boost::unique_lock<mutex_t> lk(mut_);
-      gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this)));
+      gate1_.wait(lk, boost::bind(&upgrade_mutex::no_writer_no_upgrader_no_max_readers, this));
       count_t num_readers = (state_ & n_readers_) + 1;
       state_ &= ~n_readers_;
       state_ |= upgradable_entered_ | num_readers;
@@ -833,7 +833,7 @@ namespace boost {
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.wait_until(lk, abs_time, boost::bind(
-            &upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this))))
+            &upgrade_mutex::no_writer_no_upgrader_no_max_readers, this)))
       {
         return false;
       }
@@ -850,7 +850,7 @@ namespace boost {
     {
       boost::unique_lock<mutex_t> lk(mut_);
       if (!gate1_.timed_wait(lk, abs_or_rel_time, boost::bind(
-            &upgrade_mutex::no_writer_no_upgrader_no_max_readers, boost::ref(*this))))
+            &upgrade_mutex::no_writer_no_upgrader_no_max_readers, this)))
       {
         return false;
       }
@@ -898,7 +898,7 @@ namespace boost {
       boost::unique_lock<mutex_t> lk(mut_);
       BOOST_ASSERT(one_or_more_readers());
       if (!gate1_.wait_until(lk, abs_time, boost::bind(
-            &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this))))
+            &upgrade_mutex::no_writer_no_upgrader, this)))
       {
         return false;
       }
@@ -906,7 +906,7 @@ namespace boost {
       state_ &= ~n_readers_;
       state_ |= (write_entered_ | num_readers);
       if (!gate2_.wait_until(lk, abs_time, boost::bind(
-            &upgrade_mutex::no_readers, boost::ref(*this))))
+            &upgrade_mutex::no_readers, this)))
       {
         ++num_readers;
         state_ &= ~(write_entered_ | n_readers_);
@@ -953,7 +953,7 @@ namespace boost {
       boost::unique_lock<mutex_t> lk(mut_);
       BOOST_ASSERT(one_or_more_readers());
       if (!gate1_.wait_until(lk, abs_time, boost::bind(
-            &upgrade_mutex::no_writer_no_upgrader, boost::ref(*this))))
+            &upgrade_mutex::no_writer_no_upgrader, this)))
       {
         return false;
       }
@@ -987,7 +987,7 @@ namespace boost {
       count_t num_readers = (state_ & n_readers_) - 1;
       state_ &= ~(upgradable_entered_ | n_readers_);
       state_ |= write_entered_ | num_readers;
-      gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, boost::ref(*this)));
+      gate2_.wait(lk, boost::bind(&upgrade_mutex::no_readers, this));
     }
 
     inline bool upgrade_mutex::try_unlock_upgrade_and_lock()
@@ -1017,7 +1017,7 @@ namespace boost {
       state_ &= ~(upgradable_entered_ | n_readers_);
       state_ |= (write_entered_ | num_readers);
       if (!gate2_.wait_until(lk, abs_time, boost::bind(
-            &upgrade_mutex::no_readers, boost::ref(*this))))
+            &upgrade_mutex::no_readers, this)))
       {
         ++num_readers;
         state_ &= ~(write_entered_ | n_readers_);

include/boost/thread/win32/basic_timed_mutex.hpp

@@ -30,7 +30,7 @@ namespace boost
 {
     namespace detail
     {
-        struct basic_timed_mutex
+        struct BOOST_THREAD_CAPABILITY("mutex") basic_timed_mutex
         {
             BOOST_STATIC_CONSTANT(unsigned char,lock_flag_bit=31);
             BOOST_STATIC_CONSTANT(unsigned char,event_set_flag_bit=30);
@@ -62,12 +62,12 @@ namespace boost
             }
 
             // Take the lock flag if it's available
-            bool try_lock() BOOST_NOEXCEPT
+            bool try_lock() BOOST_NOEXCEPT BOOST_THREAD_TRY_ACQUIRE(true)
             {
                 return !win32::interlocked_bit_test_and_set(&active_count,lock_flag_bit);
             }
 
-            void lock()
+            void lock() BOOST_THREAD_ACQUIRE()
             {
                 if(try_lock())
                 {
@@ -93,7 +93,7 @@ namespace boost
 
             // Loop until the number of waiters has been incremented or we've taken the lock flag
             // The loop is necessary since this function may be called by multiple threads simultaneously
-            void mark_waiting_and_try_lock(long& old_count)
+            void mark_waiting_and_try_lock(long& old_count) BOOST_THREAD_TRY_ACQUIRE(true)
             {
                 for(;;)
                 {
@@ -117,7 +117,7 @@ namespace boost
             // until we've taken the lock flag and cleared the event set flag and decremented the
             // number of waiters
             // The loop is necessary since this function may be called by multiple threads simultaneously
-            void clear_waiting_and_try_lock(long& old_count)
+            void clear_waiting_and_try_lock(long& old_count) BOOST_THREAD_TRY_ACQUIRE(true)
             {
                 old_count&=~lock_flag_value;
                 old_count|=event_set_flag_value;
@@ -152,7 +152,7 @@ namespace boost
             }
 
             template <typename Clock, typename Timepoint, typename Duration>
-            bool do_lock_until(Timepoint const& t, Duration const& max)
+            bool do_lock_until(Timepoint const& t, Duration const& max) BOOST_THREAD_TRY_ACQUIRE(true)
             {
                 if(try_lock())
                 {
@@ -238,7 +238,7 @@ namespace boost
             }
 #endif
 
-            void unlock()
+            void unlock() BOOST_THREAD_RELEASE()
             {
                 // Clear the lock flag using atomic addition (works since long is always 32 bits on Windows)
                 long const old_count=BOOST_INTERLOCKED_EXCHANGE_ADD(&active_count,lock_flag_value);

include/boost/thread/win32/interlocked_read.hpp

@@ -19,6 +19,8 @@
 // Define compiler barriers
 #if defined(__INTEL_COMPILER)
 #define BOOST_THREAD_DETAIL_COMPILER_BARRIER() __memory_barrier()
+#elif defined(__clang__)
+#define BOOST_THREAD_DETAIL_COMPILER_BARRIER() __atomic_signal_fence(__ATOMIC_SEQ_CST)
 #elif defined(_MSC_VER) && !defined(_WIN32_WCE)
 extern "C" void _ReadWriteBarrier(void);
 #pragma intrinsic(_ReadWriteBarrier)

include/boost/thread/win32/once.hpp

@@ -22,7 +22,9 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/detail/invoke.hpp>
 
-#include <boost/bind.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>
 
@@ -152,7 +154,7 @@ namespace boost
             {
                 name_once_mutex(mutex_name,flag_address);
             }
-            
+
             return ::boost::detail::win32::create_event(
                 mutex_name, 
                 ::boost::detail::win32::manual_reset_event,

include/boost/thread/win32/thread_data.hpp

@@ -145,6 +145,8 @@ namespace boost
             {}
             virtual ~thread_data_base();
 
+            #if !defined(BOOST_EMBTC)
+              
             friend void intrusive_ptr_add_ref(thread_data_base * p)
             {
                 BOOST_INTERLOCKED_INCREMENT(&p->count);
@@ -158,6 +160,13 @@ namespace boost
                 }
             }
 
+            #else
+              
+            friend void intrusive_ptr_add_ref(thread_data_base * p);
+            friend void intrusive_ptr_release(thread_data_base * p);
+
+            #endif
+      
 #if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             void interrupt()
             {
@@ -180,6 +189,24 @@ namespace boost
             }
 //#endif
         };
+        
+#if defined(BOOST_EMBTC)
+
+        inline void intrusive_ptr_add_ref(thread_data_base * p)
+        {
+            BOOST_INTERLOCKED_INCREMENT(&p->count);
+        }
+
+        inline void intrusive_ptr_release(thread_data_base * p)
+        {
+            if(!BOOST_INTERLOCKED_DECREMENT(&p->count))
+            {
+                detail::heap_delete(p);
+            }
+        }
+
+#endif
+        
         BOOST_THREAD_DECL thread_data_base* get_current_thread_data();
 
         typedef boost::intrusive_ptr<detail::thread_data_base> thread_data_ptr;

meta/libraries.json

@@ -10,10 +10,11 @@
       "Vicente J. Botet Escriba <vicente.botet -at- wanadoo.fr>"
     ],
     "description":
-      "Portable C++ multi-threading. C++03, C++11, C++14, C++17.",
+      "Portable C++ multi-threading. C++11, C++14, C++17.",
     "std": [ "proposal" ],    
     "category": [
       "Concurrent", "System"
-    ]
+    ],
+    "cxxstd": "11"
   }
 ]

src/pthread/once_atomic.cpp

@@ -11,8 +11,8 @@
 #include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
-#include <boost/atomic.hpp>
 #include <boost/memory_order.hpp>
+#include <boost/atomic/atomic.hpp>
 #include <pthread.h>
 
 namespace boost

src/pthread/thread.cpp

@@ -19,6 +19,8 @@
 #include <boost/thread/future.hpp>
 #include <boost/thread/pthread/pthread_helpers.hpp>
 #include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
+#include <boost/thread/detail/string_trim.hpp>
+#include <boost/thread/detail/string_to_unsigned.hpp>
 
 #ifdef __GLIBC__
 #include <sys/sysinfo.h>
@@ -33,10 +35,6 @@
 #include <vxCpuLib.h>
 #endif
 
-#include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/trim.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <fstream>
 #include <string>
 #include <set>
@@ -535,24 +533,36 @@ namespace boost
                 if (line.empty())
                     continue;
 
-                vector<string> key_val(2);
-                boost::split(key_val, line, boost::is_any_of(":"));
+                std::size_t i = line.find( ':' );
 
-                if (key_val.size() != 2)
-                  return hardware_concurrency();
+                if( i == std::string::npos )
+                {
+                    return hardware_concurrency();
+                }
 
-                string key   = key_val[0];
-                string value = key_val[1];
-                boost::trim(key);
-                boost::trim(value);
+                std::string key = line.substr( 0, i );
+                std::string value = line.substr( i+1 );
+
+                key = thread_detail::string_trim( key );
+                value = thread_detail::string_trim( value );
 
                 if (key == physical_id) {
-                    current_core_entry.first = boost::lexical_cast<unsigned>(value);
+
+                    if( !thread_detail::string_to_unsigned( value, current_core_entry.first ) )
+                    {
+                        return hardware_concurrency();
+                    }
+
                     continue;
                 }
 
                 if (key == core_id) {
-                    current_core_entry.second = boost::lexical_cast<unsigned>(value);
+
+                    if( !thread_detail::string_to_unsigned( value, current_core_entry.second ) )
+                    {
+                        return hardware_concurrency();
+                    }
+
                     cores.insert(current_core_entry);
                     continue;
                 }

src/win32/thread.cpp

@@ -34,10 +34,10 @@
 #include <mutex>
 #include <atomic>
 #include <Activation.h>
-#include <wrl\client.h>
-#include <wrl\event.h>
-#include <wrl\wrappers\corewrappers.h>
-#include <wrl\ftm.h>
+#include <wrl/client.h>
+#include <wrl/event.h>
+#include <wrl/wrappers/corewrappers.h>
+#include <wrl/ftm.h>
 #include <windows.system.threading.h>
 #pragma comment(lib, "runtimeobject.lib")
 #endif
@@ -577,10 +577,18 @@ namespace boost
                 } Reason;
             } REASON_CONTEXT, *PREASON_CONTEXT;
             typedef BOOL (WINAPI *setwaitabletimerex_t)(HANDLE, const LARGE_INTEGER *, LONG, PTIMERAPCROUTINE, LPVOID, PREASON_CONTEXT, ULONG);
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4100) // unreferenced formal parameter
+#endif
             static inline BOOL WINAPI SetWaitableTimerEx_emulation(HANDLE hTimer, const LARGE_INTEGER *lpDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, PREASON_CONTEXT WakeContext, ULONG TolerableDelay)
             {
                 return SetWaitableTimer(hTimer, lpDueTime, lPeriod, pfnCompletionRoutine, lpArgToCompletionRoutine, FALSE);
             }
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable: 6387) // MSVC sanitiser warns that GetModuleHandleA() might fail
@@ -641,9 +649,15 @@ namespace boost
                 timer_handle=CreateWaitableTimer(NULL,false,NULL);
                 if(timer_handle!=0)
                 {
-                    ULONG tolerable=32; // Empirical testing shows Windows ignores this when <= 26
+                    ULONG const min_tolerable=32; // Empirical testing shows Windows ignores this when <= 26
+                    ULONG const max_tolerable=1000;
+                    ULONG tolerable=min_tolerable;
                     if(time_left_msec/20>tolerable)  // 5%
+                    {
                         tolerable=static_cast<ULONG>(time_left_msec/20);
+                        if(tolerable>max_tolerable)
+                            tolerable=max_tolerable;
+                    }
                     LARGE_INTEGER due_time={{0,0}};
                     if(time_left_msec>0)
                     {
@@ -733,9 +747,15 @@ namespace boost
                 timer_handle=CreateWaitableTimer(NULL,false,NULL);
                 if(timer_handle!=0)
                 {
-                    ULONG tolerable=32; // Empirical testing shows Windows ignores this when <= 26
+                    ULONG const min_tolerable=32; // Empirical testing shows Windows ignores this when <= 26
+                    ULONG const max_tolerable=1000;
+                    ULONG tolerable=min_tolerable;
                     if(time_left_msec/20>tolerable)  // 5%
+                    {
                         tolerable=static_cast<ULONG>(time_left_msec/20);
+                        if(tolerable>max_tolerable)
+                            tolerable=max_tolerable;
+                    }
                     LARGE_INTEGER due_time={{0,0}};
                     if(time_left_msec>0)
                     {

src/win32/thread_primitives.cpp

@@ -52,7 +52,7 @@ struct get_tick_count64_state
 BOOST_ALIGNMENT(64) static get_tick_count64_state g_state;
 
 //! Artifical implementation of GetTickCount64
-ticks_type WINAPI get_tick_count64()
+ticks_type BOOST_WINAPI_WINAPI_CC get_tick_count64()
 {
     uint64_t old_state = g_state.ticks.load(boost::memory_order_acquire);
 
@@ -67,7 +67,7 @@ ticks_type WINAPI get_tick_count64()
 }
 
 //! The function is called periodically in the system thread pool to make sure g_state.ticks is timely updated
-void NTAPI refresh_get_tick_count64(boost::winapi::PVOID_, boost::winapi::BOOLEAN_)
+void BOOST_WINAPI_NTAPI_CC refresh_get_tick_count64(boost::winapi::PVOID_, boost::winapi::BOOLEAN_)
 {
     get_tick_count64();
 }
@@ -88,7 +88,7 @@ void cleanup_get_tick_count64()
     }
 }
 
-ticks_type WINAPI get_tick_count_init()
+ticks_type BOOST_WINAPI_WINAPI_CC get_tick_count_init()
 {
     boost::winapi::HMODULE_ hKernel32 = boost::winapi::GetModuleHandleW(L"kernel32.dll");
     if (hKernel32)

src/win32/tss_dll.cpp

@@ -13,8 +13,10 @@
 
     #include <windows.h>
 
-    #if defined(__BORLANDC__)
+    #if defined(BOOST_BORLANDC)
         extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)
+    #elif defined(BOOST_EMBTC)
+        extern "C" int _libmain(DWORD dwReason)
     #elif defined(_WIN32_WCE)
         extern "C" BOOL WINAPI DllMain(HANDLE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)
     #else

src/win32/tss_pe.cpp

@@ -152,19 +152,25 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) =
         static PVAPI_V on_process_init();
         static PVAPI_V on_process_term();
         static void NTAPI on_tls_callback(HINSTANCE, DWORD, PVOID);
+    }
 
+    namespace boost
+    {
         //The .CRT$Xxx information is taken from Codeguru:
         //http://www.codeguru.com/Cpp/misc/misc/threadsprocesses/article.php/c6945__2/
 
+        // Variables below are not referenced anywhere and
+        // to not be optimized away has to have external linkage
+
 #if (_MSC_VER >= 1400)
 #pragma section(".CRT$XIU",long,read)
 #pragma section(".CRT$XCU",long,read)
 #pragma section(".CRT$XTU",long,read)
 #pragma section(".CRT$XLC",long,read)
-        __declspec(allocate(".CRT$XLC")) _TLSCB __xl_ca=on_tls_callback;
-        __declspec(allocate(".CRT$XIU"))_PIFV_ p_tls_prepare = on_tls_prepare;
-        __declspec(allocate(".CRT$XCU"))_PVFV_ p_process_init = on_process_init;
-        __declspec(allocate(".CRT$XTU"))_PVFV_ p_process_term = on_process_term;
+        extern const __declspec(allocate(".CRT$XLC")) _TLSCB p_tls_callback = on_tls_callback;
+        extern const __declspec(allocate(".CRT$XIU")) _PIFV_ p_tls_prepare = on_tls_prepare;
+        extern const __declspec(allocate(".CRT$XCU")) _PVFV_ p_process_init = on_process_init;
+        extern const __declspec(allocate(".CRT$XTU")) _PVFV_ p_process_term = on_process_term;
 #else
         #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
         #   pragma data_seg(push, old_seg)
@@ -176,30 +182,33 @@ extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) =
             //this could be changed easily if required.
 
             #pragma data_seg(".CRT$XIU")
-            static _PIFV_ p_tls_prepare = on_tls_prepare;
+            extern const _PIFV_ p_tls_prepare = on_tls_prepare;
             #pragma data_seg()
 
             //Callback after all global ctors.
 
             #pragma data_seg(".CRT$XCU")
-            static _PVFV_ p_process_init = on_process_init;
+            extern const _PVFV_ p_process_init = on_process_init;
             #pragma data_seg()
 
             //Callback for tls notifications.
 
             #pragma data_seg(".CRT$XLB")
-            _TLSCB p_thread_callback = on_tls_callback;
+            extern const _TLSCB p_thread_callback = on_tls_callback;
             #pragma data_seg()
             //Callback for termination.
 
             #pragma data_seg(".CRT$XTU")
-            static _PVFV_ p_process_term = on_process_term;
+            extern const _PVFV_ p_process_term = on_process_term;
             #pragma data_seg()
         #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0
         #   pragma data_seg(pop, old_seg)
         #endif
 #endif
+    } // namespace boost
 
+    namespace
+    {
 #ifdef BOOST_MSVC
 #pragma warning(push)
 #pragma warning(disable:4189)

test/Jamfile.v2

@@ -34,8 +34,7 @@ project
         <toolset>gcc:<cxxflags>-Wno-long-long
         #<toolset>gcc:<cxxflags>-ansi
         #<toolset>gcc:<cxxflags>-fpermissive
-        <toolset>gcc-4:<cxxflags>-Wno-variadic-macros
-        <toolset>gcc-5:<cxxflags>-Wno-variadic-macros
+        <toolset>gcc:<cxxflags>-Wno-variadic-macros
         #<toolset>gcc:<cxxflags>-Wunused-local-typedefs
         <toolset>gcc:<cxxflags>-Wunused-function
         <toolset>gcc:<cxxflags>-Wno-unused-parameter
@@ -62,6 +61,7 @@ project
         #<toolset>clang:<cxxflags>-fpermissive # doesn't work
         <toolset>clang:<cxxflags>-Wunused-function
         <toolset>clang:<cxxflags>-Wno-unused-parameter
+        <toolset>clang:<cxxflags>-Wno-c99-extensions
 
         #<toolset>gcc-mingw-4.4.0:<cxxflags>-fdiagnostics-show-option
         #<toolset>gcc-mingw-4.5.0:<cxxflags>-fdiagnostics-show-option
@@ -268,16 +268,15 @@ rule generate_self_contained_header_tests
 
     if ! [ os.environ BOOST_THREAD_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS ]
     {
-        local headers_path = [ path.make $(BOOST_ROOT)/libs/thread/include/boost/thread ] ;
-        for file in [ path.glob-tree $(headers_path) : *.hpp : detail pthread win32 ]
+        for file in [ glob-tree-ex ../include/boost/thread : *.hpp : detail pthread win32 ]
         {
-            local rel_file = [ path.relative-to $(headers_path) $(file) ] ;
+            local rel_file = [ path.relative-to ../include/boost/thread $(file) ] ;
             # Note: The test name starts with '~' in order to group these tests in the test report table, preferably at the end.
             #       All '/' are replaced with '-' because apparently test scripts have a problem with test names containing slashes.
             local test_name = [ regex.replace ~hdr/$(rel_file) "/" "-" ] ;
             #ECHO $(rel_file) ;
-            all_rules += [ compile self_contained_header.cpp : <define>"BOOST_THREAD_TEST_HEADER=$(rel_file)" <dependency>$(file) : $(test_name) ] ;
-            all_rules += [ compile self_contained_header.cpp : <define>"BOOST_THREAD_TEST_HEADER=$(rel_file)" <define>"BOOST_THREAD_TEST_POST_WINDOWS_H" <dependency>$(file) <conditional>@windows-cygwin-specific : $(test_name)-post_winh ] ;
+            all_rules += [ compile self_contained_header.cpp : <define>"BOOST_THREAD_TEST_HEADER=$(rel_file)" <dependency>$(file) <use>../build//boost_thread : $(test_name) ] ;
+            all_rules += [ compile self_contained_header.cpp : <define>"BOOST_THREAD_TEST_HEADER=$(rel_file)" <define>"BOOST_THREAD_TEST_POST_WINDOWS_H" <dependency>$(file) <conditional>@windows-cygwin-specific <use>../build//boost_thread : $(test_name)-post_winh ] ;
         }
     }
 
@@ -368,6 +367,10 @@ rule generate_self_contained_header_tests
           [ thread-run test_10964.cpp ]
           [ thread-test test_11053.cpp ]
           [ thread-run test_11266.cpp ]
+          [ thread-run test_366_1.cpp ]
+          [ thread-run test_366_2.cpp ]
+          [ thread-run test_366_3.cpp ]
+          [ thread-run test_366_4.cpp ]
     ;
 
 
@@ -1008,7 +1011,7 @@ rule generate_self_contained_header_tests
           #[ thread-run test_10128.cpp ]
           #[ thread-run test_10340.cpp ]
     ;
-    
+
     explicit ts_more_cpp11 ;
     test-suite ts_more_cpp11
     :
@@ -1029,13 +1032,13 @@ rule generate_self_contained_header_tests
     :
           [ thread-run2-noit ./experimental/parallel/v1/exception_list_pass.cpp : exception_list_p ]
     ;
-    
+
     #explicit ts_task_region ;
     test-suite ts_task_region
     :
           [ thread-run2-noit ./experimental/parallel/v2/task_region_pass.cpp : task_region_p ]
     ;
-    
+
     explicit ts_other ;
     test-suite ts_other
     :
@@ -1046,7 +1049,7 @@ rule generate_self_contained_header_tests
     explicit ts_ ;
     test-suite ts_
     :
-          #[ thread-run test_11256.cpp ] 
+          #[ thread-run test_11256.cpp ]
           #[ thread-run test_11256.cpp ]
           #[ thread-run test_11499.cpp ]
           #[ thread-run test_11611.cpp ]
@@ -1056,7 +1059,7 @@ rule generate_self_contained_header_tests
           #[ thread-run test_12949.cpp ]
           #[ thread-run test_13480b.cpp ]
           [ thread-run test_13561.cpp ]
-          
+
     ;
 
     explicit test_time_jumps_1_obj ;
@@ -1095,4 +1098,10 @@ rule generate_self_contained_header_tests
     ;
 
     test-suite test_self_contained_headers : [ generate_self_contained_header_tests ] ;
+
+    test-suite detail
+    :
+          [ run detail/string_trim_test.cpp ]
+          [ run detail/string_to_unsigned_test.cpp ]
+    ;
 }

test/detail/string_to_unsigned_test.cpp

@@ -0,0 +1,55 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/thread/detail/string_to_unsigned.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    using boost::thread_detail::string_to_unsigned;
+
+    unsigned v;
+
+    BOOST_TEST_NOT( string_to_unsigned( "", v ) ) && BOOST_TEST_EQ( v, 0 );
+    BOOST_TEST_NOT( string_to_unsigned( " ", v ) ) && BOOST_TEST_EQ( v, 0 );
+    BOOST_TEST_NOT( string_to_unsigned( "+1", v ) ) && BOOST_TEST_EQ( v, 0 );
+    BOOST_TEST_NOT( string_to_unsigned( "-1", v ) ) && BOOST_TEST_EQ( v, 0 );
+    BOOST_TEST_NOT( string_to_unsigned( "abc", v ) ) && BOOST_TEST_EQ( v, 0 );
+
+    BOOST_TEST( string_to_unsigned( "0", v ) ) && BOOST_TEST_EQ( v, 0 );
+    BOOST_TEST( string_to_unsigned( "1", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "12", v ) ) && BOOST_TEST_EQ( v, 12 );
+    BOOST_TEST( string_to_unsigned( "123", v ) ) && BOOST_TEST_EQ( v, 123 );
+    BOOST_TEST( string_to_unsigned( "1234", v ) ) && BOOST_TEST_EQ( v, 1234 );
+    BOOST_TEST( string_to_unsigned( "12345", v ) ) && BOOST_TEST_EQ( v, 12345 );
+    BOOST_TEST( string_to_unsigned( "123456", v ) ) && BOOST_TEST_EQ( v, 123456 );
+    BOOST_TEST( string_to_unsigned( "1234567", v ) ) && BOOST_TEST_EQ( v, 1234567 );
+    BOOST_TEST( string_to_unsigned( "12345678", v ) ) && BOOST_TEST_EQ( v, 12345678 );
+    BOOST_TEST( string_to_unsigned( "123456789", v ) ) && BOOST_TEST_EQ( v, 123456789 );
+    BOOST_TEST( string_to_unsigned( "1234567890", v ) ) && BOOST_TEST_EQ( v, 1234567890 );
+    BOOST_TEST_NOT( string_to_unsigned( "12345678901", v ) ) && BOOST_TEST_EQ( v, 1234567890 );
+    BOOST_TEST_NOT( string_to_unsigned( "123456789012", v ) ) && BOOST_TEST_EQ( v, 1234567890 );
+
+    BOOST_TEST( string_to_unsigned( "4294967295", v ) ) && BOOST_TEST_EQ( v, 4294967295 );
+    BOOST_TEST_NOT( string_to_unsigned( "4294967296", v ) ) && BOOST_TEST_EQ( v, 429496729 );
+
+    BOOST_TEST( string_to_unsigned( "01", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "001", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "0001", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "00001", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "000001", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "0000001", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "00000001", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "000000001", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "0000000001", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "00000000001", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "000000000001", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "0000000000001", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST( string_to_unsigned( "00000000000001", v ) ) && BOOST_TEST_EQ( v, 1 );
+
+    BOOST_TEST_NOT( string_to_unsigned( "1a", v ) ) && BOOST_TEST_EQ( v, 1 );
+    BOOST_TEST_NOT( string_to_unsigned( "2 ", v ) ) && BOOST_TEST_EQ( v, 2 );
+
+    return boost::report_errors();
+}

test/detail/string_trim_test.cpp

@@ -0,0 +1,48 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/thread/detail/string_trim.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    using boost::thread_detail::string_trim;
+
+    BOOST_TEST_EQ( string_trim( "" ), std::string( "" ) );
+    BOOST_TEST_EQ( string_trim( " " ), std::string( "" ) );
+    BOOST_TEST_EQ( string_trim( "  " ), std::string( "" ) );
+    BOOST_TEST_EQ( string_trim( "   " ), std::string( "" ) );
+
+    BOOST_TEST_EQ( string_trim( " \t\r\n \t\r\n" ), std::string( "" ) );
+
+    BOOST_TEST_EQ( string_trim( "a" ), std::string( "a" ) );
+
+    BOOST_TEST_EQ( string_trim( " a" ), std::string( "a" ) );
+    BOOST_TEST_EQ( string_trim( "  a" ), std::string( "a" ) );
+    BOOST_TEST_EQ( string_trim( "   a" ), std::string( "a" ) );
+
+    BOOST_TEST_EQ( string_trim( "a " ), std::string( "a" ) );
+    BOOST_TEST_EQ( string_trim( "a  " ), std::string( "a" ) );
+    BOOST_TEST_EQ( string_trim( "a   " ), std::string( "a" ) );
+
+    BOOST_TEST_EQ( string_trim( " a " ), std::string( "a" ) );
+    BOOST_TEST_EQ( string_trim( "  a  " ), std::string( "a" ) );
+    BOOST_TEST_EQ( string_trim( "   a   " ), std::string( "a" ) );
+
+    BOOST_TEST_EQ( string_trim( "a b" ), std::string( "a b" ) );
+
+    BOOST_TEST_EQ( string_trim( " a b" ), std::string( "a b" ) );
+    BOOST_TEST_EQ( string_trim( "  a b" ), std::string( "a b" ) );
+    BOOST_TEST_EQ( string_trim( "   a b" ), std::string( "a b" ) );
+
+    BOOST_TEST_EQ( string_trim( "a b " ), std::string( "a b" ) );
+    BOOST_TEST_EQ( string_trim( "a b  " ), std::string( "a b" ) );
+    BOOST_TEST_EQ( string_trim( "a b   " ), std::string( "a b" ) );
+
+    BOOST_TEST_EQ( string_trim( " a b " ), std::string( "a b" ) );
+    BOOST_TEST_EQ( string_trim( "  a  b  " ), std::string( "a  b" ) );
+    BOOST_TEST_EQ( string_trim( "   a   b   " ), std::string( "a   b" ) );
+
+    return boost::report_errors();
+}

test/experimental/parallel/v1/exception_list_pass.cpp

@@ -14,7 +14,7 @@
 
 #include <boost/thread/experimental/parallel/v1/exception_list.hpp>
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 
 int main()

test/experimental/parallel/v2/task_region_pass.cpp

@@ -16,7 +16,7 @@
 #include <boost/thread/experimental/parallel/v2/task_region.hpp>
 #include <string>
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 #if ! defined BOOST_NO_CXX11_LAMBDAS  && defined(BOOST_THREAD_PROVIDES_INVOKE)
 using boost::experimental::parallel::v2::task_region;

test/functional/invoke/invoke_int_0_pass.cpp

@@ -15,7 +15,7 @@
 // <boost/thread/detail/invoke.hpp>
 
 #include <boost/thread/detail/invoke.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 int f()
 {

test/functional/invoke/invoke_lvalue_pass.cpp

@@ -16,7 +16,7 @@
 // <boost/thread/detail/invoke.hpp>
 
 #include <boost/thread/detail/invoke.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 int count = 0;
 

test/functional/invoke/invoke_rvalue_pass.cpp

@@ -15,7 +15,7 @@
 // <boost/thread/detail/invoke.hpp>
 
 #include <boost/thread/detail/invoke.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 int count = 0;
 

test/functional/invoker/invoker_int_0_pass.cpp

@@ -15,7 +15,7 @@
 // <boost/thread/detail/invoker.hpp>
 
 #include <boost/thread/detail/invoker.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 int f()
 {

test/functional/invoker/invoker_lvalue_pass.cpp

@@ -15,7 +15,7 @@
 // <boost/thread/detail/invoker.hpp>
 
 #include <boost/thread/detail/invoker.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 int count = 0;
 

test/functional/invoker/invoker_rvalue_pass.cpp

@@ -19,7 +19,7 @@
 #endif
 
 #include <boost/thread/detail/invoker.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 int count = 0;
 

test/shared_mutex_locking_thread.hpp

@@ -7,6 +7,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
+#include <boost/config.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/shared_mutex.hpp>
@@ -38,6 +39,10 @@ public:
         finish_mutex(finish_mutex_)
     {}
 
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+    locking_thread(locking_thread const&) = default;
+#endif
+
     void operator()()
     {
         // acquire lock
@@ -84,6 +89,10 @@ public:
         unblocked_mutex(unblocked_mutex_),unblocked_count(unblocked_count_)
     {}
 
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+    simple_writing_thread(simple_writing_thread const&) = default;
+#endif
+
     void operator()()
     {
         boost::unique_lock<boost::shared_mutex>  lk(rwm);
@@ -115,6 +124,10 @@ public:
         unblocked_mutex(unblocked_mutex_),unblocked_count(unblocked_count_)
     {}
 
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+    simple_reading_thread(simple_reading_thread const&) = default;
+#endif
+
     void operator()()
     {
         boost::shared_lock<boost::shared_mutex>  lk(rwm);

test/sync/conditions/condition_variable/copy_fail.cpp

@@ -18,7 +18,7 @@
 // condition_variable(const condition_variable&) = delete;
 
 #include <boost/thread/condition_variable.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 void fail()
 {

test/sync/conditions/condition_variable/default_pass.cpp

@@ -18,7 +18,7 @@
 // condition_variable(const condition_variable&) = delete;
 
 #include <boost/thread/condition_variable.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 int main()
 {

test/sync/conditions/condition_variable/dtor_pass.cpp

@@ -21,7 +21,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/thread/locks.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 boost::condition_variable* cv;
 boost::mutex m;

test/sync/conditions/condition_variable/lost_notif_pass.cpp

@@ -21,7 +21,7 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <cassert>
 
 // Summary of each test:

test/sync/conditions/condition_variable/native_handle_pass.cpp

@@ -20,7 +20,8 @@
 #include <boost/thread/condition_variable.hpp>
 
 #include <boost/static_assert.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 int main()
 {

test/sync/conditions/condition_variable/wait_for_pass.cpp

@@ -21,7 +21,7 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <cassert>
 #include "../../../timming.hpp"
 

test/sync/conditions/condition_variable/wait_for_pred_pass.cpp

@@ -20,7 +20,8 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 #include <cassert>
 #include <iostream>
 #include "../../../timming.hpp"
@@ -64,9 +65,9 @@ void f()
     assert(test2 == 0);
     test1 = 1;
     cv.notify_one();
-    Clock::time_point t0 = Clock::now();
+    BOOST_ATTRIBUTE_UNUSED Clock::time_point t0 = Clock::now();
     cv.wait_for(lk, milliseconds(250), Pred(test2));
-    Clock::time_point t1 = Clock::now();
+    BOOST_ATTRIBUTE_UNUSED Clock::time_point t1 = Clock::now();
     if (runs == 0)
     {
       assert(t1 - t0 < max_diff);

test/sync/conditions/condition_variable/wait_pass.cpp

@@ -21,7 +21,7 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <cassert>
 #include <iostream>
 

test/sync/conditions/condition_variable/wait_until_pass.cpp

@@ -20,7 +20,7 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <iostream>
 #include <cassert>
 #include "../../../timming.hpp"

test/sync/conditions/condition_variable/wait_until_pred_pass.cpp

@@ -20,7 +20,8 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 #include <cassert>
 #include <iostream>
 #include "../../../timming.hpp"
@@ -79,7 +80,7 @@ void f()
     cv.notify_one();
     Clock::time_point t0 = Clock::now();
     Clock::time_point t = t0 + Clock::duration(250);
-    bool r = cv.wait_until(lk, t, Pred(test2));
+    BOOST_ATTRIBUTE_UNUSED bool r = cv.wait_until(lk, t, Pred(test2));
     Clock::time_point t1 = Clock::now();
     if (runs == 0)
     {

test/sync/conditions/condition_variable_any/copy_fail.cpp

@@ -18,7 +18,7 @@
 // condition_variable_any(const condition_variable_any&) = delete;
 
 #include <boost/thread/condition_variable.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 void fail()
 {

test/sync/conditions/condition_variable_any/default_pass.cpp

@@ -18,7 +18,7 @@
 // condition_variable_any(const condition_variable_any&) = delete;
 
 #include <boost/thread/condition_variable.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 int main()
 {

test/sync/conditions/condition_variable_any/dtor_pass.cpp

@@ -21,7 +21,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/thread/locks.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 boost::condition_variable_any* cv;
 boost::timed_mutex m;

test/sync/conditions/condition_variable_any/lost_notif_pass.cpp

@@ -21,7 +21,7 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <cassert>
 
 // Summary of each test:

test/sync/conditions/condition_variable_any/wait_for_pass.cpp

@@ -20,7 +20,7 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO

test/sync/conditions/condition_variable_any/wait_for_pred_pass.cpp

@@ -20,7 +20,7 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO

test/sync/conditions/condition_variable_any/wait_until_pass.cpp

@@ -20,7 +20,7 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO

test/sync/conditions/condition_variable_any/wait_until_pred_pass.cpp

@@ -20,7 +20,7 @@
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO

test/sync/conditions/cv_status/cv_status_pass.cpp

@@ -18,7 +18,7 @@
 // static unsigned hardware_concurrency();
 
 #include <boost/thread/condition_variable.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 int main()
 {

test/sync/conditions/notify_all_at_thread_exit_pass.cpp

@@ -23,7 +23,7 @@
 #include <boost/thread/locks.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/chrono/chrono.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 boost::condition_variable cv;
 boost::mutex mut;

test/sync/futures/async/async_executor_pass.cpp

@@ -29,7 +29,7 @@
 #include <boost/thread/detail/memory.hpp>
 #include <boost/thread/csbl/memory/unique_ptr.hpp>
 #include <memory>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/thread/executors/basic_thread_pool.hpp>
 #include <boost/thread/executor.hpp>
 

test/sync/futures/async/async_pass.cpp

@@ -34,7 +34,7 @@
 #include <boost/thread/detail/memory.hpp>
 #include <boost/thread/csbl/memory/unique_ptr.hpp>
 #include <memory>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 typedef boost::chrono::high_resolution_clock Clock;
 typedef boost::chrono::milliseconds ms;

test/sync/futures/future/async_deferred_then_pass.cpp

@@ -16,7 +16,7 @@
 #include <boost/thread/detail/log.hpp>
 
 #include <boost/thread/future.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 #if defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
 

test/sync/futures/future/copy_assign_fail.cpp

@@ -21,7 +21,7 @@
 
 #define BOOST_THREAD_VERSION 3
 #include <boost/thread/future.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 int main()
 {

test/sync/futures/future/copy_ctor_fail.cpp

@@ -20,7 +20,7 @@
 
 #define BOOST_THREAD_VERSION 3
 #include <boost/thread/future.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 int main()
 {