Merge branch 'develop'

Windows.h > windows.h

build/Jamfile.v2

@@ -238,6 +238,10 @@ rule usage-requirements ( properties * )
             # in that case?
         }
     }
+    if <threadapi>win32 in $(properties)
+    {
+        result += <define>BOOST_THREAD_WIN32 ;
+    }
 
     #if ! <toolset>vacpp in $(properties) || <toolset-vacpp:version>11.1 in $(properties) || <toolset-vacpp:version>12.1.0.1 in $(properties)  || <toolset-vacpp:version>12.1 in $(properties)
     #{
@@ -272,6 +276,10 @@ rule requirements ( properties * )
            result += <library>/boost/atomic//boost_atomic ; 
         } 
     } else {
+        if <threadapi>win32 in $(properties)
+        {
+            result += <define>BOOST_THREAD_WIN32 ;
+        }
         result += <define>BOOST_THREAD_USES_CHRONO ;
         result += <library>/boost/chrono//boost_chrono ;
     }
@@ -284,6 +292,7 @@ alias thread_sources
       win32/thread.cpp
       win32/tss_dll.cpp
       win32/tss_pe.cpp
+      win32/thread_primitives.cpp
       future.cpp
     : ## requirements ##
       <threadapi>win32

circle.yml

@@ -0,0 +1,184 @@
+# Copyright 2018 Tom Hughes
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+build_steps: &build_steps
+  steps:
+    - run:
+        name: Setup
+        command: |
+          PLATFORM=`uname`
+          if [ "${PLATFORM}" == "Linux" ]; then
+            sudo apt-get install -y software-properties-common apt-transport-https
+
+            # https://github.com/ilikenwf/apt-fast
+            sudo add-apt-repository -y ppa:apt-fast/stable
+            sudo apt-get update
+            sudo apt-get -y install apt-fast
+
+            sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+            wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
+            echo "deb https://apt.llvm.org/trusty/ llvm-toolchain-trusty-4.0 main" | sudo tee -a /etc/apt/sources.list
+            echo "deb https://apt.llvm.org/trusty/ llvm-toolchain-trusty-5.0 main" | sudo tee -a /etc/apt/sources.list
+            echo "deb https://apt.llvm.org/trusty/ llvm-toolchain-trusty-6.0 main" | sudo tee -a /etc/apt/sources.list
+            sudo apt-fast update
+            sudo apt-fast install -y $COMPILER
+          fi
+    - checkout
+    - run:
+        name: Install
+        command: |
+          BOOST_BRANCH=develop && [ "$CIRCLE_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          git submodule update --init tools/build
+          git submodule update --init libs/config
+          git submodule update --init tools/boostdep
+          mkdir -p libs/thread
+          cp -r $HOME/project/* libs/thread
+          python tools/boostdep/depinst/depinst.py thread
+          ./bootstrap.sh
+          ./b2 headers
+    - run:
+        name: Build
+        command: |
+          echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD <cxxflags>$DEFINES ;" > ~/user-config.jam
+          cd ../boost-root
+          ./b2 -j10 libs/thread/test toolset=$TOOLSET
+
+mac_build: &mac_build
+  macos:
+    xcode: "9.2.0"
+  <<: *build_steps
+
+linux_build: &linux_build
+  docker:
+    - image: circleci/buildpack-deps:trusty
+  <<: *build_steps
+
+
+version: 2
+jobs:
+  linux-g++-c++11:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++"
+      - CXXSTD: "c++11"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-g++-7-c++98:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++98"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-g++-7-c++11:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++11"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-g++-7-c++14:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++14"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-g++-7-c++1z:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "gcc"
+      - COMPILER: "g++-7"
+      - CXXSTD: "c++1z"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-clang++-4.0-c++98:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++98"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-clang++-4.0-c++11:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++11"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-clang++-4.0-c++14:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++14"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  linux-clang++-4.0-c++1z:
+    <<: *linux_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++-4.0"
+      - CXXSTD: "c++1z"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=100"
+
+  mac-clang++-c++98:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++98"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=170"
+
+  mac-clang++-c++11:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++11"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=170"
+
+  mac-clang++-c++14:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++14"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=170"
+
+  mac-clang++-c++1z:
+    <<: *mac_build
+    environment:
+      - TOOLSET: "clang"
+      - COMPILER: "clang++"
+      - CXXSTD: "c++1z"
+      - DEFINES: "-DBOOST_THREAD_TEST_TIME_MS=170"
+
+workflows:
+  version: 2
+  continous:
+    jobs:
+      - linux-g++-c++11
+      - linux-g++-7-c++98
+      - linux-g++-7-c++11
+      - linux-g++-7-c++14
+      - linux-g++-7-c++1z
+      - linux-clang++-4.0-c++98
+      - linux-clang++-4.0-c++11
+      - linux-clang++-4.0-c++14
+      - linux-clang++-4.0-c++1z
+      - mac-clang++-c++98
+      - mac-clang++-c++11
+      - mac-clang++-c++14
+      - mac-clang++-c++1z
+

doc/changes.qbk

@@ -1,6 +1,6 @@
 [/
   (C) Copyright 2007-11 Anthony Williams.
-  (C) Copyright 2011-17 Vicente J. Botet Escriba.
+  (C) Copyright 2011-18 Vicente J. Botet Escriba.
   Distributed under the Boost Software License, Version 1.0.
   (See accompanying file LICENSE_1_0.txt or copy at
   http://www.boost.org/LICENSE_1_0.txt).
@@ -8,6 +8,27 @@
 
 [section:changes History]
 
+[heading Version 4.8.1 - boost 1.67]
+
+[*Know Bugs:]
+
+* [@http://svn.boost.org/trac/boost/ticket/3926 #3926] thread_specific_ptr + dlopen library causes a SIGSEGV.
+
+* [@http://svn.boost.org/trac/boost/ticket/10964 #10964] future<future<T>>::unwrap().then() Deadlocks
+
+
+Please take a look at [@https://svn.boost.org/trac/boost/query?status=assigned&status=new&status=reopened&component=thread&type=!Feature+Requests&col=id&col=summary&order=id thread Know Bugs] to see the current state.
+
+Please take a look at [@http://www.boost.org/development/tests/master/developer/thread.html thread master regression test] to see the last regression test snapshot.
+
+[*Fixed Bugs:]
+
+
+* [@https://github.com/boostorg/thread/issues/162 #162] fix as much time-related issues as possible and improve the QOI
+* [@https://github.com/boostorg/thread/issues/193 #193] future_then unit test contains two different implementations of do_continuation function
+* [@https://github.com/boostorg/thread/issues/209 #209] Legal problem with `win32/thread_primitives.hpp`
+
+
 [heading Version 4.8.0 - boost 1.66]
 
 [*Know Bugs:]

include/boost/thread/detail/config.hpp

@@ -123,7 +123,7 @@
 
 /// RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
 //#if defined BOOST_NO_CXX11_RVALUE_REFERENCES || defined BOOST_MSVC
-#define BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR
+#define BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNCTION_PTR
 //#endif
 
 // Default version
@@ -417,6 +417,11 @@
   #define BOOST_THREAD_INTERNAL_CLOCK_IS_MONO
 #elif defined(BOOST_THREAD_CHRONO_MAC_API)
   #define BOOST_THREAD_HAS_MONO_CLOCK
+#elif defined(__ANDROID__)
+  #define BOOST_THREAD_HAS_MONO_CLOCK
+  #if defined(__ANDROID_API__) && __ANDROID_API__ >= 21
+    #define BOOST_THREAD_INTERNAL_CLOCK_IS_MONO
+  #endif
 #else
   #include <time.h> // check for CLOCK_MONOTONIC
   #if defined(CLOCK_MONOTONIC)

include/boost/thread/detail/platform.hpp

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

include/boost/thread/detail/platform_time.hpp

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

include/boost/thread/detail/thread.hpp

@@ -513,7 +513,7 @@ namespace boost
         }
 
         template<typename TimeDuration>
-        inline bool timed_join(TimeDuration const& rel_time)
+        bool timed_join(TimeDuration const& rel_time)
         {
           detail::platform_duration d(rel_time);
 #if defined(BOOST_THREAD_HAS_MONO_CLOCK) && !defined(BOOST_THREAD_INTERNAL_CLOCK_IS_MONO)
@@ -811,6 +811,7 @@ namespace boost
         };
 
         void BOOST_THREAD_DECL add_thread_exit_function(thread_exit_function_base*);
+//#ifndef BOOST_NO_EXCEPTIONS
         struct shared_state_base;
 #if defined(BOOST_THREAD_PLATFORM_WIN32)
         inline void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
@@ -824,6 +825,7 @@ namespace boost
 #else
         void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as);
 #endif
+//#endif
     }
 
     namespace this_thread

include/boost/thread/future.hpp

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

include/boost/thread/pthread/thread_data.hpp

@@ -130,9 +130,10 @@ namespace boost
             > notify_list_t;
             notify_list_t notify;
 
+//#ifndef BOOST_NO_EXCEPTIONS
             typedef std::vector<shared_ptr<shared_state_base> > async_states_t;
             async_states_t async_states_;
-
+//#endif
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
             // These data must be at the end so that the access to the other fields doesn't change
             // when BOOST_THREAD_PROVIDES_INTERRUPTIONS is defined.
@@ -148,8 +149,10 @@ namespace boost
                 cond_mutex(0),
                 current_cond(0),
 //#endif
-                notify(),
-                async_states_()
+                notify()
+//#ifndef BOOST_NO_EXCEPTIONS
+                , async_states_()
+//#endif
 //#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
                 , interrupt_enabled(true)
                 , interrupt_requested(false)
@@ -165,11 +168,12 @@ namespace boost
               notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
             }
 
+//#ifndef BOOST_NO_EXCEPTIONS
             void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
             {
               async_states_.push_back(as);
             }
-
+//#endif
         };
 
         BOOST_THREAD_DECL thread_data_base* get_current_thread_data();
@@ -264,7 +268,7 @@ namespace boost
         }
 
         template<typename TimeDuration>
-        inline void sleep(TimeDuration const& rel_time)
+        void sleep(TimeDuration const& rel_time)
         {
           mutex mx;
           unique_lock<mutex> lock(mx);
@@ -275,7 +279,7 @@ namespace boost
 
 #ifdef BOOST_THREAD_USES_CHRONO
         template <class Clock, class Duration>
-        inline void sleep_until(const chrono::time_point<Clock, Duration>& t)
+        void sleep_until(const chrono::time_point<Clock, Duration>& t)
         {
           mutex mut;
           unique_lock<mutex> lk(mut);
@@ -284,7 +288,7 @@ namespace boost
         }
 
         template <class Rep, class Period>
-        inline void sleep_for(const chrono::duration<Rep, Period>& d)
+        void sleep_for(const chrono::duration<Rep, Period>& d)
         {
           mutex mut;
           unique_lock<mutex> lk(mut);
@@ -322,7 +326,7 @@ namespace boost
           }
 
           template<typename TimeDuration>
-          inline void sleep(TimeDuration const& rel_time)
+          void sleep(TimeDuration const& rel_time)
           {
             hidden::sleep_for_internal(detail::platform_duration(rel_time));
           }
@@ -330,19 +334,19 @@ namespace boost
 
 #ifdef BOOST_THREAD_USES_CHRONO
           template <class Rep, class Period>
-          inline void sleep_for(const chrono::duration<Rep, Period>& d)
+          void sleep_for(const chrono::duration<Rep, Period>& d)
           {
             hidden::sleep_for_internal(detail::platform_duration(d));
           }
 
           template <class Duration>
-          inline void sleep_until(const chrono::time_point<chrono::steady_clock, Duration>& t)
+          void sleep_until(const chrono::time_point<chrono::steady_clock, Duration>& t)
           {
             sleep_for(t - chrono::steady_clock::now());
           }
 
           template <class Clock, class Duration>
-          inline void sleep_until(const chrono::time_point<Clock, Duration>& t)
+          void sleep_until(const chrono::time_point<Clock, Duration>& t)
           {
             typedef typename common_type<Duration, typename Clock::duration>::type common_duration;
             common_duration d(t - Clock::now());
@@ -370,7 +374,7 @@ namespace boost
           }
 
           template<typename TimeDuration>
-          inline void sleep(TimeDuration const& rel_time)
+          void sleep(TimeDuration const& rel_time)
           {
             this_thread::sleep(rel_time);
           }
@@ -378,13 +382,13 @@ namespace boost
 
 #ifdef BOOST_THREAD_USES_CHRONO
           template <class Clock, class Duration>
-          inline void sleep_until(const chrono::time_point<Clock, Duration>& t)
+          void sleep_until(const chrono::time_point<Clock, Duration>& t)
           {
             this_thread::sleep_until(t);
           }
 
           template <class Rep, class Period>
-          inline void sleep_for(const chrono::duration<Rep, Period>& d)
+          void sleep_for(const chrono::duration<Rep, Period>& d)
           {
             this_thread::sleep_for(d);
           }

include/boost/thread/v2/shared_mutex.hpp

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

include/boost/thread/win32/once.hpp

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

include/boost/thread/win32/thread_data.hpp

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

include/boost/thread/win32/thread_primitives.hpp

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

src/future.cpp

@@ -4,7 +4,14 @@
 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/thread/detail/config.hpp>
-#ifndef BOOST_NO_EXCEPTIONS
+
+#ifdef BOOST_NO_EXCEPTIONS
+namespace boost
+{
+    void shared_state_base::notify_deferred() {}
+}
+
+#else
 
 
 #include <boost/thread/futures/future_error_code.hpp>

src/pthread/thread.cpp

@@ -27,9 +27,9 @@
 #include <unistd.h>
 #endif
 
-#if defined(__VXWORKS__) 
+#if defined(__VXWORKS__)
 #include <vxCpuLib.h>
-#endif 
+#endif
 
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/trim.hpp>
@@ -53,11 +53,13 @@ namespace boost
                 i->second->unlock();
                 i->first->notify_all();
             }
+//#ifndef BOOST_NO_EXCEPTIONS
             for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                     i != e; ++i)
             {
                 (*i)->notify_deferred();
             }
+//#endif
         }
 
         struct thread_exit_callback_node
@@ -213,8 +215,10 @@ namespace boost
             ~externally_launched_thread() {
               BOOST_ASSERT(notify.empty());
               notify.clear();
+//#ifndef BOOST_NO_EXCEPTIONS
               BOOST_ASSERT(async_states_.empty());
               async_states_.clear();
+//#endif
             }
             void run()
             {}
@@ -498,9 +502,9 @@ namespace boost
            set &= set -1;
         }
         return(i);
-  #else  
+  #else
         return (__builtin_popcount(set) );
-  #endif  
+  #endif
 #elif defined(__GLIBC__)
         return get_nprocs();
 #else
@@ -773,6 +777,8 @@ namespace boost
         current_thread_data->notify_all_at_thread_exit(&cond, lk.release());
       }
     }
+
+//#ifndef BOOST_NO_EXCEPTIONS
 namespace detail {
 
     void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
@@ -784,7 +790,7 @@ namespace detail {
       }
     }
 }
-
+//#endif
 
 
 }

src/win32/thread.cpp

@@ -54,11 +54,13 @@ namespace boost
             i->second->unlock();
             i->first->notify_all();
         }
+//#ifndef BOOST_NO_EXCEPTIONS
         for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
                 i != e; ++i)
         {
             (*i)->notify_deferred();
         }
+//#endif
     }
   }
 
@@ -370,8 +372,10 @@ namespace boost
             ~externally_launched_thread() {
               BOOST_ASSERT(notify.empty());
               notify.clear();
+//#ifndef BOOST_NO_EXCEPTIONS
               BOOST_ASSERT(async_states_.empty());
               async_states_.clear();
+//#endif
             }
 
             void run()

src/win32/thread_primitives.cpp

@@ -0,0 +1,140 @@
+//  thread_primitives.cpp
+//
+//  (C) Copyright 2018 Andrey Semashev
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/winapi/config.hpp>
+#include <boost/winapi/dll.hpp>
+#include <boost/winapi/time.hpp>
+#include <boost/winapi/event.hpp>
+#include <boost/winapi/handles.hpp>
+#include <boost/winapi/thread_pool.hpp>
+#include <cstdlib>
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/memory_order.hpp>
+#include <boost/atomic/atomic.hpp>
+#include <boost/thread/win32/interlocked_read.hpp>
+#include <boost/thread/win32/thread_primitives.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+
+#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
+
+// Directly use API from Vista and later
+BOOST_THREAD_DECL boost::detail::win32::detail::gettickcount64_t gettickcount64 = &::boost::winapi::GetTickCount64;
+
+#else // BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
+
+namespace {
+
+enum init_state
+{
+    uninitialized = 0,
+    in_progress,
+    initialized
+};
+
+struct get_tick_count64_state
+{
+    boost::atomic< uint64_t > ticks;
+    boost::atomic< init_state > init;
+    boost::winapi::HANDLE_ wait_event;
+    boost::winapi::HANDLE_ wait_handle;
+};
+
+// Zero-initialized initially
+BOOST_ALIGNMENT(64) static get_tick_count64_state g_state;
+
+//! Artifical implementation of GetTickCount64
+ticks_type WINAPI get_tick_count64()
+{
+    uint64_t old_state = g_state.ticks.load(boost::memory_order_acquire);
+
+    uint32_t new_ticks = boost::winapi::GetTickCount();
+
+    uint32_t old_ticks = static_cast< uint32_t >(old_state & UINT64_C(0x00000000ffffffff));
+    uint64_t new_state = ((old_state & UINT64_C(0xffffffff00000000)) + (static_cast< uint64_t >(new_ticks < old_ticks) << 32)) | static_cast< uint64_t >(new_ticks);
+
+    g_state.ticks.store(new_state, boost::memory_order_release);
+
+    return new_state;
+}
+
+//! The function is called periodically in the system thread pool to make sure g_state.ticks is timely updated
+void NTAPI refresh_get_tick_count64(boost::winapi::PVOID_, boost::winapi::BOOLEAN_)
+{
+    get_tick_count64();
+}
+
+//! Cleanup function to stop get_tick_count64 refreshes
+void cleanup_get_tick_count64()
+{
+    if (g_state.wait_handle)
+    {
+        boost::winapi::UnregisterWait(g_state.wait_handle);
+        g_state.wait_handle = NULL;
+    }
+
+    if (g_state.wait_event)
+    {
+        boost::winapi::CloseHandle(g_state.wait_event);
+        g_state.wait_event = NULL;
+    }
+}
+
+ticks_type WINAPI get_tick_count_init()
+{
+    boost::winapi::HMODULE_ hKernel32 = boost::winapi::GetModuleHandleW(L"kernel32.dll");
+    if (hKernel32)
+    {
+        boost::detail::win32::detail::gettickcount64_t p =
+            (boost::detail::win32::detail::gettickcount64_t)boost::winapi::get_proc_address(hKernel32, "GetTickCount64");
+        if (p)
+        {
+            // Use native API
+            boost::detail::interlocked_write_release((void**)&gettickcount64, (void*)p);
+            return p();
+        }
+    }
+
+    // No native API available. Use emulation with periodic refreshes to make sure the GetTickCount wrap arounds are properly counted.
+    init_state old_init = uninitialized;
+    if (g_state.init.compare_exchange_strong(old_init, in_progress, boost::memory_order_acq_rel, boost::memory_order_relaxed))
+    {
+        if (!g_state.wait_event)
+            g_state.wait_event = boost::winapi::create_anonymous_event(NULL, false, false);
+        if (g_state.wait_event)
+        {
+            boost::winapi::BOOL_ res = boost::winapi::RegisterWaitForSingleObject(&g_state.wait_handle, g_state.wait_event, &refresh_get_tick_count64, NULL, 0x7fffffff, boost::winapi::WT_EXECUTEINWAITTHREAD_);
+            if (res)
+            {
+                std::atexit(&cleanup_get_tick_count64);
+
+                boost::detail::interlocked_write_release((void**)&gettickcount64, (void*)&get_tick_count64);
+                g_state.init.store(initialized, boost::memory_order_release);
+                goto finish;
+            }
+        }
+
+        g_state.init.store(uninitialized, boost::memory_order_release);
+    }
+
+finish:
+    return get_tick_count64();
+}
+
+} // namespace
+
+BOOST_THREAD_DECL boost::detail::win32::detail::gettickcount64_t gettickcount64 = &get_tick_count_init;
+
+#endif // BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
+
+} // namespace win32
+} // namespace detail
+} // namespace boost

test/Jamfile.v2

@@ -970,7 +970,8 @@ rule thread-compile ( sources : reqs * : name )
           #[ thread-run test_11818.cpp ]
           #[ thread-run test_11796.cpp ]
           #[ thread-run test_12293.cpp ]
-          [ thread-run test_12949.cpp ]
+          #[ thread-run test_12949.cpp ]
+          [ thread-run test_13480b.cpp ]
           
     ;
 

test/sync/conditions/condition_variable/wait_for_pass.cpp

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

test/sync/conditions/condition_variable/wait_for_pred_pass.cpp

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

test/sync/conditions/condition_variable/wait_until_pass.cpp

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

test/sync/conditions/condition_variable/wait_until_pred_pass.cpp

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

test/sync/conditions/condition_variable_any/wait_for_pass.cpp

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

test/sync/conditions/condition_variable_any/wait_for_pred_pass.cpp

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

test/sync/conditions/condition_variable_any/wait_until_pass.cpp

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

test/sync/conditions/condition_variable_any/wait_until_pred_pass.cpp

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

test/sync/futures/future/wait_for_pass.cpp

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

test/sync/futures/future/wait_until_pass.cpp

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

test/sync/futures/shared_future/wait_for_pass.cpp

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

test/sync/futures/shared_future/wait_until_pass.cpp

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

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

@@ -22,6 +22,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -32,11 +33,7 @@ typedef boost::chrono::nanoseconds ns;
 #endif
 boost::mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -49,7 +46,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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

@@ -22,6 +22,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -33,11 +34,7 @@ typedef boost::chrono::nanoseconds ns;
 
 boost::mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -49,7 +46,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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

@@ -23,6 +23,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 
 #ifdef BOOST_THREAD_USES_CHRONO
@@ -36,11 +37,7 @@ boost::mutex m;
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -54,7 +51,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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

@@ -24,6 +24,7 @@
 #include <boost/thread/thread.hpp>
 
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -37,11 +38,7 @@ boost::mutex m;
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_LOCK_GUARD && defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -52,7 +49,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 #endif
 

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

@@ -14,6 +14,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -25,11 +26,7 @@ typedef boost::chrono::nanoseconds ns;
 
 boost::mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -42,7 +39,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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

@@ -16,6 +16,7 @@
 #include <boost/thread/thread.hpp>
 
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -29,11 +30,7 @@ boost::mutex m;
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_NESTED_STRICT_LOCK && defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -45,7 +42,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 #endif
 

test/sync/mutual_exclusion/locks/shared_lock/cons/duration_pass.cpp

@@ -24,6 +24,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/chrono/chrono_io.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -33,11 +34,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -46,7 +43,7 @@ void f1()
   BOOST_TEST(lk.owns_lock() == true);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -56,7 +53,7 @@ void f2()
   BOOST_TEST(lk.owns_lock() == false);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()

test/sync/mutual_exclusion/locks/shared_lock/cons/mutex_pass.cpp

@@ -18,11 +18,11 @@
 
 // explicit shared_lock(Mutex& m);
 
-
 #include <boost/thread/lock_types.hpp>
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -35,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -51,7 +47,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

test/sync/mutual_exclusion/locks/shared_lock/cons/time_point_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -32,11 +33,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -45,7 +42,7 @@ void f1()
   BOOST_TEST(lk.owns_lock() == true);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -55,7 +52,7 @@ void f2()
   BOOST_TEST(lk.owns_lock() == false);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()

test/sync/mutual_exclusion/locks/shared_lock/cons/try_to_lock_pass.cpp

@@ -18,11 +18,11 @@
 
 // shared_lock(mutex_type& m, try_to_lock_t);
 
-
 #include <boost/thread/lock_types.hpp>
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -35,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -64,7 +60,7 @@ void f()
   }
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
 //  time_point t0 = Clock::now();
 //  {

test/sync/mutual_exclusion/locks/shared_lock/locking/lock_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -35,11 +36,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -50,7 +47,7 @@ void f()
   time_point t1 = Clock::now();
   BOOST_TEST(lk.owns_lock() == true);
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   try
   {
     lk.lock();

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

@@ -22,6 +22,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -34,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 
 boost::shared_mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -51,7 +48,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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

@@ -23,6 +23,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include  <iostream>
+#include "../../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -35,11 +36,7 @@ typedef boost::chrono::nanoseconds ns;
 
 boost::shared_mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -51,8 +48,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
-  std::cout << "diff= " << d.count() << std::endl;
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

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

@@ -13,6 +13,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -24,11 +25,7 @@ typedef boost::chrono::nanoseconds ns;
 
 boost::mutex m;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -40,7 +37,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

test/sync/mutual_exclusion/locks/strict_lock/make_strict_lock_pass.cpp

@@ -15,6 +15,7 @@
 #include <boost/thread/thread.hpp>
 
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../timming.hpp"
 
 #ifdef BOOST_THREAD_USES_CHRONO
 typedef boost::chrono::high_resolution_clock Clock;
@@ -28,11 +29,7 @@ boost::mutex m;
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && ! defined BOOST_THREAD_NO_MAKE_STRICT_LOCK && defined BOOST_THREAD_USES_CHRONO
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -43,7 +40,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 #endif
 

test/sync/mutual_exclusion/locks/unique_lock/cons/duration_pass.cpp

@@ -26,6 +26,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/chrono/chrono_io.hpp>
+#include "../../../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -37,11 +38,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -50,7 +47,7 @@ void f1()
   BOOST_TEST(lk.owns_lock() == true);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()

test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_mutex_pass.cpp

@@ -15,6 +15,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 //#if ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 
@@ -30,11 +31,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -52,7 +49,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_lock_try_to_lock_pass.cpp

@@ -15,6 +15,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::mutex m;
 
@@ -27,11 +28,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -47,7 +44,7 @@ void f()
     BOOST_TEST(lk.owns_lock() == false);
     time_point t1 = Clock::now();
     ns d = t1 - t0 - ms(250);
-    BOOST_TEST(d < max_diff);
+    BOOST_THREAD_TEST_IT(d, ns(max_diff));
   }
   {
     time_point t0 = Clock::now();
@@ -60,7 +57,7 @@ void f()
     BOOST_TEST(lk.owns_lock() == false);
     time_point t1 = Clock::now();
     ns d = t1 - t0 - ms(250);
-    BOOST_TEST(d < max_diff);
+    BOOST_THREAD_TEST_IT(d, ns(max_diff));
   }
   {
     time_point t0 = Clock::now();
@@ -73,7 +70,7 @@ void f()
     BOOST_TEST(lk.owns_lock() == false);
     time_point t1 = Clock::now();
     ns d = t1 - t0 - ms(250);
-    BOOST_TEST(d < max_diff);
+    BOOST_THREAD_TEST_IT(d, ns(max_diff));
   }
   {
     time_point t0 = Clock::now();
@@ -89,7 +86,7 @@ void f()
     }
     time_point t1 = Clock::now();
     ns d = t1 - t0 - ms(250);
-    BOOST_TEST(d < max_diff);
+    BOOST_THREAD_TEST_IT(d, ns(max_diff));
   }
 #else
 //  time_point t0 = Clock::now();

test/sync/mutual_exclusion/locks/unique_lock/cons/make_unique_locks_mutex_pass.cpp

@@ -14,6 +14,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 #if ! defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && ! defined BOOST_THREAD_NO_MAKE_UNIQUE_LOCKS && ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
 
@@ -32,11 +33,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -48,7 +45,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

test/sync/mutual_exclusion/locks/unique_lock/cons/mutex_pass.cpp

@@ -24,6 +24,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 
 boost::mutex m;
@@ -37,11 +38,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -53,9 +50,7 @@ void f()
     t1 = Clock::now();
   }
   ns d = t1 - t0 - ms(250);
-  std::cout << "diff= " << d.count() << std::endl;
-  std::cout << "max_diff= " << max_diff.count() << std::endl;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

test/sync/mutual_exclusion/locks/unique_lock/cons/time_point_pass.cpp

@@ -25,6 +25,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -36,11 +37,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -49,7 +46,7 @@ void f1()
   BOOST_TEST(lk.owns_lock() == true);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()

test/sync/mutual_exclusion/locks/unique_lock/cons/try_to_lock_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 
 boost::mutex m;
@@ -36,11 +37,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -66,9 +63,7 @@ void f()
   time_point t1 = Clock::now();
   //m.unlock();
   ns d = t1 - t0 - ms(250);
-  std::cout << "diff= " << d.count() << std::endl;
-  std::cout << "max_diff= " << max_diff.count() << std::endl;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
 //  time_point t0 = Clock::now();
 //  {

test/sync/mutual_exclusion/locks/unique_lock/locking/lock_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 boost::mutex m;
 
@@ -35,11 +36,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -50,7 +47,7 @@ void f()
   time_point t1 = Clock::now();
   BOOST_TEST(lk.owns_lock() == true);
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   try
   {
     lk.lock();

test/sync/mutual_exclusion/locks/upgrade_lock/cons/duration_pass.cpp

@@ -26,6 +26,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/chrono/chrono_io.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -35,11 +36,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -48,7 +45,7 @@ void f1()
   BOOST_TEST(lk.owns_lock() == true);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -58,7 +55,7 @@ void f2()
   BOOST_TEST(lk.owns_lock() == false);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()

test/sync/mutual_exclusion/locks/upgrade_lock/cons/mutex_pass.cpp

@@ -24,6 +24,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -36,11 +37,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -54,7 +51,7 @@ void f()
   ns d = t1 - t0 - ms(250);
   std::cout << "diff= " << d.count() << std::endl;
   std::cout << "max_diff= " << max_diff.count() << std::endl;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //time_point t1;

test/sync/mutual_exclusion/locks/upgrade_lock/cons/time_point_pass.cpp

@@ -25,6 +25,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -34,11 +35,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -47,7 +44,7 @@ void f1()
   BOOST_TEST(lk.owns_lock() == true);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -57,7 +54,7 @@ void f2()
   BOOST_TEST(lk.owns_lock() == false);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()

test/sync/mutual_exclusion/locks/upgrade_lock/cons/try_to_lock_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -35,11 +36,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -65,7 +62,7 @@ void f()
   time_point t1 = Clock::now();
   //m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
 //  time_point t0 = Clock::now();
 //  {

test/sync/mutual_exclusion/locks/upgrade_lock/locking/lock_pass.cpp

@@ -23,6 +23,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -35,11 +36,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -50,7 +47,7 @@ void f()
   time_point t1 = Clock::now();
   BOOST_TEST(lk.owns_lock() == true);
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   try
   {
     lk.lock();

test/sync/mutual_exclusion/mutex/lock_pass.cpp

@@ -21,7 +21,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-
+#include "../../../timming.hpp"
 
 boost::mutex m;
 
@@ -34,11 +34,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -48,7 +44,7 @@ void f()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   m.lock();

test/sync/mutual_exclusion/mutex/try_lock_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 
 boost::mutex m;
@@ -33,11 +34,7 @@ typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -51,7 +48,7 @@ void f()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());

test/sync/mutual_exclusion/null_mutex/lock_pass.cpp

@@ -21,8 +21,7 @@
 #include <boost/thread/null_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-
-
+#include "../../../timming.hpp"
 
 boost::null_mutex m;
 
@@ -35,11 +34,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(50);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -51,7 +46,7 @@ void f()
   m.unlock();
   m.unlock();
   ns d = t1 - t0 ;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   m.lock();

test/sync/mutual_exclusion/null_mutex/try_lock_for_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/null_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -34,11 +35,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(50);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -49,10 +46,9 @@ void f1()
   m.unlock();
   m.unlock();
   ns d = t1 - t0 ;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
-
 int main()
 {
   {

test/sync/mutual_exclusion/null_mutex/try_lock_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/null_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 
 
@@ -35,11 +36,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(50);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -51,7 +48,7 @@ void f()
   m.unlock();
   m.unlock();
   ns d = t1 - t0;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   BOOST_TEST(m.try_lock());
   BOOST_TEST(m.try_lock());

test/sync/mutual_exclusion/null_mutex/try_lock_until_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/null_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -33,11 +34,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(50);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -46,7 +43,7 @@ void f1()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 ;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 

test/sync/mutual_exclusion/recursive_mutex/lock_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 
 boost::recursive_mutex m;
@@ -34,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -50,7 +47,7 @@ void f()
   m.unlock();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   m.lock();

test/sync/mutual_exclusion/recursive_mutex/try_lock_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../timming.hpp"
 
 boost::recursive_mutex m;
 
@@ -34,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -54,9 +51,7 @@ void f()
   m.unlock();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  std::cout << "diff= " << d.count() << std::endl;
-  std::cout << "max_diff= " << max_diff.count() << std::endl;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());

test/sync/mutual_exclusion/recursive_timed_mutex/lock_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
+#include "../../../timming.hpp"
 
 boost::recursive_timed_mutex m;
 
@@ -34,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -50,9 +47,7 @@ void f()
   m.unlock();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  std::cout << "diff= " << d.count() << std::endl;
-  std::cout << "max_diff= " << max_diff.count() << std::endl;
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   m.lock();

test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_for_pass.cpp

@@ -22,10 +22,10 @@
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
-
 boost::recursive_timed_mutex m;
 
 typedef boost::chrono::steady_clock Clock;
@@ -34,11 +34,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -49,7 +45,7 @@ void f1()
   m.unlock();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -58,7 +54,7 @@ void f2()
   BOOST_TEST(m.try_lock_for(ms(250)) == false);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()

test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_pass.cpp

@@ -21,8 +21,7 @@
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
-
-
+#include "../../../timming.hpp"
 
 boost::recursive_timed_mutex m;
 
@@ -35,11 +34,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -55,7 +50,7 @@ void f()
   m.unlock();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());

test/sync/mutual_exclusion/recursive_timed_mutex/try_lock_until_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -33,11 +34,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -46,7 +43,7 @@ void f1()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -55,7 +52,7 @@ void f2()
   BOOST_TEST(m.try_lock_until(Clock::now() + ms(250)) == false);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()

test/sync/mutual_exclusion/shared_mutex/lock_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -33,11 +34,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -47,7 +44,7 @@ void f()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   m.lock();

test/sync/mutual_exclusion/shared_mutex/try_lock_for_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -31,11 +32,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -44,7 +41,7 @@ void f1()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -53,7 +50,7 @@ void f2()
   BOOST_TEST(m.try_lock_for(ms(250)) == false);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()

test/sync/mutual_exclusion/shared_mutex/try_lock_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -33,11 +34,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -51,7 +48,7 @@ void f()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());

test/sync/mutual_exclusion/shared_mutex/try_lock_until_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::shared_mutex m;
 
@@ -31,11 +32,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -44,7 +41,7 @@ void f1()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -53,7 +50,7 @@ void f2()
   BOOST_TEST(m.try_lock_until(Clock::now() + ms(250)) == false);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()

test/sync/mutual_exclusion/sync_pq/pq_single_thread_pass.cpp

@@ -20,8 +20,11 @@
 #include <boost/thread/concurrent_queues/sync_priority_queue.hpp>
 
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 using namespace boost::chrono;
+typedef boost::chrono::milliseconds ms;
+typedef boost::chrono::nanoseconds ns;
 
 typedef boost::concurrent::sync_priority_queue<int> sync_pq;
 
@@ -46,11 +49,7 @@ public:
   }
 };
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const milliseconds max_diff(250);
-#else
-const milliseconds max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void test_pull_for()
 {
@@ -58,10 +57,9 @@ void test_pull_for()
   steady_clock::time_point start = steady_clock::now();
   int val;
   boost::queue_op_status st = pq.pull_for(milliseconds(500), val);
-  steady_clock::duration diff = steady_clock::now() - start - milliseconds(500);
+  ns d = steady_clock::now() - start - milliseconds(500);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   BOOST_TEST(boost::queue_op_status::timeout == st);
-  BOOST_TEST(diff < max_diff);
-  std::cout << "diff= " << diff.count();
 }
 
 void test_pull_until()
@@ -70,9 +68,9 @@ void test_pull_until()
   steady_clock::time_point start = steady_clock::now();
   int val;
   boost::queue_op_status st = pq.pull_until(start + milliseconds(500), val);
-  steady_clock::duration diff = steady_clock::now() - start - milliseconds(500);
+  ns d = steady_clock::now() - start - milliseconds(500);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   BOOST_TEST(boost::queue_op_status::timeout == st);
-  BOOST_TEST(diff < max_diff);
 }
 
 void test_nonblocking_pull()
@@ -81,9 +79,9 @@ void test_nonblocking_pull()
   steady_clock::time_point start = steady_clock::now();
   int val;
   boost::queue_op_status st = pq.nonblocking_pull(val);
-  steady_clock::duration diff = steady_clock::now() - start;
+  ns d = steady_clock::now() - start;
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   BOOST_TEST(boost::queue_op_status::empty == st);
-  BOOST_TEST(diff < max_diff);
 }
 
 void test_pull_for_when_not_empty()
@@ -93,10 +91,10 @@ void test_pull_for_when_not_empty()
   steady_clock::time_point start = steady_clock::now();
   int val;
   boost::queue_op_status st = pq.pull_for(milliseconds(500), val);
-  steady_clock::duration diff = steady_clock::now() - start;
+  ns d = steady_clock::now() - start;
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   BOOST_TEST(boost::queue_op_status::success == st);
   BOOST_TEST(1 == val);
-  BOOST_TEST(diff < max_diff);
 }
 
 void test_pull_until_when_not_empty()
@@ -106,10 +104,10 @@ void test_pull_until_when_not_empty()
   steady_clock::time_point start = steady_clock::now();
   int val;
   boost::queue_op_status st = pq.pull_until(start + milliseconds(500), val);
-  steady_clock::duration diff = steady_clock::now() - start;
+  ns d = steady_clock::now() - start;
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
   BOOST_TEST(boost::queue_op_status::success == st);
   BOOST_TEST(1 == val);
-  BOOST_TEST(diff < max_diff);
 }
 
 int main()

test/sync/mutual_exclusion/timed_mutex/lock_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 boost::timed_mutex m;
 
@@ -33,11 +34,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -47,7 +44,7 @@ void f()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   m.lock();

test/sync/mutual_exclusion/timed_mutex/try_lock_for_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -33,11 +34,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -46,7 +43,7 @@ void f1()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -55,7 +52,7 @@ void f2()
   BOOST_TEST(m.try_lock_for(ms(250)) == false);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()

test/sync/mutual_exclusion/timed_mutex/try_lock_pass.cpp

@@ -21,6 +21,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 
 boost::timed_mutex m;
@@ -34,11 +35,7 @@ typedef boost::chrono::nanoseconds ns;
 #else
 #endif
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f()
 {
@@ -52,7 +49,7 @@ void f()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 #else
   //time_point t0 = Clock::now();
   //BOOST_TEST(!m.try_lock());

test/sync/mutual_exclusion/timed_mutex/try_lock_until_pass.cpp

@@ -22,6 +22,7 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include "../../../timming.hpp"
 
 #if defined BOOST_THREAD_USES_CHRONO
 
@@ -33,11 +34,7 @@ typedef Clock::duration duration;
 typedef boost::chrono::milliseconds ms;
 typedef boost::chrono::nanoseconds ns;
 
-#ifdef BOOST_THREAD_PLATFORM_WIN32
-const ms max_diff(250);
-#else
-const ms max_diff(75);
-#endif
+const ms max_diff(BOOST_THREAD_TEST_TIME_MS);
 
 void f1()
 {
@@ -46,7 +43,7 @@ void f1()
   time_point t1 = Clock::now();
   m.unlock();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 void f2()
@@ -55,7 +52,7 @@ void f2()
   BOOST_TEST(m.try_lock_until(Clock::now() + ms(250)) == false);
   time_point t1 = Clock::now();
   ns d = t1 - t0 - ms(250);
-  BOOST_TEST(d < max_diff);
+  BOOST_THREAD_TEST_IT(d, ns(max_diff));
 }
 
 int main()

test/test_13480b.cpp

@@ -0,0 +1,77 @@
+// comment if you want to see the boost::move issue
+#define BOOST_THREAD_VERSION 3
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/variant/detail/apply_visitor_binary.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+
+#define WANT_BUILD_TO_FAIL
+#ifdef WANT_BUILD_TO_FAIL
+#include <boost/thread.hpp>
+#endif
+
+class AType
+{
+
+};
+
+class BType
+{
+};
+
+typedef boost::shared_ptr<AType> IATypePtr;
+typedef boost::shared_ptr<BType> IBTypePtr;
+
+typedef boost::variant<IATypePtr, IBTypePtr> ABVar;
+
+struct ServiceTimeTableEvent
+{
+public:
+
+    ServiceTimeTableEvent(ABVar abType)
+        : m_abType{ abType }
+        {}
+
+        inline ABVar const& GetABType() const { return m_abType; }
+        inline ABVar & GetABType() { return m_abType; }
+
+private:
+    ABVar           m_abType;
+};
+
+class ab_are_equals
+    : public boost::static_visitor<bool>
+{
+public:
+    template<typename T, typename U>
+    bool operator()(T, U) const
+    {
+        return false; // cannot compare different types
+    }
+    template<typename T>
+    bool operator()(T lhs, T rhs) const
+    {
+        return  lhs == rhs;
+    }
+};
+
+int main(int argc, char* argv[])
+{
+
+    auto aTypePtr = IATypePtr{ new AType };
+    auto bTypePtr = IBTypePtr{ new BType };
+
+    ABVar aType = aTypePtr;
+    ABVar bType = bTypePtr;
+
+    ServiceTimeTableEvent timeTableEvent1{ aType };
+    ServiceTimeTableEvent timeTableEvent2{ bType };
+
+    auto xx = boost::apply_visitor(ab_are_equals(), timeTableEvent1.GetABType(), timeTableEvent2.GetABType());
+    xx = boost::apply_visitor(ab_are_equals(), timeTableEvent1.GetABType(), timeTableEvent1.GetABType());;
+    xx = boost::apply_visitor(ab_are_equals(), timeTableEvent2.GetABType(), timeTableEvent2.GetABType());;
+}
+
+

test/test_shared_mutex_timed_locks_chrono.cpp

@@ -65,7 +65,6 @@ BOOST_AUTO_TEST_CASE(test_timed_lock_shared_succeeds_if_no_lock_held)
 
     boost::chrono::steady_clock::time_point const start=boost::chrono::steady_clock::now();
     boost::chrono::steady_clock::time_point const timeout=start+boost::chrono::milliseconds(500);
-    boost::chrono::milliseconds const timeout_resolution(50);
     bool timed_lock_succeeded=rw_mutex.try_lock_shared_until(timeout);
     BOOST_CHECK(boost::chrono::steady_clock::now()<timeout);
     BOOST_CHECK(timed_lock_succeeded);
@@ -99,7 +98,6 @@ BOOST_AUTO_TEST_CASE(test_timed_lock_shared_succeeds_if_read_lock_held)
 
     boost::chrono::steady_clock::time_point const start=boost::chrono::steady_clock::now();
     boost::chrono::steady_clock::time_point const timeout=start+boost::chrono::milliseconds(500);
-    boost::chrono::milliseconds const timeout_resolution(50);
     bool timed_lock_succeeded=rw_mutex.try_lock_shared_until(timeout);
     BOOST_CHECK(boost::chrono::steady_clock::now()<timeout);
     BOOST_CHECK(timed_lock_succeeded);
@@ -166,7 +164,6 @@ BOOST_AUTO_TEST_CASE(test_timed_lock_succeeds_if_no_lock_held)
 
     boost::chrono::steady_clock::time_point const start=boost::chrono::steady_clock::now();
     boost::chrono::steady_clock::time_point const timeout=start+boost::chrono::milliseconds(500);
-    boost::chrono::milliseconds const timeout_resolution(50);
     bool timed_lock_succeeded=rw_mutex.try_lock_until(timeout);
     BOOST_CHECK(boost::chrono::steady_clock::now()<timeout);
     BOOST_CHECK(timed_lock_succeeded);

test/test_time_jumps.cpp

@@ -1,5 +1,5 @@
 #ifdef _WIN32
-	#include <Windows.h>
+	#include <windows.h>
 #else
 	#include <sys/time.h>
 #endif

test/timming.hpp

@@ -0,0 +1,26 @@
+// Copyright (C) 2018 Vicente Botet
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_THREAD_TEST_TIMMING_HPP
+#define BOOST_THREAD_TEST_TIMMING_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#if ! defined BOOST_THREAD_TEST_TIME_MS
+#ifdef BOOST_THREAD_PLATFORM_WIN32
+#define BOOST_THREAD_TEST_TIME_MS 250
+#else
+#define BOOST_THREAD_TEST_TIME_MS 75
+#endif
+#endif
+
+#if ! defined BOOST_THREAD_TEST_TIME_WARNING
+#define BOOST_THREAD_TEST_IT(A, B) BOOST_TEST_LT((A).count(), (B).count())
+#else
+#define BOOST_THREAD_TEST_IT(A, B) BOOST_TEST_LT((A).count(), (B).count())
+#endif
+
+#endif