Use SwitchToThread instead of Sleep(0) is sp_thread_yield; the general consensus is that it's newer and 'smarter'

.drone.jsonnet

@@ -334,6 +334,14 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         ["deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"],
     ),
 
+    linux_pipeline(
+        "Linux 22.04 Clang 16",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '03,11,14,17,20,2b' },
+        "clang-16",
+        ["deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-16 main"],
+    ),
+
     macos_pipeline(
         "MacOS 10.15 Xcode 12.2 UBSAN",
         { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + ubsan,

.github/workflows/ci.yml

@@ -245,10 +245,6 @@ jobs:
             os: ubuntu-22.04
             install:
               - clang-15
-            sources:
-              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"
-            source_keys:
-              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
           - toolset: clang
             compiler: clang++-15
             cxxstd: "03,11,14,17,20,2b"
@@ -257,24 +253,34 @@ jobs:
               - clang-15
               - libc++-15-dev
               - libc++abi-15-dev
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-22.04
+            install:
+              - clang-16
+              - libc++-16-dev
+              - libc++abi-16-dev
             sources:
-              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"
+              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-16 main"
             source_keys:
               - "https://apt.llvm.org/llvm-snapshot.gpg.key"
             cxxflags: -stdlib=libc++
             linkflags: -stdlib=libc++
           - name: UBSAN
             toolset: clang
-            compiler: clang++-14
+            compiler: clang++-15
             cxxstd: "03,11,14,17,20,2b"
             cxxflags: -stdlib=libc++
             linkflags: -stdlib=libc++
             ubsan: 1
             os: ubuntu-22.04
             install:
-              - clang-14
-              - libc++-14-dev
-              - libc++abi-14-dev
+              - clang-15
+              - libc++-15-dev
+              - libc++abi-15-dev
 
           - toolset: clang
             cxxstd: "03,11,14,17,2a"

doc/changes.qbk

@@ -14,6 +14,8 @@
   `constexpr` on recent MSVC versions (VS2019 update 5 and later.)
 * Added `boost::core::byteswap` (an implementation of `std::byteswap` from
   C++23) to [link core.bit `boost/core/bit.hpp`].
+* Moved the yield primitives `sp_thread_pause`, `sp_thread_yield`, `sp_thread_sleep`
+  from SmartPtr implementation details to `boost/core/yield_primitives.hpp`.
 
 [endsect]
 

doc/core.qbk

@@ -83,3 +83,4 @@ criteria for inclusion is that the utility component be:
 [include uncaught_exceptions.qbk]
 [include use_default.qbk]
 [include verbose_terminate_handler.qbk]
+[include yield_primitives.qbk]

doc/yield_primitives.qbk

@@ -0,0 +1,79 @@
+[/
+  Copyright 2023 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:yield_primitives Yield Primitives]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/yield_primitives.hpp>]
+
+The header `<boost/core/yield_primitives.hpp>` implements a
+collection of primitives that allow the current thread to
+yield the CPU in various ways.
+
+Very low level, specialized functionality, generally only useful for
+implementing spinlocks. Normal synchronization primitives should
+almost always be preferable in application code.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+namespace core
+{
+
+void sp_thread_pause() noexcept;
+void sp_thread_yield() noexcept;
+void sp_thread_sleep() noexcept;
+
+} // namespace core
+} // namespace boost
+``
+
+[endsect]
+
+[section sp_thread_pause]
+
+`void sp_thread_pause() noexcept;`
+
+Emits a PAUSE instruction (on x86) or a YIELD instruction (on ARM).
+
+A portable equivalent of the GCC builtin function `__builtin_ia32_pause`.
+
+[endsect]
+
+[section sp_thread_yield]
+
+`void sp_thread_yield() noexcept;`
+
+Informs the scheduler that the current thread wishes to relinquish
+the rest of its timeslice.
+
+A portable equivalent of POSIX `sched_yield`.
+
+[endsect]
+
+[section sp_thread_sleep]
+
+`void sp_thread_sleep() noexcept;`
+
+Sleeps for a short period, as if by calling POSIX `nanosleep` with
+a small, implementation-dependent, interval (usually one microsecond).
+
+A more forcing yield primitive than `sp_thread_yield`, because it's
+generally not ignored even if all other waiting threads are of lower
+priority.
+
+[endsect]
+
+[endsect]
+
+[endsect]

include/boost/core/bit.hpp

@@ -43,6 +43,16 @@
 # define BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL
 #endif
 
+#if defined(__has_builtin)
+# if __has_builtin(__builtin_bit_cast)
+#  define BOOST_CORE_HAS_BUILTIN_BIT_CAST
+# endif
+#endif
+
+#if defined(BOOST_MSVC) && BOOST_MSVC >= 1926
+#  define BOOST_CORE_HAS_BUILTIN_BIT_CAST
+#endif
+
 namespace boost
 {
 namespace core
@@ -50,6 +60,16 @@ namespace core
 
 // bit_cast
 
+#if defined(BOOST_CORE_HAS_BUILTIN_BIT_CAST)
+
+template<class To, class From>
+BOOST_CONSTEXPR To bit_cast( From const & from ) BOOST_NOEXCEPT
+{
+    return __builtin_bit_cast( To, from );
+}
+
+#else
+
 template<class To, class From>
 To bit_cast( From const & from ) BOOST_NOEXCEPT
 {
@@ -60,6 +80,8 @@ To bit_cast( From const & from ) BOOST_NOEXCEPT
     return to;
 }
 
+#endif
+
 // countl
 
 #if defined(__GNUC__) || defined(__clang__)

include/boost/core/detail/sp_thread_pause.hpp

@@ -0,0 +1,71 @@
+#ifndef BOOST_CORE_DETAIL_SP_THREAD_PAUSE_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_SP_THREAD_PAUSE_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// boost/core/detail/sp_thread_pause.hpp
+//
+// inline void bost::core::sp_thread_pause();
+//
+//   Emits a "pause" instruction.
+//
+// Copyright 2008, 2020, 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+
+#if defined(__has_builtin)
+# if __has_builtin(__builtin_ia32_pause) && !defined(_INTEL_COMPILER)
+#  define BOOST_CORE_HAS_BUILTIN_IA32_PAUSE
+# endif
+#endif
+
+#if defined(BOOST_CORE_HAS_BUILTIN_IA32_PAUSE)
+
+# define BOOST_CORE_SP_PAUSE() __builtin_ia32_pause()
+
+#elif defined(_MSC_VER) && ( defined(_M_IX86) || defined(_M_X64) )
+
+# include <intrin.h>
+# define BOOST_CORE_SP_PAUSE() _mm_pause()
+
+#elif defined(_MSC_VER) && ( defined(_M_ARM) || defined(_M_ARM64) )
+
+# include <intrin.h>
+# define BOOST_CORE_SP_PAUSE() __yield()
+
+#elif defined(__GNUC__) && ( defined(__i386__) || defined(__x86_64__) )
+
+# define BOOST_CORE_SP_PAUSE() __asm__ __volatile__( "rep; nop" : : : "memory" )
+
+#elif defined(__GNUC__) && ( (defined(__ARM_ARCH) && __ARM_ARCH >= 8) || defined(__ARM_ARCH_8A__) || defined(__aarch64__) )
+
+# define BOOST_CORE_SP_PAUSE() __asm__ __volatile__( "yield" : : : "memory" )
+
+#else
+
+# define BOOST_CORE_SP_PAUSE() ((void)0)
+
+#endif
+
+namespace boost
+{
+namespace core
+{
+
+BOOST_FORCEINLINE void sp_thread_pause() BOOST_NOEXCEPT
+{
+    BOOST_CORE_SP_PAUSE();
+}
+
+} // namespace core
+} // namespace boost
+
+#undef BOOST_CORE_SP_PAUSE
+
+#endif // #ifndef BOOST_CORE_DETAIL_SP_THREAD_PAUSE_HPP_INCLUDED

include/boost/core/detail/sp_thread_sleep.hpp

@@ -0,0 +1,122 @@
+#ifndef BOOST_CORE_DETAIL_SP_THREAD_SLEEP_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_SP_THREAD_SLEEP_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// boost/core/detail/sp_thread_sleep.hpp
+//
+// inline void bost::core::sp_thread_sleep();
+//
+//   Cease execution for a while to yield to other threads,
+//   as if by calling nanosleep() with an appropriate interval.
+//
+// Copyright 2008, 2020, 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+  BOOST_PRAGMA_MESSAGE("Using Sleep(1) in sp_thread_sleep")
+#endif
+
+#include <boost/core/detail/sp_win32_sleep.hpp>
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+inline void sp_thread_sleep() BOOST_NOEXCEPT
+{
+    Sleep( 1 );
+}
+
+} // namespace detail
+
+using boost::core::detail::sp_thread_sleep;
+
+} // namespace core
+} // namespace boost
+
+#elif defined(BOOST_HAS_NANOSLEEP)
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+  BOOST_PRAGMA_MESSAGE("Using nanosleep() in sp_thread_sleep")
+#endif
+
+#include <time.h>
+
+#if defined(BOOST_HAS_PTHREADS)
+# include <pthread.h>
+#endif
+
+namespace boost
+{
+namespace core
+{
+
+inline void sp_thread_sleep() BOOST_NOEXCEPT
+{
+#if defined(BOOST_HAS_PTHREADS)
+
+    int oldst;
+    pthread_setcancelstate( PTHREAD_CANCEL_DISABLE, &oldst );
+
+#endif
+
+    // g++ -Wextra warns on {} or {0}
+    struct timespec rqtp = { 0, 0 };
+
+    // POSIX says that timespec has tv_sec and tv_nsec
+    // But it doesn't guarantee order or placement
+
+    rqtp.tv_sec = 0;
+    rqtp.tv_nsec = 1000;
+
+    nanosleep( &rqtp, 0 );
+
+#if defined(BOOST_HAS_PTHREADS)
+
+    pthread_setcancelstate( oldst, &oldst );
+
+#endif
+
+}
+
+} // namespace core
+} // namespace boost
+
+#else
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+  BOOST_PRAGMA_MESSAGE("Using sp_thread_yield() in sp_thread_sleep")
+#endif
+
+#include <boost/core/detail/sp_thread_yield.hpp>
+
+namespace boost
+{
+namespace core
+{
+
+inline void sp_thread_sleep() BOOST_NOEXCEPT
+{
+    sp_thread_yield();
+}
+
+} // namespace core
+} // namespace boost
+
+#endif
+
+#endif // #ifndef BOOST_CORE_DETAIL_SP_THREAD_SLEEP_HPP_INCLUDED

include/boost/core/detail/sp_thread_yield.hpp

@@ -0,0 +1,100 @@
+#ifndef BOOST_CORE_DETAIL_SP_THREAD_YIELD_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_SP_THREAD_YIELD_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// boost/core/detail/sp_thread_yield.hpp
+//
+// inline void bost::core::sp_thread_yield();
+//
+//   Gives up the remainder of the time slice,
+//   as if by calling sched_yield().
+//
+// Copyright 2008, 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+  BOOST_PRAGMA_MESSAGE("Using SwitchToThread() in sp_thread_yield")
+#endif
+
+#include <boost/core/detail/sp_win32_sleep.hpp>
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+inline void sp_thread_yield() BOOST_NOEXCEPT
+{
+    SwitchToThread();
+}
+
+} // namespace detail
+
+using boost::core::detail::sp_thread_yield;
+
+} // namespace core
+} // namespace boost
+
+#elif defined(BOOST_HAS_SCHED_YIELD)
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+  BOOST_PRAGMA_MESSAGE("Using sched_yield() in sp_thread_yield")
+#endif
+
+#ifndef _AIX
+# include <sched.h>
+#else
+  // AIX's sched.h defines ::var which sometimes conflicts with Lambda's var
+  extern "C" int sched_yield(void);
+#endif
+
+namespace boost
+{
+namespace core
+{
+
+inline void sp_thread_yield() BOOST_NOEXCEPT
+{
+    sched_yield();
+}
+
+} // namespace core
+} // namespace boost
+
+#else
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+  BOOST_PRAGMA_MESSAGE("Using sp_thread_pause() in sp_thread_yield")
+#endif
+
+#include <boost/core/detail/sp_thread_pause.hpp>
+
+namespace boost
+{
+namespace core
+{
+
+inline void sp_thread_yield() BOOST_NOEXCEPT
+{
+    sp_thread_pause();
+}
+
+} // namespace core
+} // namespace boost
+
+#endif
+
+#endif // #ifndef BOOST_CORE_DETAIL_SP_THREAD_YIELD_HPP_INCLUDED

include/boost/core/detail/sp_win32_sleep.hpp

@@ -0,0 +1,54 @@
+#ifndef BOOST_CORE_DETAIL_SP_WIN32_SLEEP_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_SP_WIN32_SLEEP_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// boost/core/detail/sp_win32_sleep.hpp
+//
+// Declares the Win32 Sleep() function.
+//
+// Copyright 2008, 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+#endif
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+#if !defined( BOOST_USE_WINDOWS_H )
+
+#if defined(__clang__) && defined(__x86_64__)
+// clang x64 warns that __stdcall is ignored
+# define BOOST_CORE_SP_STDCALL
+#else
+# define BOOST_CORE_SP_STDCALL __stdcall
+#endif
+
+#if defined(__LP64__) // Cygwin 64
+  extern "C" __declspec(dllimport) void BOOST_CORE_SP_STDCALL Sleep( unsigned int ms );
+#else
+  extern "C" __declspec(dllimport) void BOOST_CORE_SP_STDCALL Sleep( unsigned long ms );
+#endif
+
+extern "C" __declspec(dllimport) int BOOST_CORE_SP_STDCALL SwitchToThread();
+
+#undef BOOST_CORE_SP_STDCALL
+
+#endif // !defined( BOOST_USE_WINDOWS_H )
+
+} // namespace detail
+} // namespace core
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_DETAIL_SP_WIN32_SLEEP_HPP_INCLUDED

include/boost/core/yield_primitives.hpp

@@ -0,0 +1,12 @@
+#ifndef BOOST_CORE_YIELD_PRIMITIVES_HPP_INCLUDED
+#define BOOST_CORE_YIELD_PRIMITIVES_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/sp_thread_pause.hpp>
+#include <boost/core/detail/sp_thread_yield.hpp>
+#include <boost/core/detail/sp_thread_sleep.hpp>
+
+#endif  // #ifndef BOOST_CORE_YIELD_PRIMITIVES_HPP_INCLUDED

test/CMakeLists.txt

@@ -38,6 +38,13 @@ boost_test(TYPE run SOURCES serialization_split_free_test.cpp)
 boost_test(TYPE run SOURCES serialization_split_member_test.cpp)
 boost_test(TYPE run SOURCES serialization_construct_data_test.cpp)
 
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+set(BOOST_TEST_LINK_LIBRARIES Boost::core Threads::Threads)
+
+boost_test(TYPE run SOURCES yield_prim_pthread_cancel_test.cpp)
+
 endif()
 
 add_subdirectory(swap)

test/Jamfile.v2

@@ -304,6 +304,7 @@ run bit_byteswap_test.cpp
 compile-fail bit_width_fail.cpp
   : <warnings>off ;
 
+compile bit_cast_test_cx.cpp ;
 compile bit_rotate_test_cx.cpp ;
 compile bit_countr_test_cx.cpp ;
 compile bit_countl_test_cx.cpp ;
@@ -385,5 +386,11 @@ run serialization_construct_data_test.cpp : : : <library>/boost//serialization/<
 run identity_test.cpp ;
 run identity_rvalue_test.cpp ;
 
+run sp_thread_pause_test.cpp ;
+run sp_thread_yield_test.cpp ;
+run sp_thread_sleep_test.cpp ;
+run yield_prim_windows_h_test.cpp ;
+run yield_prim_pthread_cancel_test.cpp : ;
+
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;

test/bit_cast_test_cx.cpp

@@ -0,0 +1,28 @@
+// constexpr test for boost/core/bit.hpp (bit_cast)
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/cstdint.hpp>
+
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX11_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX11_CONSTEXPR is defined" )
+
+#elif !defined(BOOST_CORE_HAS_BUILTIN_BIT_CAST)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_CORE_HAS_BUILTIN_BIT_CAST is not defined" )
+
+#else
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+STATIC_ASSERT( boost::core::bit_cast<boost::uint32_t>( 1.0f ) == 0x3F800000u );
+STATIC_ASSERT( boost::core::bit_cast<boost::uint64_t>( 1.0 ) == 0x3FF0000000000000ull );
+
+#endif

test/sp_thread_pause_test.cpp

@@ -0,0 +1,15 @@
+// Test for sp_thread_pause
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/yield_primitives.hpp>
+
+int main()
+{
+    for( int i = 0; i < 1048576; ++i )
+    {
+        boost::core::sp_thread_pause();
+    }
+}

test/sp_thread_sleep_test.cpp

@@ -0,0 +1,15 @@
+// Test for sp_thread_sleep
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/yield_primitives.hpp>
+
+int main()
+{
+    for( int i = 0; i < 100; ++i )
+    {
+        boost::core::sp_thread_sleep();
+    }
+}

test/sp_thread_yield_test.cpp

@@ -0,0 +1,15 @@
+// Test for sp_thread_yield
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/yield_primitives.hpp>
+
+int main()
+{
+    for( int i = 0; i < 10000; ++i )
+    {
+        boost::core::sp_thread_yield();
+    }
+}

test/sv_types_test.cpp

@@ -7,10 +7,19 @@
 #include <boost/core/lightweight_test_trait.hpp>
 #include <iterator>
 
+#if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION >= 160000
+
+// std::char_traits<Ch> is deprecated for non-char types
+typedef wchar_t Ch;
+
+#else
+
 struct Ch
 {
 };
 
+#endif
+
 int main()
 {
     typedef boost::core::basic_string_view<Ch> ch_string_view;

test/type_name_test.cpp

@@ -310,7 +310,11 @@ int main()
     TEST(std::pair<void, void>);
     TEST(std::pair<std::pair<void, void>, void>);
 
+#if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION >= 160000
+// std::char_traits<Ch> is deprecated for non-char types
+#else
     TEST(std::basic_string<Ch>);
+#endif
 
     TEST(std::string);
     TEST(std::wstring);
@@ -402,7 +406,11 @@ int main()
 
 #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
 
+#if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION >= 160000
+// std::char_traits<Ch> is deprecated for non-char types
+#else
     TEST(std::basic_string_view<Ch>);
+#endif
 
     TEST(std::string_view);
     TEST(std::wstring_view);

test/yield_prim_pthread_cancel_test.cpp

@@ -0,0 +1,54 @@
+// Test that yield primitives aren't cancelation points
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/yield_primitives.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if !defined(BOOST_HAS_PTHREADS)
+
+BOOST_PRAGMA_MESSAGE( "Skipping test because BOOST_HAS_PTHREADS is not defined" )
+int main() {}
+
+#else
+
+#include <pthread.h>
+
+pthread_mutex_t s_mx = PTHREAD_MUTEX_INITIALIZER;
+
+void* threadfunc( void* )
+{
+    pthread_mutex_lock( &s_mx );
+    pthread_mutex_unlock( &s_mx );
+
+    boost::core::sp_thread_pause();
+    boost::core::sp_thread_yield();
+    boost::core::sp_thread_sleep();
+
+    return 0;
+}
+
+int main()
+{
+    pthread_mutex_lock( &s_mx );
+
+    pthread_t th;
+    pthread_create( &th, 0, threadfunc, 0 );
+
+    pthread_cancel( th );
+
+    pthread_mutex_unlock( &s_mx );
+
+    void* r;
+    pthread_join( th, &r );
+
+    BOOST_TEST_EQ( r, (void*)0 );
+
+    return boost::report_errors();
+}
+
+#endif

test/yield_prim_windows_h_test.cpp

@@ -0,0 +1,18 @@
+// Test for yield_primitives.hpp compatibility with windows.h
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+# include <windows.h>
+#endif
+
+#include <boost/core/yield_primitives.hpp>
+
+int main()
+{
+    boost::core::sp_thread_pause();
+    boost::core::sp_thread_yield();
+    boost::core::sp_thread_sleep();
+}