Increased BOOST_THREAD_TEST_TIME_MS yet more because of test failures on Windows.

Fixed more MSVC warnings about variables shadowing other variables.
Try to gracefully finish the timed_join test in case of timeout.
2026-07-21 13:33:33 +00:00 · 2026-07-03 21:57:51 +03:00 · 2026-07-03 19:17:31 +03:00 · 2026-07-03 19:17:31 +03:00 · 2026-07-03 19:17:31 +03:00 · 2026-07-03 19:17:31 +03:00
435 changed files with 4502 additions and 2694 deletions
@@ -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()
@@ -13,39 +13,46 @@ branches:
    - develop
    - /feature\/.*/

+image: Visual Studio 2015
+
 environment:
  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-#      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 2015
-      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 2015
-      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 2015
-      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 2015
-      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% --abbreviate-paths 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%
@@ -0,0 +1,45 @@
+# Copyright René Ferdinand Rivera Morell 2023-2024
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/assert//boost_assert
+    /boost/atomic//boost_atomic
+    /boost/bind//boost_bind
+    /boost/chrono//boost_chrono
+    /boost/concept_check//boost_concept_check
+    /boost/config//boost_config
+    /boost/container//boost_container
+    /boost/container_hash//boost_container_hash
+    /boost/core//boost_core
+    /boost/date_time//boost_date_time
+    /boost/exception//boost_exception
+    /boost/function//boost_function
+    /boost/io//boost_io
+    /boost/move//boost_move
+    /boost/optional//boost_optional
+    /boost/predef//boost_predef
+    /boost/preprocessor//boost_preprocessor
+    /boost/smart_ptr//boost_smart_ptr
+    /boost/system//boost_system
+    /boost/throw_exception//boost_throw_exception
+    /boost/tuple//boost_tuple
+    /boost/type_traits//boost_type_traits
+    /boost/utility//boost_utility
+    /boost/winapi//boost_winapi ;
+
+project /boost/thread
+    ;
+
+explicit
+    [ alias boost_thread : build//boost_thread ]
+    [ alias all : boost_thread example test ]
+    ;
+
+call-if : boost-library thread
+    : install boost_thread
+    ;
+
@@ -35,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 ;
@@ -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).
@@ -1,6 +1,6 @@
 [/
  (C) Copyright 2007-12 Anthony Williams.
-  (C) Copyright 20012 Vicente J. Botet Escriba.
+  (C) Copyright 2012 Vicente J. Botet Escriba.
  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
@@ -1,6 +1,6 @@
 [/
  (C) Copyright 2008-9 Anthony Williams.
-  (C) Copyright 12 Vicente J. Botet Escriba.
+  (C) Copyright 2012 Vicente J. Botet Escriba.
  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
@@ -4,7 +4,7 @@
 #  Distributed under the Boost Software License, Version 1.0. (See accompanying 
 #  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

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

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

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

-counter c;
+counter g_counter;

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

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

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

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

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

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

-counter c;
+counter g_counter;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 int main()
@@ -63,11 +62,11 @@ int main()
  }
  {
    {
-      boost::unique_lock<boost::mutex> lock(mutex);
+      boost::unique_lock<boost::mutex> lock(g_mutex);
      boost::thread* th2 = new boost::thread(&increment_count_2);
-      threads2.add_thread(th2);
+      g_threads2.add_thread(th2);
    }
-    threads2.join_all();
+    g_threads2.join_all();
  }
  return boost::report_errors();
 }
@@ -8,21 +8,21 @@
 #include <boost/thread/tss.hpp>
 #include <cassert>

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

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

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

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

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

 void job() {
  for (int i = 0; i < 10; ++i) {
-    boost::with_lock_guard(m, print_x);
+    boost::with_lock_guard(g_mutex, print_x);
    boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
  }
 }
@@ -31,10 +31,10 @@ void job() {
 void job() {
  for (int i = 0; i < 10; ++i) {
    boost::with_lock_guard(
-        m,
+        g_mutex,
        []() {
-          ++x;
-          std::cout << "x = " << x << std::endl;
+          ++g_x;
+          std::cout << "x = " << g_x << std::endl;
        }
    );
    boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
@@ -12,6 +12,7 @@
 //////////////////////////////////////////////////////////////////////////////

 #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;
@@ -12,6 +12,7 @@
 //////////////////////////////////////////////////////////////////////////////

 #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;
@@ -9,37 +9,14 @@
 #ifndef BOOST_CSBL_DEQUE_HPP
 #define BOOST_CSBL_DEQUE_HPP

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 namespace boost
 {
  namespace csbl
  {
-    using ::boost::movelib::unique_ptr;
-    using ::boost::movelib::make_unique;
-
+    using ::std::unique_ptr;
+    using ::boost::make_unique;
  }
 }
+
 #endif // header
@@ -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
@@ -9,28 +9,12 @@
 #ifndef BOOST_CSBL_TUPLE_HPP
 #define BOOST_CSBL_TUPLE_HPP

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

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

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

 namespace boost
 {
  namespace csbl
  {
-#if defined BOOST_THREAD_USES_BOOST_VECTOR
-    using ::boost::container::vector;
-#else
    using ::std::vector;
-#endif
-
  }
 }
+
 #endif // header
@@ -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
@@ -32,6 +32,7 @@
 #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>
@@ -85,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)
@@ -93,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)
@@ -101,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)
@@ -109,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)
@@ -0,0 +1,55 @@
+#ifndef BOOST_THREAD_DETAIL_STRING_TO_UNSIGNED_HPP_INCLUDED
+#define BOOST_THREAD_DETAIL_STRING_TO_UNSIGNED_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <string>
+#include <climits>
+
+namespace boost
+{
+namespace thread_detail
+{
+
+inline bool string_to_unsigned( std::string const& s, unsigned& v )
+{
+    v = 0;
+
+    if( s.empty() )
+    {
+        return false;
+    }
+
+    for( char const* p = s.c_str(); *p; ++p )
+    {
+        unsigned char ch = static_cast<unsigned char>( *p );
+
+        if( ch < '0' || ch > '9' )
+        {
+            return false;
+        }
+
+        if( v > UINT_MAX / 10 )
+        {
+            return false;
+        }
+
+        unsigned q = static_cast<unsigned>( ch - '0' );
+
+        if( v == UINT_MAX / 10 && q > UINT_MAX % 10 )
+        {
+            return false;
+        }
+
+        v = v * 10 + q;
+    }
+
+    return true;
+}
+
+} // namespace thread_detail
+} // namespace boost
+
+#endif // #ifndef BOOST_THREAD_DETAIL_STRING_TO_UNSIGNED_HPP_INCLUDED
@@ -0,0 +1,29 @@
+#ifndef BOOST_THREAD_DETAIL_STRING_TRIM_HPP_INCLUDED
+#define BOOST_THREAD_DETAIL_STRING_TRIM_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <string>
+
+namespace boost
+{
+namespace thread_detail
+{
+
+inline std::string string_trim( std::string const& s )
+{
+    std::size_t i = s.find_first_not_of( " \t\r\n" );
+
+    if( i == std::string::npos ) return std::string();
+
+    std::size_t j = s.find_last_not_of( " \t\r\n" );
+
+    return s.substr( i, j + 1 - i );
+}
+
+} // namespace thread_detail
+} // namespace boost
+
+#endif // #ifndef BOOST_THREAD_DETAIL_STRING_TRIM_HPP_INCLUDED
@@ -30,7 +30,6 @@
 #include <algorithm>
 #include <boost/core/ref.hpp>
 #include <boost/cstdint.hpp>
-#include <boost/bind/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;
@@ -704,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
@@ -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;
@@ -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.
@@ -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()()
    {
@@ -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;
  }
 }

@@ -19,14 +19,17 @@
 #include <boost/thread/detail/delete.hpp>
 #include <boost/core/no_exceptions_support.hpp>

-#include <boost/bind/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
 {

@@ -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/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>
-#include <boost/atomic.hpp>
+#endif

 #include <boost/config/abi_prefix.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>

@@ -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;
          }
@@ -58,7 +58,7 @@ namespace boost
          std::size_t page_size = ::sysconf( _SC_PAGESIZE);
 #endif
 #ifdef PTHREAD_STACK_MIN
-          if (size<PTHREAD_STACK_MIN) size=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);
@@ -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_);
@@ -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);
    }

    /**
@@ -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_);
@@ -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_);
@@ -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);
@@ -22,7 +22,9 @@
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/detail/invoke.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,
@@ -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;
@@ -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"
  }
 ]
@@ -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
@@ -19,6 +19,9 @@
 #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>
+#include <boost/core/no_exceptions_support.hpp>

 #ifdef __GLIBC__
 #include <sys/sysinfo.h>
@@ -33,10 +36,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>
@@ -187,7 +186,7 @@ namespace boost
 // Unhandled exceptions still cause the application to terminate
 //                 BOOST_CATCH(...)
 //                 {
-//                   throw;
+//                     throw;
 //
 //                     std::terminate();
 //                 }
@@ -214,12 +213,13 @@ namespace boost
                interrupt_enabled=false;
 #endif
            }
-            ~externally_launched_thread() {
-              BOOST_ASSERT(notify.empty());
-              notify.clear();
+            ~externally_launched_thread()
+            {
+                BOOST_ASSERT(notify.empty());
+                notify.clear();
 //#ifndef BOOST_NO_EXCEPTIONS
-              BOOST_ASSERT(async_states_.empty());
-              async_states_.clear();
+                BOOST_ASSERT(async_states_.empty());
+                async_states_.clear();
 //#endif
            }
            void run()
@@ -356,7 +356,7 @@ namespace boost
        }
        else
        {
-          return false;
+            return false;
        }
    }

@@ -375,8 +375,8 @@ namespace boost
                }
                if(!local_thread_info->done)
                {
-                  res=false;
-                  return true;
+                    res=false;
+                    return true;
                }
                do_join=!local_thread_info->join_started;

@@ -439,31 +439,31 @@ namespace boost

    namespace this_thread
    {
-      namespace no_interruption_point
-      {
-        namespace hidden
+        namespace no_interruption_point
        {
-          void BOOST_THREAD_DECL sleep_for_internal(const detail::platform_duration& ts)
-          {
-                if (ts > detail::platform_duration::zero())
+            namespace hidden
+            {
+                void BOOST_THREAD_DECL sleep_for_internal(const detail::platform_duration& ts)
                {
-                  // Use pthread_delay_np or nanosleep whenever possible here in the no_interruption_point
-                  // namespace because they do not provide an interruption point.
-    #   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
-    #     if defined(__IBMCPP__) ||  defined(_AIX)
-                  BOOST_VERIFY(!pthread_delay_np(const_cast<timespec*>(&ts.getTs())));
-    #     else
-                  BOOST_VERIFY(!pthread_delay_np(&ts.getTs()));
-    #     endif
-    #   elif defined(BOOST_HAS_NANOSLEEP)
-                  nanosleep(&ts.getTs(), 0);
-    #   else
-                  // This should never be reached due to BOOST_THREAD_SLEEP_FOR_IS_STEADY
-    #   endif
+                    if (ts > detail::platform_duration::zero())
+                    {
+                        // Use pthread_delay_np or nanosleep whenever possible here in the no_interruption_point
+                        // namespace because they do not provide an interruption point.
+#   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
+#       if defined(__IBMCPP__) ||  defined(_AIX)
+                        BOOST_VERIFY(!pthread_delay_np(const_cast<timespec*>(&ts.getTs())));
+#       else
+                        BOOST_VERIFY(!pthread_delay_np(&ts.getTs()));
+#       endif
+#   elif defined(BOOST_HAS_NANOSLEEP)
+                        nanosleep(&ts.getTs(), 0);
+#   else
+                        // This should never be reached due to BOOST_THREAD_SLEEP_FOR_IS_STEADY
+#   endif
+                    }
                }
-          }
+            }
        }
-      }

        void yield() BOOST_NOEXCEPT
        {
@@ -517,7 +517,7 @@ namespace boost
    unsigned thread::physical_concurrency() BOOST_NOEXCEPT
    {
 #ifdef __linux__
-        try {
+        BOOST_TRY {
            using namespace std;

            ifstream proc_cpuinfo ("/proc/cpuinfo");
@@ -535,24 +535,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;
                }
@@ -560,9 +572,10 @@ namespace boost
            // Fall back to hardware_concurrency() in case
            // /proc/cpuinfo is formatted differently than we expect.
            return cores.size() != 0 ? cores.size() : hardware_concurrency();
-        } catch(...) {
-          return hardware_concurrency();
+        } BOOST_CATCH(...) {
+            return hardware_concurrency();
        }
+        BOOST_CATCH_END
 #elif defined(__APPLE__)
        int count;
        size_t size=sizeof(count);
@@ -776,26 +789,25 @@ namespace boost

    BOOST_THREAD_DECL void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
    {
-      detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
-      if(current_thread_data)
-      {
-        current_thread_data->notify_all_at_thread_exit(&cond, lk.release());
-      }
+        detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
+        if(current_thread_data)
+        {
+            current_thread_data->notify_all_at_thread_exit(&cond, lk.release());
+        }
    }

 //#ifndef BOOST_NO_EXCEPTIONS
-namespace detail {
-
+namespace detail
+{
    void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
    {
-      detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
-      if(current_thread_data)
-      {
-        current_thread_data->make_ready_at_thread_exit(as);
-      }
+        detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
+        if(current_thread_data)
+        {
+            current_thread_data->make_ready_at_thread_exit(as);
+        }
    }
 }
 //#endif

-
 }
@@ -29,15 +29,16 @@
 #include <stdio.h>
 #include <windows.h>
 #include <boost/predef/platform.h>
+#include <boost/core/no_exceptions_support.hpp>

 #if BOOST_PLAT_WINDOWS_RUNTIME
 #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 +578,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 +650,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 +748,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)
                    {
@@ -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)
@@ -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
@@ -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)
@@ -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
@@ -110,18 +110,18 @@ project
        <toolset>msvc:<cxxflags>/wd6246
    ;

-rule thread-run ( sources )
+rule thread-run ( sources : reqs * )
 {
    sources = $(sources) winrt_init.cpp ;
    return
-    [ run $(sources) ../build//boost_thread ]
+    [ run $(sources) ../build//boost_thread : : : $(reqs) ]
    [ run $(sources) ../src/tss_null.cpp ../build//boost_thread/<link>static
-        : : : : $(sources[1]:B)_lib ]
+        : : : $(reqs) : $(sources[1]:B)_lib ]
    ;
 }


-rule thread-test ( sources )
+rule thread-test ( sources : reqs * )
 {
    sources = $(sources) winrt_init.cpp ;
    return
@@ -136,14 +136,14 @@ rule thread-test ( sources )
    ;
 }

-rule thread-run2 ( sources : name )
+rule thread-run2 ( sources : name : reqs * )
 {
    sources = $(sources) winrt_init.cpp ;
    return
-    [ run $(sources) ../build//boost_thread : : :
+    [ run $(sources) ../build//boost_thread : : : $(reqs)
      : $(name) ]
    [ run $(sources) ../src/tss_null.cpp ../build//boost_thread/<link>static
-        : : :
+        : : : $(reqs)
      : $(name)_lib ]
    ;
 }
@@ -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 ] ;
        }
    }

@@ -363,11 +362,18 @@ rule generate_self_contained_header_tests
          [ thread-run test_7571.cpp ]
          [ thread-run test_9319.cpp ]
          #[ thread-run test_9711.cpp ] This is an invalid use of ::then deferred.
-          [ thread-run test_9856.cpp ]
+          [ thread-run test_9856.cpp :
+              <toolset>gcc:<cxxflags>-fopenmp
+              <toolset>gcc:<linkflags>-fopenmp
+          ]
          [ thread-compile test_10963.cpp : : test_10963_c ]
          [ 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 +1014,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 +1035,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 +1052,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 +1062,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 +1101,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 ]
+    ;
 }
@@ -30,12 +30,16 @@ struct wait_for_flag
            flag(flag_)
        {}

+        check_flag(check_flag const& that):
+            flag(that.flag)
+        {}
+
        bool operator()() const
        {
            return flag;
        }
    private:
-        void operator=(check_flag&);
+        check_flag& operator=(check_flag const&);
    };


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

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

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

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

@@ -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()
 {
@@ -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()
 {
@@ -21,10 +21,10 @@
 #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;
+boost::condition_variable* g_cv;
+boost::mutex g_mutex;
 typedef boost::unique_lock<boost::mutex> Lock;

 bool f_ready = false;
@@ -32,33 +32,33 @@ bool g_ready = false;

 void f()
 {
-  Lock lk(m);
+  Lock lk(g_mutex);
  f_ready = true;
-  cv->notify_one();
-  cv->wait(lk);
-  delete cv;
+  g_cv->notify_one();
+  g_cv->wait(lk);
+  delete g_cv;
 }

 void g()
 {
-  Lock lk(m);
+  Lock lk(g_mutex);
  g_ready = true;
-  cv->notify_one();
+  g_cv->notify_one();
  while (!f_ready)
  {
-    cv->wait(lk);
+    g_cv->wait(lk);
  }
-  cv->notify_one();
+  g_cv->notify_one();
 }

 int main()
 {
-  cv = new boost::condition_variable;
+  g_cv = new boost::condition_variable;
  boost::thread th2(g);
-  Lock lk(m);
+  Lock lk(g_mutex);
  while (!g_ready)
  {
-    cv->wait(lk);
+    g_cv->wait(lk);
  }
  lk.unlock();
  boost::thread th1(f);
@@ -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:
@@ -60,7 +60,7 @@ bool threadIsWaiting()

 #ifdef BOOST_THREAD_USES_DATETIME

-boost::posix_time::milliseconds posix_wait_time(1000);
+boost::posix_time::milliseconds posix_wait_time(2000);

 template <typename F>
 void test_posix_wait_function(F f)
@@ -68,12 +68,14 @@ void test_posix_wait_function(F f)
    flag = false;
    waiting = false;
    boost::thread t(f);
+    boost::unique_lock<boost::mutex> lk(mut);
    while (!threadIsWaiting())
    {
-        boost::this_thread::sleep(boost::posix_time::milliseconds(1));
+        lk.unlock();
+        boost::this_thread::sleep(boost::posix_time::milliseconds(10));
+        lk.lock();
    }

-    boost::unique_lock<boost::mutex> lk(mut);
    boost::this_thread::sleep(boost::posix_time::milliseconds(500));
    boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::universal_time();
    flag = true;
@@ -82,7 +84,7 @@ void test_posix_wait_function(F f)
    t.join();
    boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::universal_time();

-    BOOST_TEST(t1 - t0 < boost::posix_time::milliseconds(250));
+    BOOST_TEST(t1 - t0 < boost::posix_time::milliseconds(500));
 }

 //------------------------------------------------------------------------------
@@ -131,7 +133,7 @@ void timed_wait_relative_with_pred()

 #ifdef BOOST_THREAD_USES_CHRONO

-boost::chrono::milliseconds chrono_wait_time(1000);
+boost::chrono::milliseconds chrono_wait_time(2000);

 template <typename F>
 void test_chrono_wait_function(F f)
@@ -139,12 +141,14 @@ void test_chrono_wait_function(F f)
    flag = false;
    waiting = false;
    boost::thread t(f);
+    boost::unique_lock<boost::mutex> lk(mut);
    while (!threadIsWaiting())
    {
-        boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
+        lk.unlock();
+        boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
+        lk.lock();
    }

-    boost::unique_lock<boost::mutex> lk(mut);
    boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
    boost::chrono::steady_clock::time_point t0 = boost::chrono::steady_clock::now();
    flag = true;
@@ -153,7 +157,7 @@ void test_chrono_wait_function(F f)
    t.join();
    boost::chrono::steady_clock::time_point t1 = boost::chrono::steady_clock::now();

-    BOOST_TEST(t1 - t0 < boost::chrono::milliseconds(250));
+    BOOST_TEST(t1 - t0 < boost::chrono::milliseconds(500));
 }

 //------------------------------------------------------------------------------
@@ -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()
 {
@@ -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"

@@ -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"
@@ -55,7 +56,7 @@ typedef boost::chrono::milliseconds milliseconds;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;

-const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
+BOOST_ATTRIBUTE_UNUSED const ms max_diff(BOOST_THREAD_TEST_TIME_MS);

 void f()
 {
@@ -64,9 +65,11 @@ 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();
+    (void)t0;
+    (void)t1;
    if (runs == 0)
    {
      assert(t1 - t0 < max_diff);
@@ -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>

@@ -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"
@@ -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,8 +80,9 @@ 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();
+    (void)r;
    if (runs == 0)
    {
      assert(t1 - t0 < max_diff);
@@ -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()
 {
@@ -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()
 {
@@ -21,10 +21,10 @@
 #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;
+boost::condition_variable_any* g_cv;
+boost::timed_mutex g_mutex;
 typedef boost::unique_lock<boost::timed_mutex> Lock;

 bool f_ready = false;
@@ -32,33 +32,33 @@ bool g_ready = false;

 void f()
 {
-  Lock lk(m);
+  Lock lk(g_mutex);
  f_ready = true;
-  cv->notify_one();
-  cv->wait(lk);
-  delete cv;
+  g_cv->notify_one();
+  g_cv->wait(lk);
+  delete g_cv;
 }

 void g()
 {
-  Lock lk(m);
+  Lock lk(g_mutex);
  g_ready = true;
-  cv->notify_one();
+  g_cv->notify_one();
  while (!f_ready)
  {
-    cv->wait(lk);
+    g_cv->wait(lk);
  }
-  cv->notify_one();
+  g_cv->notify_one();
 }

 int main()
 {
-  cv = new boost::condition_variable_any;
+  g_cv = new boost::condition_variable_any;
  boost::thread th2(g);
-  Lock lk(m);
+  Lock lk(g_mutex);
  while (!g_ready)
  {
-    cv->wait(lk);
+    g_cv->wait(lk);
  }
  lk.unlock();
  boost::thread th1(f);
@@ -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:
@@ -60,7 +60,7 @@ bool threadIsWaiting()

 #ifdef BOOST_THREAD_USES_DATETIME

-boost::posix_time::milliseconds posix_wait_time(1000);
+boost::posix_time::milliseconds posix_wait_time(2000);

 template <typename F>
 void test_posix_wait_function(F f)
@@ -68,12 +68,14 @@ void test_posix_wait_function(F f)
    flag = false;
    waiting = false;
    boost::thread t(f);
+    boost::unique_lock<boost::mutex> lk(mut);
    while (!threadIsWaiting())
    {
-        boost::this_thread::sleep(boost::posix_time::milliseconds(1));
+        lk.unlock();
+        boost::this_thread::sleep(boost::posix_time::milliseconds(10));
+        lk.lock();
    }

-    boost::unique_lock<boost::mutex> lk(mut);
    boost::this_thread::sleep(boost::posix_time::milliseconds(500));
    boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::universal_time();
    flag = true;
@@ -82,7 +84,7 @@ void test_posix_wait_function(F f)
    t.join();
    boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::universal_time();

-    BOOST_TEST(t1 - t0 < boost::posix_time::milliseconds(250));
+    BOOST_TEST(t1 - t0 < boost::posix_time::milliseconds(500));
 }

 //------------------------------------------------------------------------------
@@ -131,7 +133,7 @@ void timed_wait_relative_with_pred()

 #ifdef BOOST_THREAD_USES_CHRONO

-boost::chrono::milliseconds chrono_wait_time(1000);
+boost::chrono::milliseconds chrono_wait_time(2000);

 template <typename F>
 void test_chrono_wait_function(F f)
@@ -139,12 +141,14 @@ void test_chrono_wait_function(F f)
    flag = false;
    waiting = false;
    boost::thread t(f);
+    boost::unique_lock<boost::mutex> lk(mut);
    while (!threadIsWaiting())
    {
-        boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
+        lk.unlock();
+        boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
+        lk.lock();
    }

-    boost::unique_lock<boost::mutex> lk(mut);
    boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
    boost::chrono::steady_clock::time_point t0 = boost::chrono::steady_clock::now();
    flag = true;
@@ -153,7 +157,7 @@ void test_chrono_wait_function(F f)
    t.join();
    boost::chrono::steady_clock::time_point t1 = boost::chrono::steady_clock::now();

-    BOOST_TEST(t1 - t0 < boost::chrono::milliseconds(250));
+    BOOST_TEST(t1 - t0 < boost::chrono::milliseconds(500));
 }

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

@@ -106,12 +106,12 @@ int f0()
  return 3;
 }

-int i = 0;
+int g_i = 0;

 int& f1()
 {
  boost::this_thread::sleep_for(ms(200));
-  return i;
+  return g_i;
 }

 void f2()
@@ -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;
@@ -109,12 +109,12 @@ int f0()
  return 3;
 }

-int i = 0;
+int g_i = 0;

 int& f1()
 {
  boost::this_thread::sleep_for(ms(200));
-  return i;
+  return g_i;
 }

 void f2()
@@ -153,8 +153,8 @@ struct check_timer {
  boost::chrono::nanoseconds delay;
  Clock::time_point start;
  check_timer(boost::chrono::nanoseconds delay)
-  : delay(delay)
-  , start(Clock::now())
+    : delay(delay)
+    , start(Clock::now())
  {
  }
  ~check_timer() {
@@ -490,7 +490,7 @@ int main()
        check_timer timer(ms(500));
        res = &f.get();
      }
-      BOOST_TEST(res == &i);
+      BOOST_TEST(res == &g_i);
    }
    catch (std::exception& ex)
    {
@@ -513,7 +513,7 @@ int main()
        check_timer timer(ms(500));
        res = &f.get();
      }
-      BOOST_TEST(res == &i);
+      BOOST_TEST(res == &g_i);
    }
    catch (std::exception& ex)
    {
@@ -536,7 +536,7 @@ int main()
        check_timer timer(ms(500));
        res = &f.get();
      }
-      BOOST_TEST(res == &i);
+      BOOST_TEST(res == &g_i);
    }
    catch (std::exception& ex)
    {
@@ -560,7 +560,7 @@ int main()
        check_timer timer(ms(500));
        res = &f.get();
      }
-      BOOST_TEST(res == &i);
+      BOOST_TEST(res == &g_i);
    }
    catch (std::exception& ex)
    {
@@ -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)

--- a/Show More
+++ b/Show More