feat: ponyfill std::atomic_ref on OSX with Boost

Author: BurningEnlightenment

CMakeLists.txt

@@ -20,6 +20,9 @@ include(VcpkgDefaults)
 if (BUILD_TESTING OR NOT DEFINED BUILD_TESTING)
     list(APPEND VCPKG_MANIFEST_FEATURES "tests")
 endif()
+if (DPLX_DLOG_USE_BOOST_ATOMIC_REF)
+    list(APPEND VCPKG_MANIFEST_FEATURES "boost-atomic-ref")
+endif()
 
 ########################################################################
 project(deeplog
@@ -28,6 +31,7 @@ project(deeplog
 )
 
 include(EnforceOutOfSourceBuilds)
+include(CheckStdAtomicRefSupport)
 include(CMakeDependentOption)
 include(CMakePackageConfigHelpers)
 include(FeatureSummary)
@@ -40,6 +44,7 @@ if (BUILD_TESTING)
     enable_testing()
 endif()
 
+check_std_atomic_ref_support(DPLX_DLOG_HAS_STD_ATOMIC_REF)
 
 ########################################################################
 # options
@@ -48,6 +53,7 @@ option(DPLX_DLOG_DISABLE_WORKAROUNDS "Disable all workarounds" OFF)
 option(DPLX_DLOG_FLAG_OUTDATED_WORKAROUNDS "Emit compiler errors for workarounds which are active, but haven't been validated for this version" OFF)
 
 option(DPLX_DLOG_DISABLE_IMPLICIT_CONTEXT "Disable implicit context support via TLS" OFF)
+cmake_dependent_option(DPLX_DLOG_USE_BOOST_ATOMIC_REF "Use boost::atomic_ref instead of std::atomic_ref" OFF "DPLX_DLOG_HAS_STD_ATOMIC_REF" ON)
 
 option(BUILD_EXAMPLES "Build the example executables" OFF)
 
@@ -59,6 +65,10 @@ set_property(CACHE DLOG_LLFIO_TARGET PROPERTY STRINGS "hl;sl;dl")
 # dependencies
 
 set(Boost_NO_WARN_NEW_VERSIONS ON)
+set(DLOG_REQUIRED_BOOST_COMPONENTS config mp11 unordered variant2)
+if (DPLX_DLOG_USE_BOOST_ATOMIC_REF)
+    list(APPEND DLOG_REQUIRED_BOOST_COMPONENTS atomic)
+endif()
 
 find_package(fmt 10 CONFIG REQUIRED)
 
@@ -71,7 +81,7 @@ find_package(llfio CONFIG REQUIRED)
 find_package(concrete 0.0 CONFIG REQUIRED)
 find_package(deeppack 0.1 CONFIG REQUIRED)
 
-find_package(Boost 1.82 REQUIRED)
+find_package(Boost 1.82 REQUIRED COMPONENTS ${DLOG_REQUIRED_BOOST_COMPONENTS})
 
 find_package(Catch2 CONFIG)
 set_package_properties(Catch2 PROPERTIES

libs/deeplog/CMakeLists.txt

@@ -34,6 +34,8 @@ target_include_directories(deeplog PUBLIC
 target_link_libraries(deeplog PUBLIC
     Deeplex::deeppack
 
+    Boost::boost
+    $<$<BOOL:${DPLX_DLOG_USE_BOOST_ATOMIC_REF}>:Boost::atomic>
     fmt::fmt
     llfio::${DLOG_LLFIO_TARGET}
     outcome::hl

libs/deeplog/src/dplx/dlog/bus/mpsc_bus.cpp

@@ -295,8 +295,8 @@ auto dplx::dlog::mpsc_bus_handle::create_span_context(trace_id trace,
                     ^ traceBlob.values[3],
             mNumRegions);
     auto const ctr
-            = std::atomic_ref<std::uint64_t>(region(regionId)->span_prng_ctr)
-                      .fetch_add(1U, std::memory_order_relaxed);
+            = detail::atomic_ref<std::uint64_t>(region(regionId)->span_prng_ctr)
+                      .fetch_add(1U, detail::memory_order::relaxed);
     auto const rawTraceId
             = std::bit_cast<cncr::blob<std::uint64_t, 2, alignof(trace_id)>>(
                     trace);

libs/deeplog/src/dplx/dlog/bus/mpsc_bus.hpp

@@ -20,9 +20,11 @@
 #include <dplx/dp/macros.hpp>
 #include <dplx/dp/streams/memory_output_stream.hpp>
 #include <dplx/make.hpp>
+#include <dplx/predef/os.h>
 #include <dplx/scope_guard.hpp>
 
 #include <dplx/dlog/concepts.hpp>
+#include <dplx/dlog/config.hpp>
 #include <dplx/dlog/core/file_database.hpp>
 #include <dplx/dlog/core/log_clock.hpp>
 #include <dplx/dlog/core/strong_types.hpp>
@@ -31,9 +33,23 @@
 #include <dplx/dlog/log_fabric.hpp>
 #include <dplx/dlog/source/record_output_buffer.hpp>
 
+#if DPLX_DLOG_USE_BOOST_ATOMIC_REF
+#include <boost/atomic/atomic_ref.hpp>
+#endif
+
 namespace dplx::dlog::detail
 {
 
+#if DPLX_DLOG_USE_BOOST_ATOMIC_REF
+template <typename T>
+using atomic_ref = boost::atomic_ref<T>;
+using memory_order = boost::memory_order;
+#else
+template <typename T>
+using atomic_ref = std::atomic_ref<T>;
+using memory_order = std::memory_order;
+#endif
+
 auto hashed_this_thread_id() noexcept -> std::uint32_t;
 
 constexpr auto hash_to_index(std::uint32_t h, std::uint32_t buckets) noexcept
@@ -64,11 +80,11 @@ using mpsc_bus_info = mpsc_bus_info_v00;
 
 struct mpsc_bus_region_ctrl
 {
-    alignas(std::atomic_ref<std::uint32_t>::required_alignment)
+    alignas(detail::atomic_ref<std::uint32_t>::required_alignment)
             std::uint32_t read_ptr;
-    alignas(std::atomic_ref<std::uint32_t>::required_alignment)
+    alignas(detail::atomic_ref<std::uint32_t>::required_alignment)
             std::uint32_t alloc_ptr;
-    alignas(std::atomic_ref<std::uint64_t>::required_alignment) std::uint64_t
+    alignas(detail::atomic_ref<std::uint64_t>::required_alignment) std::uint64_t
             span_prng_ctr;
 
     std::uint8_t padding[48]; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
@@ -174,7 +190,7 @@ class mpsc_bus_handle
             = static_cast<std::uint32_t>(sizeof(region_ctrl));
 
     static constexpr std::uint32_t write_alignment
-            = std::atomic_ref<std::uint32_t>::required_alignment;
+            = detail::atomic_ref<std::uint32_t>::required_alignment;
     static constexpr std::uint32_t block_size = write_alignment;
     static constexpr std::uint32_t message_header_size = block_size;
 
@@ -209,8 +225,8 @@ class mpsc_bus_handle
                 return errc::bad;
             }
 
-            std::atomic_ref<std::uint32_t>(*mMsgCtrl).fetch_and(
-                    max_message_size, std::memory_order::release);
+            detail::atomic_ref<std::uint32_t>(*mMsgCtrl).fetch_and(
+                    max_message_size, detail::memory_order::release);
             // reset();
             mMsgCtrl = nullptr;
             return outcome::success();
@@ -238,11 +254,12 @@ class mpsc_bus_handle
         auto *const blockData = region_data(regionId);
         writable_bytes block(blockData, mRegionSize - region_ctrl_overhead);
 
-        std::atomic_ref<std::uint32_t> const readPtr(ctx->read_ptr);
-        std::atomic_ref<std::uint32_t> const allocPtr(ctx->alloc_ptr);
+        detail::atomic_ref<std::uint32_t> const readPtr(ctx->read_ptr);
+        detail::atomic_ref<std::uint32_t> const allocPtr(ctx->alloc_ptr);
 
-        auto const originalReadPos = readPtr.load(std::memory_order::relaxed);
-        auto const allocPos = allocPtr.load(std::memory_order::relaxed);
+        auto const originalReadPos
+                = readPtr.load(detail::memory_order::relaxed);
+        auto const allocPos = allocPtr.load(detail::memory_order::relaxed);
         if (allocPos == originalReadPos)
         {
             // nothing to see here
@@ -253,7 +270,7 @@ class mpsc_bus_handle
         scope_guard readUpdateGuard = [&readPos, &originalReadPos, &readPtr] {
             if (readPos != originalReadPos)
             {
-                readPtr.store(readPos, std::memory_order::release);
+                readPtr.store(readPos, detail::memory_order::release);
             }
         };
 
@@ -276,8 +293,8 @@ class mpsc_bus_handle
                         blockData + readPos);
 
                 auto const msgHead
-                        = std::atomic_ref<std::uint32_t>{*msgHeadPtr}.load(
-                                std::memory_order::acquire);
+                        = detail::atomic_ref<std::uint32_t>{*msgHeadPtr}.load(
+                                detail::memory_order::acquire);
                 if ((msgHead & message_lock_flag) != 0U)
                 {
                     break;
@@ -312,9 +329,9 @@ class mpsc_bus_handle
 
             for (std::size_t i = 0U; i < batchSize; ++i)
             {
-                std::atomic_ref<std::uint32_t>{*infos[i].head}.fetch_or(
+                detail::atomic_ref<std::uint32_t>{*infos[i].head}.fetch_or(
                         message_lock_flag | message_consumed_flag,
-                        std::memory_order::relaxed);
+                        detail::memory_order::relaxed);
                 std::memset(infos[i].content.data(),
                             static_cast<int>(unused_block_content),
                             infos[i].content.size());
@@ -379,12 +396,13 @@ class mpsc_bus_handle
         auto const regionEnd = mRegionSize - region_ctrl_overhead;
         auto const allocSize = cncr::round_up_p2(payloadSize, block_size);
 
-        std::atomic_ref<std::uint32_t> const sharedReadHand(ctx->read_ptr);
-        std::atomic_ref<std::uint32_t> const sharedAllocHand(ctx->alloc_ptr);
+        detail::atomic_ref<std::uint32_t> const sharedReadHand(ctx->read_ptr);
+        detail::atomic_ref<std::uint32_t> const sharedAllocHand(ctx->alloc_ptr);
 
-        auto const readHand = sharedReadHand.load(std::memory_order::acquire);
+        auto const readHand
+                = sharedReadHand.load(detail::memory_order::acquire);
         std::uint32_t allocHand
-                = sharedAllocHand.load(std::memory_order::relaxed);
+                = sharedAllocHand.load(detail::memory_order::relaxed);
         // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
         std::uint32_t payloadPosition;
         for (;;)
@@ -412,7 +430,7 @@ class mpsc_bus_handle
             }
 
             if (sharedAllocHand.compare_exchange_weak(
-                        allocHand, payloadEnd, std::memory_order::relaxed))
+                        allocHand, payloadEnd, detail::memory_order::relaxed))
                     [[likely]]
             {
                 break;
@@ -424,8 +442,8 @@ class mpsc_bus_handle
         auto *ctrl = reinterpret_cast<std::uint32_t *>(regionData + allocHand);
         auto *data = regionData + payloadPosition;
         // NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-        std::atomic_ref<std::uint32_t>(*ctrl).store(
-                payloadSize | message_lock_flag, std::memory_order::relaxed);
+        detail::atomic_ref<std::uint32_t>(*ctrl).store(
+                payloadSize | message_lock_flag, detail::memory_order::relaxed);
         out.reset(data, allocSize);
         out.mMsgCtrl = ctrl;
         return errc::success;

libs/deeplog/src/dplx/dlog/config.hpp

@@ -18,3 +18,12 @@
 #if !defined(DPLX_DLOG_FLAG_OUTDATED_WORKAROUNDS)
 #define DPLX_DLOG_FLAG_OUTDATED_WORKAROUNDS 0
 #endif
+
+#if !defined(DPLX_DLOG_USE_BOOST_ATOMIC_REF)
+#include <version>
+#if __cpp_lib_atomic_ref >= 201'806L
+#define DPLX_DLOG_USE_BOOST_ATOMIC_REF 0
+#else
+#define DPLX_DLOG_USE_BOOST_ATOMIC_REF 1
+#endif
+#endif

tools/cmake/CheckStdAtomicRefSupport.cmake

@@ -0,0 +1,14 @@
+include_guard(DIRECTORY)
+include(CheckCXXSourceCompiles)
+
+function(check_std_atomic_ref_support OUT_VAR)
+    set(CMAKE_CXX_STANDARD 20)
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+    check_cxx_source_compiles([=[
+        #include <version>
+        static_assert(__cpp_lib_atomic_ref >= 201806L);
+        int main() {}
+    ]=] "${OUT_VAR}")
+    set("${OUT_VAR}" "${${OUT_VAR}}" PARENT_SCOPE)
+endfunction()

tools/config.hpp.in

@@ -16,6 +16,7 @@
 
 #cmakedefine01 DPLX_DLOG_DISABLE_IMPLICIT_CONTEXT
 #cmakedefine01 DPLX_DLOG_USE_SOURCE_LOCATION
+#cmakedefine01 DPLX_DLOG_USE_BOOST_ATOMIC_REF
 
 // NOLINTEND(cppcoreguidelines-macro-to-enum)
 // NOLINTEND(cppcoreguidelines-macro-usage)

vcpkg.json

@@ -4,11 +4,18 @@
     "version-semver": "0.0.0-beta.6",
     "homepage": "https://github.com/deeplex/deeplog",
     "dependencies": [
+        {
+            "name": "boost-atomic",
+            "platform": "osx"
+        },
         "boost-config",
         "boost-mp11",
         "boost-unordered",
         "boost-variant2",
-        "boost-winapi",
+        {
+            "name": "boost-winapi",
+            "platform": "windows"
+        },
         "concrete",
         "deeppack",
         "fmt",
@@ -20,6 +27,10 @@
         "outcome"
     ],
     "features": {
+        "boost-atomic-ref": {
+            "description": "Use boost::atomic_ref instead of std::atomic_ref",
+            "dependencies": [ "boost-atomic" ]
+        },
         "tests": {
             "description": "Build the test suite",
             "dependencies": [ "catch2" ]