From 2df64e600cd0f5e19a1a5bbaa1c8a5fee349827c Mon Sep 17 00:00:00 2001 From: Omar Boukli-Hacene Date: Mon, 9 Nov 2026 22:15:18 +0200 Subject: [PATCH 1/9] fix: Correct container destructor --- .../forfun/concurrency/spsc_bound_queue.hpp | 104 +++++------- .../spsc_bound_queue_statictest.cpp | 18 -- test/concurrency/spsc_bound_queue_test.cpp | 159 ++++++++++++++++++ 3 files changed, 198 insertions(+), 83 deletions(-) diff --git a/include/forfun/concurrency/spsc_bound_queue.hpp b/include/forfun/concurrency/spsc_bound_queue.hpp index f8f699f0..da8bdd4f 100644 --- a/include/forfun/concurrency/spsc_bound_queue.hpp +++ b/include/forfun/concurrency/spsc_bound_queue.hpp @@ -13,8 +13,6 @@ #include #include #include -#include -#include #include #include #include @@ -25,9 +23,10 @@ namespace forfun::concurrency::wait_free { namespace detail { /// @note Assumes @p buffer is correctly aligned. -template +template [[nodiscard]] constexpr auto -get_ptr_to_obj(std::byte* const buffer, Offset const offset) noexcept -> Pointer +get_ptr_to_obj(std::byte* const buffer, std::size_t const offset) noexcept + -> Type* { #if defined(__GNUC__) && !defined(__clang__) #pragma GCC diagnostic push @@ -40,14 +39,11 @@ get_ptr_to_obj(std::byte* const buffer, Offset const offset) noexcept -> Pointer #endif // __clang__ // NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast,cppcoreguidelines-pro-bounds-pointer-arithmetic) - assert( - reinterpret_cast( - reinterpret_cast(buffer) + offset - ) % alignof(std::remove_pointer_t) - == 0UZ - ); + assert(reinterpret_cast(buffer) % alignof(Type) == 0UZ); + + assert(((offset * sizeof(Type)) % alignof(Type)) == 0UZ); - return reinterpret_cast(buffer) + offset; + return reinterpret_cast(buffer + (offset * sizeof(Type))); // NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast,cppcoreguidelines-pro-bounds-pointer-arithmetic) #ifdef __clang__ @@ -59,38 +55,6 @@ get_ptr_to_obj(std::byte* const buffer, Offset const offset) noexcept -> Pointer #endif // defined(__GNUC__) && !defined(__clang__) } -/// @note Assumes @p buffer is correctly aligned. -template -[[nodiscard]] constexpr auto get_ptr_to_obj(std::byte* const buffer) noexcept - -> Pointer -{ - return get_ptr_to_obj(buffer, std::ptrdiff_t{}); -} - -using std::destroy_n; - -template -auto constexpr destroy_n(std::byte* const buffer, Size n) noexcept(noexcept( -#if defined(__cpp_lib_execution) && __cpp_lib_execution >= 201603L - destroy_n( - std::execution::unseq, std::declval(), std::declval() - ) -#else - destroy_n(std::declval(), std::declval()) -#endif // defined(__cpp_lib_execution) && __cpp_lib_execution >= 201603L -)) -> std::byte* -{ - using std::data; - - auto* const ptr{get_ptr_to_obj(buffer)}; - -#if defined(__cpp_lib_execution) && __cpp_lib_execution >= 201603L - return destroy_n(std::execution::unseq, ptr, n); -#else - return destroy_n(ptr, n); -#endif // defined(__cpp_lib_execution) && __cpp_lib_execution >= 201603L -} - } // namespace detail /// Single-producer single-consumer (SPSC) bound queue. @@ -142,7 +106,12 @@ class spsc_bound_queue final { spsc_bound_queue(spsc_bound_queue&&) = delete; - constexpr ~spsc_bound_queue() noexcept(noexcept(reset_storage())) + ~spsc_bound_queue() + requires(std::is_trivially_destructible_v) + = default; + + ~spsc_bound_queue() + requires(not std::is_trivially_destructible_v) { reset_storage(); } @@ -177,7 +146,7 @@ class spsc_bound_queue final { assert(std::cmp_less(write_cursor_cached_, capacity_)); auto* const ptr_emplaced{std::construct_at( - detail::get_ptr_to_obj( + detail::get_ptr_to_obj( data(raw_queue_), write_cursor_cached_ ), std::forward(args)... @@ -191,11 +160,17 @@ class spsc_bound_queue final { return *ptr_emplaced; } - auto reset_unsafe() noexcept(noexcept(reset_storage())) -> void + auto reset_unsafe() noexcept -> void { + using std::atomic_store_explicit; + reset_storage(); - reset_indices(); + write_cursor_cached_ = {}; + + atomic_store_explicit( + &write_cursor_, cursor_type{}, std::memory_order_release + ); } [[nodiscard]] auto to_span() noexcept -> span_type @@ -213,7 +188,7 @@ class spsc_bound_queue final { #endif // __clang__ return span_type( - detail::get_ptr_to_obj(data(raw_queue_)), + detail::get_ptr_to_obj(std::data(raw_queue_), {}), static_cast(cursor_snapshot) ); @@ -232,7 +207,7 @@ class spsc_bound_queue final { static constexpr std::size_t const capacity_{Capacity}; /// Raw cursor type, without atomic wrapper. - using cursor_type = std::ptrdiff_t; + using cursor_type = std::size_t; static_assert(std::atomic::is_always_lock_free); @@ -274,26 +249,25 @@ class spsc_bound_queue final { std::array< std::byte, std::hardware_destructive_interference_size - sizeof(cursor_type)> - end_of_object_padding_ /*[[indeterminate]]*/; - - auto reset_indices() noexcept -> void - { - write_cursor_cached_ = {}; + end_of_object_padding_; - atomic_store_explicit( - &write_cursor_, cursor_type{}, std::memory_order_release - ); - } - - constexpr auto reset_storage() noexcept(noexcept(detail::destroy_n( - std::declval(), capacity_ - ))) -> void + constexpr auto reset_storage() noexcept -> void { - using std::data; - assert(std::cmp_less_equal(write_cursor_cached_, capacity_)); - detail::destroy_n(data(raw_queue_), write_cursor_cached_); + if constexpr (not std::is_trivially_destructible_v) + { + auto const size{static_cast(write_cursor_cached_)}; + auto* reversed_first{detail::get_ptr_to_obj( + std::data(raw_queue_), + static_cast(write_cursor_cached_) + )}; + for (auto i{size}; i != size_type{}; --i) + { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + std::destroy_at(reversed_first + (i - size_type{1})); + } + } } }; diff --git a/test/concurrency/spsc_bound_queue_statictest.cpp b/test/concurrency/spsc_bound_queue_statictest.cpp index 21426973..e32f6df1 100644 --- a/test/concurrency/spsc_bound_queue_statictest.cpp +++ b/test/concurrency/spsc_bound_queue_statictest.cpp @@ -15,19 +15,6 @@ #include -namespace { - -[[nodiscard]] consteval auto is_constexpr_destructor() noexcept -> bool -{ - { - forfun::concurrency::wait_free::spsc_bound_queue const queue{}; - } - - return true; -} - -} // namespace - TEST_CASE("Wait-free SPSC append-only bounded queue", "[spsc_bound_queue]") { SECTION("Object representations is not unique") @@ -56,11 +43,6 @@ TEST_CASE("Wait-free SPSC append-only bounded queue", "[spsc_bound_queue]") ); } - SECTION("Destructor call on empty queue") - { - STATIC_REQUIRE(is_constexpr_destructor()); - } - SECTION("Comparision") { STATIC_REQUIRE_FALSE( diff --git a/test/concurrency/spsc_bound_queue_test.cpp b/test/concurrency/spsc_bound_queue_test.cpp index 97940aaa..65fd6123 100644 --- a/test/concurrency/spsc_bound_queue_test.cpp +++ b/test/concurrency/spsc_bound_queue_test.cpp @@ -6,6 +6,7 @@ #include #include +#include #include #include #include @@ -36,6 +37,101 @@ struct dummy_aggregate { auto operator==(dummy_aggregate const&) const -> bool = default; }; +struct dummy_with_tracked_destructor final { +private: + static inline std::atomic alive_instances_{}; + + static inline std::atomic destructor_calls_{}; + + int dummy_value_; + +public: + static auto reset_destructor_call_counter() noexcept -> void + { + std::atomic_store_explicit( + &destructor_calls_, 0UZ, std::memory_order_relaxed + ); + } + + [[nodiscard]] static auto alive_instances() noexcept -> std::size_t + { + return std::atomic_load_explicit( + &alive_instances_, std::memory_order_relaxed + ); + } + + [[nodiscard]] static auto destructor_calls() noexcept -> std::size_t + { + return std::atomic_load_explicit( + &destructor_calls_, std::memory_order_relaxed + ); + } + + explicit dummy_with_tracked_destructor(int dummy_value) noexcept : + dummy_value_{dummy_value} + { + std::atomic_fetch_add_explicit( + &alive_instances_, 1UZ, std::memory_order_relaxed + ); + } + + dummy_with_tracked_destructor(dummy_with_tracked_destructor const&) noexcept + = default; + + dummy_with_tracked_destructor(dummy_with_tracked_destructor&&) noexcept + = default; + + ~dummy_with_tracked_destructor() + { + std::atomic_fetch_sub_explicit( + &alive_instances_, 1UZ, std::memory_order_relaxed + ); + + std::atomic_fetch_add_explicit( + &destructor_calls_, 1UZ, std::memory_order_relaxed + ); + } + + auto operator=(dummy_with_tracked_destructor const&) noexcept + -> dummy_with_tracked_destructor& = default; + + auto operator=(dummy_with_tracked_destructor&&) noexcept + -> dummy_with_tracked_destructor& = default; + + [[nodiscard]] auto get_value() const noexcept -> int + { + return dummy_value_; + } +}; + +static_assert( + std::is_nothrow_constructible_v +); + +class destructor_call_counter_guard final { +public: + destructor_call_counter_guard() noexcept + { + dummy_with_tracked_destructor::reset_destructor_call_counter(); + } + + destructor_call_counter_guard(destructor_call_counter_guard const&) + = delete; + + destructor_call_counter_guard(destructor_call_counter_guard&&) = delete; + + ~destructor_call_counter_guard() + { + dummy_with_tracked_destructor::reset_destructor_call_counter(); + } + + auto operator=(destructor_call_counter_guard const&) + -> destructor_call_counter_guard& = delete; + + auto operator=(destructor_call_counter_guard&&) + -> destructor_call_counter_guard& = delete; +}; + } // namespace #ifdef __clang__ @@ -386,6 +482,69 @@ TEST_CASE( SUCCEED(); } + SECTION("Reset destroys queued non-trivial objects") + { + destructor_call_counter_guard const guard; + { + forfun::concurrency::wait_free:: + spsc_bound_queue + queue{}; + + queue.emplace_back(584141); + queue.emplace_back(604171); + queue.emplace_back(971767); + + REQUIRE_FALSE(queue.empty_unsafe()); + + REQUIRE(dummy_with_tracked_destructor::alive_instances() == 3UZ); + + REQUIRE(queue.to_span().size() == 3UZ); + + REQUIRE(queue.to_span().front().get_value() == 584141); + + REQUIRE(dummy_with_tracked_destructor::destructor_calls() == 0UZ); + + queue.reset_unsafe(); + + REQUIRE(queue.empty_unsafe()); + + REQUIRE(dummy_with_tracked_destructor::alive_instances() == 0UZ); + } + + REQUIRE(dummy_with_tracked_destructor::destructor_calls() == 3UZ); + + REQUIRE(dummy_with_tracked_destructor::alive_instances() == 0UZ); + } + + SECTION("Destructor destroys buffered non-trivial objects") + { + destructor_call_counter_guard const guard; + { + forfun::concurrency::wait_free:: + spsc_bound_queue + queue{}; + + queue.emplace_back(1062599); + queue.emplace_back(1282529); + + REQUIRE_FALSE(queue.empty_unsafe()); + + REQUIRE(dummy_with_tracked_destructor::alive_instances() == 2UZ); + + REQUIRE(queue.to_span().size() == 2UZ); + + REQUIRE(queue.to_span().front().get_value() == 1062599); + + REQUIRE(dummy_with_tracked_destructor::destructor_calls() == 0UZ); + + REQUIRE(dummy_with_tracked_destructor::alive_instances() == 2UZ); + } + + REQUIRE(dummy_with_tracked_destructor::destructor_calls() == 2UZ); + + REQUIRE(dummy_with_tracked_destructor::alive_instances() == 0UZ); + } + SECTION( "Nondeterministic one producer and one consumer of int values " "(immediate write)" From 1754170512d839a9d7a9d5f29ce16637077ce8c5 Mon Sep 17 00:00:00 2001 From: Omar Boukli-Hacene Date: Mon, 9 Nov 2026 22:16:18 +0200 Subject: [PATCH 2/9] refactor: Revisit helper function --- include/forfun/concurrency/spsc_bound_queue.hpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/include/forfun/concurrency/spsc_bound_queue.hpp b/include/forfun/concurrency/spsc_bound_queue.hpp index da8bdd4f..8ace6622 100644 --- a/include/forfun/concurrency/spsc_bound_queue.hpp +++ b/include/forfun/concurrency/spsc_bound_queue.hpp @@ -22,9 +22,9 @@ namespace forfun::concurrency::wait_free { namespace detail { -/// @note Assumes @p buffer is correctly aligned. +/// @note Assumes @p buffer is aligned as Type. template -[[nodiscard]] constexpr auto +[[nodiscard]] auto get_ptr_to_obj(std::byte* const buffer, std::size_t const offset) noexcept -> Type* { @@ -38,13 +38,13 @@ get_ptr_to_obj(std::byte* const buffer, std::size_t const offset) noexcept #pragma clang diagnostic ignored "-Wunsafe-buffer-usage" #endif // __clang__ - // NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast,cppcoreguidelines-pro-bounds-pointer-arithmetic) + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) assert(reinterpret_cast(buffer) % alignof(Type) == 0UZ); - assert(((offset * sizeof(Type)) % alignof(Type)) == 0UZ); - - return reinterpret_cast(buffer + (offset * sizeof(Type))); - // NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast,cppcoreguidelines-pro-bounds-pointer-arithmetic) + return static_cast( + // NOLINTNEXTLINE(bugprone-casting-through-void,cppcoreguidelines-pro-bounds-pointer-arithmetic) + static_cast(buffer + (offset * sizeof(Type))) + ); #ifdef __clang__ #pragma clang diagnostic pop @@ -251,7 +251,7 @@ class spsc_bound_queue final { std::hardware_destructive_interference_size - sizeof(cursor_type)> end_of_object_padding_; - constexpr auto reset_storage() noexcept -> void + auto reset_storage() noexcept -> void { assert(std::cmp_less_equal(write_cursor_cached_, capacity_)); From d0bcb996af5cc2bc53f484c88bb3368e2ea528ff Mon Sep 17 00:00:00 2001 From: Omar Boukli-Hacene Date: Mon, 9 Nov 2026 22:20:18 +0200 Subject: [PATCH 3/9] refactor: Clean up code --- .../forfun/concurrency/spsc_bound_queue.hpp | 21 +++++++------------ test/concurrency/spsc_bound_queue_test.cpp | 2 +- 2 files changed, 8 insertions(+), 15 deletions(-) diff --git a/include/forfun/concurrency/spsc_bound_queue.hpp b/include/forfun/concurrency/spsc_bound_queue.hpp index 8ace6622..0b5bd125 100644 --- a/include/forfun/concurrency/spsc_bound_queue.hpp +++ b/include/forfun/concurrency/spsc_bound_queue.hpp @@ -62,7 +62,7 @@ get_ptr_to_obj(std::byte* const buffer, std::size_t const offset) noexcept /// Features: /// - Wait-free (lock-free) concurrency model /// - First in, first out (FIFO) order semantics -/// - Multi-pass reads via \c std::span +/// - Multi-pass reads via @c std::span /// - Bounded, fixed-capacity, and non-circular /// - Inline storage with no dynamic allocation /// - Append-only; elements are deconstructed when the queue is deconstructed. @@ -75,9 +75,8 @@ template // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,clang-analyzer-optin.performance.Padding) class spsc_bound_queue final { private: - using pointer = T*; - - using raw_queue_type = std::array; + // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays) + using raw_queue_type = std::byte[Capacity * sizeof(T)]; public: using size_type = std::size_t; @@ -107,7 +106,7 @@ class spsc_bound_queue final { spsc_bound_queue(spsc_bound_queue&&) = delete; ~spsc_bound_queue() - requires(std::is_trivially_destructible_v) + requires std::is_trivially_destructible_v = default; ~spsc_bound_queue() @@ -124,7 +123,6 @@ class spsc_bound_queue final { /// comparision is undefined behavior. auto operator<=>(spsc_bound_queue const&) const = delete; - /// @note Not thread-safe. [[nodiscard]] auto empty_unsafe() const noexcept -> bool { using std::atomic_load_explicit; @@ -137,9 +135,7 @@ class spsc_bound_queue final { template auto emplace_back(Args&&... args) noexcept -> reference { - using std::atomic_fetch_add_explicit; - using std::atomic_load_explicit; - using std::data; + using std::atomic_store_explicit; static_assert(capacity_ != 0UZ); @@ -147,7 +143,7 @@ class spsc_bound_queue final { auto* const ptr_emplaced{std::construct_at( detail::get_ptr_to_obj( - data(raw_queue_), write_cursor_cached_ + std::data(raw_queue_), write_cursor_cached_ ), std::forward(args)... )}; @@ -176,7 +172,6 @@ class spsc_bound_queue final { [[nodiscard]] auto to_span() noexcept -> span_type { using std::atomic_load_explicit; - using std::data; auto const cursor_snapshot{ atomic_load_explicit(&write_cursor_, std::memory_order_acquire) @@ -211,10 +206,8 @@ class spsc_bound_queue final { static_assert(std::atomic::is_always_lock_free); - alignas(T) raw_queue_type raw_queue_ - /*[[indeterminate]]*/; + alignas(T) raw_queue_type raw_queue_; - static_assert(std::same_as); static_assert(std::same_as); #if defined(__GNUC__) && !defined(__clang__) diff --git a/test/concurrency/spsc_bound_queue_test.cpp b/test/concurrency/spsc_bound_queue_test.cpp index 65fd6123..09e77d36 100644 --- a/test/concurrency/spsc_bound_queue_test.cpp +++ b/test/concurrency/spsc_bound_queue_test.cpp @@ -23,7 +23,7 @@ namespace { -struct dummy_aggregate { +struct dummy_aggregate final { // NOLINTBEGIN(misc-non-private-member-variables-in-classes) int a; From b9e8b9d5a85ce85b9fedced2930942237e0eff5f Mon Sep 17 00:00:00 2001 From: Omar Boukli-Hacene Date: Mon, 9 Nov 2026 22:25:18 +0200 Subject: [PATCH 4/9] refactor: Avoid zero initialization --- .../forfun/concurrency/spsc_bound_queue.hpp | 18 +++++------------- 1 file changed, 5 insertions(+), 13 deletions(-) diff --git a/include/forfun/concurrency/spsc_bound_queue.hpp b/include/forfun/concurrency/spsc_bound_queue.hpp index 0b5bd125..c897212c 100644 --- a/include/forfun/concurrency/spsc_bound_queue.hpp +++ b/include/forfun/concurrency/spsc_bound_queue.hpp @@ -87,19 +87,11 @@ class spsc_bound_queue final { using span_type = std::span; -#ifdef _MSC_VER -#pragma warning(push) -// Warning C26495: Variable 'variable' is uninitialized. Always initialize a -// member variable (type.6). -#pragma warning(disable : 26495) -#endif // _MSC_VER - - // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init) - spsc_bound_queue() = default; - -#ifdef _MSC_VER -#pragma warning(pop) // C26495 -#endif // _MSC_VER + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,modernize-use-equals-default) + spsc_bound_queue() noexcept + { + // Avoid zero initialization. + } spsc_bound_queue(spsc_bound_queue const&) = delete; From 042b450fc1e5f35e7b8ca6d6ce689a808fe7b8ac Mon Sep 17 00:00:00 2001 From: Omar Boukli-Hacene Date: Mon, 9 Nov 2026 22:30:18 +0200 Subject: [PATCH 5/9] refactor: Rename and clean up --- .../forfun/concurrency/spsc_bound_queue.hpp | 53 ++++--------------- .../spsc_bound_queue_statictest.cpp | 9 ---- test/concurrency/spsc_bound_queue_test.cpp | 28 +++++----- 3 files changed, 24 insertions(+), 66 deletions(-) diff --git a/include/forfun/concurrency/spsc_bound_queue.hpp b/include/forfun/concurrency/spsc_bound_queue.hpp index c897212c..26758ee0 100644 --- a/include/forfun/concurrency/spsc_bound_queue.hpp +++ b/include/forfun/concurrency/spsc_bound_queue.hpp @@ -9,7 +9,6 @@ #include #include -#include #include #include #include @@ -28,16 +27,6 @@ template get_ptr_to_obj(std::byte* const buffer, std::size_t const offset) noexcept -> Type* { -#if defined(__GNUC__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wcast-align" -#endif // defined(__GNUC__) && !defined(__clang__) - -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wunsafe-buffer-usage" -#endif // __clang__ - // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) assert(reinterpret_cast(buffer) % alignof(Type) == 0UZ); @@ -45,14 +34,6 @@ get_ptr_to_obj(std::byte* const buffer, std::size_t const offset) noexcept // NOLINTNEXTLINE(bugprone-casting-through-void,cppcoreguidelines-pro-bounds-pointer-arithmetic) static_cast(buffer + (offset * sizeof(Type))) ); - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif // __clang__ - -#if defined(__GNUC__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif // defined(__GNUC__) && !defined(__clang__) } } // namespace detail @@ -70,18 +51,18 @@ get_ptr_to_obj(std::byte* const buffer, std::size_t const offset) noexcept /// @note The implementation prioritizes performance over safety and security. /// /// @note Internal storage and padding area might not be (zero-)initialized. -template - requires std::destructible +template + requires std::destructible // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,clang-analyzer-optin.performance.Padding) class spsc_bound_queue final { private: // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays) - using raw_queue_type = std::byte[Capacity * sizeof(T)]; + using storage_type = std::byte[Size * sizeof(Type)]; public: using size_type = std::size_t; - using value_type = T; + using value_type = Type; using reference = value_type&; @@ -111,11 +92,7 @@ class spsc_bound_queue final { auto operator=(spsc_bound_queue&&) -> spsc_bound_queue& = delete; - /// @note Padding area might not be (zero-)initialized. Instance-to-instance - /// comparision is undefined behavior. - auto operator<=>(spsc_bound_queue const&) const = delete; - - [[nodiscard]] auto empty_unsafe() const noexcept -> bool + [[nodiscard]] auto empty() const noexcept -> bool { using std::atomic_load_explicit; @@ -165,40 +142,30 @@ class spsc_bound_queue final { { using std::atomic_load_explicit; - auto const cursor_snapshot{ + auto const last{ atomic_load_explicit(&write_cursor_, std::memory_order_acquire) }; -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-container" -#endif // __clang__ - return span_type( detail::get_ptr_to_obj(std::data(raw_queue_), {}), - static_cast(cursor_snapshot) + static_cast(last) ); - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif // __clang__ } - [[nodiscard]] static consteval auto capacity() noexcept -> size_type + [[nodiscard]] static constexpr auto capacity() noexcept -> size_type { return capacity_; } private: - static_assert(std::has_single_bit(Capacity)); - static constexpr std::size_t const capacity_{Capacity}; + static constexpr std::size_t const capacity_{Size}; /// Raw cursor type, without atomic wrapper. using cursor_type = std::size_t; static_assert(std::atomic::is_always_lock_free); - alignas(T) raw_queue_type raw_queue_; + alignas(Type) storage_type raw_queue_; static_assert(std::same_as); diff --git a/test/concurrency/spsc_bound_queue_statictest.cpp b/test/concurrency/spsc_bound_queue_statictest.cpp index e32f6df1..5b28d525 100644 --- a/test/concurrency/spsc_bound_queue_statictest.cpp +++ b/test/concurrency/spsc_bound_queue_statictest.cpp @@ -4,7 +4,6 @@ // SPDX-License-Identifier: MIT -#include #include #include #include @@ -51,14 +50,6 @@ TEST_CASE("Wait-free SPSC append-only bounded queue", "[spsc_bound_queue]") ); } - SECTION("Capacity must be a power of two") - { - using queue_type - = forfun::concurrency::wait_free::spsc_bound_queue; - - STATIC_REQUIRE(std::has_single_bit(queue_type::capacity())); - } - SECTION("Capacity is as requested") { using queue_type diff --git a/test/concurrency/spsc_bound_queue_test.cpp b/test/concurrency/spsc_bound_queue_test.cpp index 09e77d36..86207f23 100644 --- a/test/concurrency/spsc_bound_queue_test.cpp +++ b/test/concurrency/spsc_bound_queue_test.cpp @@ -160,7 +160,7 @@ TEMPLATE_TEST_CASE_SIG( forfun::concurrency::wait_free::spsc_bound_queue const queue{}; - REQUIRE(queue.empty_unsafe()); + REQUIRE(queue.empty()); } SECTION("Capacity is as requested") @@ -177,11 +177,11 @@ TEMPLATE_TEST_CASE_SIG( queue.emplace_back(677); - REQUIRE_FALSE(queue.empty_unsafe()); + REQUIRE_FALSE(queue.empty()); queue.emplace_back(683); - REQUIRE_FALSE(queue.empty_unsafe()); + REQUIRE_FALSE(queue.empty()); } SECTION("Emplace affects span size") @@ -266,7 +266,7 @@ TEMPLATE_TEST_CASE_SIG( REQUIRE(ref == n); } - REQUIRE_FALSE(queue.empty_unsafe()); + REQUIRE_FALSE(queue.empty()); REQUIRE(queue.to_span().size() == queue_capacity); @@ -301,7 +301,7 @@ TEMPLATE_TEST_CASE_SIG( queue.reset_unsafe(); - REQUIRE(queue.empty_unsafe()); + REQUIRE(queue.empty()); } SECTION("Reset call on non-empty non-full queue") @@ -313,7 +313,7 @@ TEMPLATE_TEST_CASE_SIG( queue.reset_unsafe(); - REQUIRE(queue.empty_unsafe()); + REQUIRE(queue.empty()); } SECTION("Destructor call on empty queue") @@ -371,7 +371,7 @@ TEST_CASE( { forfun::concurrency::wait_free::spsc_bound_queue const queue{}; - REQUIRE(queue.empty_unsafe()); + REQUIRE(queue.empty()); } SECTION("Capacity is as requested") @@ -393,7 +393,7 @@ TEST_CASE( queue.reset_unsafe(); - REQUIRE(queue.empty_unsafe()); + REQUIRE(queue.empty()); REQUIRE(queue.to_span().empty()); @@ -420,7 +420,7 @@ TEST_CASE( queue.reset_unsafe(); - REQUIRE(queue.empty_unsafe()); + REQUIRE(queue.empty()); } SECTION("Fill, reset, refill, and read queue") @@ -441,7 +441,7 @@ TEST_CASE( queue.reset_unsafe(); - REQUIRE(queue.empty_unsafe()); + REQUIRE(queue.empty()); queue.emplace_back(1); queue.emplace_back(2); @@ -452,7 +452,7 @@ TEST_CASE( queue.emplace_back(7); queue.emplace_back(8); - REQUIRE_FALSE(queue.empty_unsafe()); + REQUIRE_FALSE(queue.empty()); REQUIRE(queue.to_span().size() == queue_capacity); @@ -494,7 +494,7 @@ TEST_CASE( queue.emplace_back(604171); queue.emplace_back(971767); - REQUIRE_FALSE(queue.empty_unsafe()); + REQUIRE_FALSE(queue.empty()); REQUIRE(dummy_with_tracked_destructor::alive_instances() == 3UZ); @@ -506,7 +506,7 @@ TEST_CASE( queue.reset_unsafe(); - REQUIRE(queue.empty_unsafe()); + REQUIRE(queue.empty()); REQUIRE(dummy_with_tracked_destructor::alive_instances() == 0UZ); } @@ -527,7 +527,7 @@ TEST_CASE( queue.emplace_back(1062599); queue.emplace_back(1282529); - REQUIRE_FALSE(queue.empty_unsafe()); + REQUIRE_FALSE(queue.empty()); REQUIRE(dummy_with_tracked_destructor::alive_instances() == 2UZ); From ed94a29d01f2e7e13ae43ac910f95880043411b5 Mon Sep 17 00:00:00 2001 From: Omar Boukli-Hacene Date: Mon, 9 Nov 2026 22:35:18 +0200 Subject: [PATCH 6/9] perf: Fix pessimization --- .../forfun/concurrency/spsc_bound_queue.hpp | 31 ++++++++++++------- 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/include/forfun/concurrency/spsc_bound_queue.hpp b/include/forfun/concurrency/spsc_bound_queue.hpp index 26758ee0..23be0905 100644 --- a/include/forfun/concurrency/spsc_bound_queue.hpp +++ b/include/forfun/concurrency/spsc_bound_queue.hpp @@ -104,22 +104,28 @@ class spsc_bound_queue final { template auto emplace_back(Args&&... args) noexcept -> reference { + using std::atomic_load_explicit; using std::atomic_store_explicit; static_assert(capacity_ != 0UZ); - assert(std::cmp_less(write_cursor_cached_, capacity_)); + auto const write_cursor_copy{ + atomic_load_explicit(&write_cursor_, std::memory_order_relaxed) + }; + + assert(std::cmp_less(write_cursor_copy, capacity_)); auto* const ptr_emplaced{std::construct_at( detail::get_ptr_to_obj( - std::data(raw_queue_), write_cursor_cached_ + std::data(raw_queue_), write_cursor_copy ), std::forward(args)... )}; - ++write_cursor_cached_; atomic_store_explicit( - &write_cursor_, write_cursor_cached_, std::memory_order_release + &write_cursor_, + write_cursor_copy + cursor_type{1}, + std::memory_order_release ); return *ptr_emplaced; @@ -131,8 +137,6 @@ class spsc_bound_queue final { reset_storage(); - write_cursor_cached_ = {}; - atomic_store_explicit( &write_cursor_, cursor_type{}, std::memory_order_release ); @@ -188,8 +192,6 @@ class spsc_bound_queue final { #pragma warning(pop) // C4324 #endif // _MSC_VER - cursor_type write_cursor_cached_{}; - static_assert( std::hardware_destructive_interference_size >= sizeof(cursor_type) ); @@ -205,14 +207,19 @@ class spsc_bound_queue final { auto reset_storage() noexcept -> void { - assert(std::cmp_less_equal(write_cursor_cached_, capacity_)); + using std::atomic_load_explicit; + + auto const write_cursor_copy{ + atomic_load_explicit(&write_cursor_, std::memory_order_relaxed) + }; + + assert(std::cmp_less_equal(write_cursor_copy, capacity_)); if constexpr (not std::is_trivially_destructible_v) { - auto const size{static_cast(write_cursor_cached_)}; + auto const size{static_cast(write_cursor_copy)}; auto* reversed_first{detail::get_ptr_to_obj( - std::data(raw_queue_), - static_cast(write_cursor_cached_) + std::data(raw_queue_), static_cast(write_cursor_copy) )}; for (auto i{size}; i != size_type{}; --i) { From c0fd86834e3f351441ce0fbe9ff6ece2bb517ab5 Mon Sep 17 00:00:00 2001 From: Omar Boukli-Hacene Date: Mon, 9 Nov 2026 22:40:18 +0200 Subject: [PATCH 7/9] refactor: Inject cache line separation size --- .../spsc_bound_queue_benchmark.cpp | 15 +- .../forfun/concurrency/spsc_bound_queue.hpp | 24 +-- .../spsc_bound_queue_statictest.cpp | 46 +++-- test/concurrency/spsc_bound_queue_test.cpp | 185 +++++++++++------- 4 files changed, 168 insertions(+), 102 deletions(-) diff --git a/benchmark/concurrency/spsc_bound_queue_benchmark.cpp b/benchmark/concurrency/spsc_bound_queue_benchmark.cpp index ded4761b..c048bcea 100644 --- a/benchmark/concurrency/spsc_bound_queue_benchmark.cpp +++ b/benchmark/concurrency/spsc_bound_queue_benchmark.cpp @@ -5,6 +5,7 @@ // SPDX-License-Identifier: MIT #include +#include #include @@ -29,12 +30,22 @@ TEST_CASE( .relative(true) .run( - NAMEOF_RAW(wait_free::spsc_bound_queue{}).c_str(), + NAMEOF_RAW( + wait_free::spsc_bound_queue< + int, + capacity, + std::hardware_destructive_interference_size>{} + ) + .c_str(), [] noexcept -> void { // NOLINTNEXTLINE(cppcoreguidelines-init-variables) int volatile val /*[[indeterminate]]*/; - wait_free::spsc_bound_queue queue{}; + wait_free::spsc_bound_queue< + int, + capacity, + std::hardware_destructive_interference_size> + queue{}; queue.emplace_back(502807); val = queue.to_span().back(); diff --git a/include/forfun/concurrency/spsc_bound_queue.hpp b/include/forfun/concurrency/spsc_bound_queue.hpp index 23be0905..c3f042f1 100644 --- a/include/forfun/concurrency/spsc_bound_queue.hpp +++ b/include/forfun/concurrency/spsc_bound_queue.hpp @@ -13,7 +13,6 @@ #include #include #include -#include #include #include @@ -51,7 +50,7 @@ get_ptr_to_obj(std::byte* const buffer, std::size_t const offset) noexcept /// @note The implementation prioritizes performance over safety and security. /// /// @note Internal storage and padding area might not be (zero-)initialized. -template +template requires std::destructible // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,clang-analyzer-optin.performance.Padding) class spsc_bound_queue final { @@ -173,36 +172,21 @@ class spsc_bound_queue final { static_assert(std::same_as); -#if defined(__GNUC__) && !defined(__clang__) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Winterference-size" -#endif // defined(__GNUC__) && !defined(__clang__) - #ifdef _MSC_VER #pragma warning(push) // Warning C4324: 'type': structure was padded due to alignment specifier. #pragma warning(disable : 4324) #endif // _MSC_VER - alignas( - std::hardware_destructive_interference_size - ) std::atomic write_cursor_{0}; + alignas(CacheLineSeparation) std::atomic write_cursor_{0}; #ifdef _MSC_VER #pragma warning(pop) // C4324 #endif // _MSC_VER - static_assert( - std::hardware_destructive_interference_size >= sizeof(cursor_type) - ); - -#if defined(__GNUC__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif // defined(__GNUC__) && !defined(__clang__) + static_assert(CacheLineSeparation >= sizeof(cursor_type)); - std::array< - std::byte, - std::hardware_destructive_interference_size - sizeof(cursor_type)> + std::array end_of_object_padding_; auto reset_storage() noexcept -> void diff --git a/test/concurrency/spsc_bound_queue_statictest.cpp b/test/concurrency/spsc_bound_queue_statictest.cpp index 5b28d525..0d778af2 100644 --- a/test/concurrency/spsc_bound_queue_statictest.cpp +++ b/test/concurrency/spsc_bound_queue_statictest.cpp @@ -6,6 +6,7 @@ #include #include +#include #include #include #include @@ -20,25 +21,35 @@ TEST_CASE("Wait-free SPSC append-only bounded queue", "[spsc_bound_queue]") { STATIC_REQUIRE_FALSE( std::has_unique_object_representations_v< - forfun::concurrency::wait_free::spsc_bound_queue> + forfun::concurrency::wait_free::spsc_bound_queue< + char, + 8, + std::hardware_destructive_interference_size>> ); STATIC_REQUIRE_FALSE( std::has_unique_object_representations_v< - forfun::concurrency::wait_free::spsc_bound_queue> + forfun::concurrency::wait_free::spsc_bound_queue< + int, + 8, + std::hardware_destructive_interference_size>> ); } SECTION("Construction and initialization") { STATIC_REQUIRE_FALSE( - std::copyable< - forfun::concurrency::wait_free::spsc_bound_queue> + std::copyable> ); STATIC_REQUIRE_FALSE( - std::movable< - forfun::concurrency::wait_free::spsc_bound_queue> + std::movable> ); } @@ -46,22 +57,29 @@ TEST_CASE("Wait-free SPSC append-only bounded queue", "[spsc_bound_queue]") { STATIC_REQUIRE_FALSE( std::equality_comparable< - forfun::concurrency::wait_free::spsc_bound_queue> + forfun::concurrency::wait_free::spsc_bound_queue< + int, + 8, + std::hardware_destructive_interference_size>> ); } SECTION("Capacity is as requested") { - using queue_type - = forfun::concurrency::wait_free::spsc_bound_queue; + using queue_type = forfun::concurrency::wait_free::spsc_bound_queue< + int, + 8, + std::hardware_destructive_interference_size>; STATIC_REQUIRE(queue_type::capacity() == 8UZ); } SECTION("Type aliases") { - using queue_type - = forfun::concurrency::wait_free::spsc_bound_queue; + using queue_type = forfun::concurrency::wait_free::spsc_bound_queue< + int, + 8, + std::hardware_destructive_interference_size>; STATIC_REQUIRE(std::same_as); @@ -72,8 +90,10 @@ TEST_CASE("Wait-free SPSC append-only bounded queue", "[spsc_bound_queue]") SECTION("To span") { - using queue_type - = forfun::concurrency::wait_free::spsc_bound_queue; + using queue_type = forfun::concurrency::wait_free::spsc_bound_queue< + int, + 8, + std::hardware_destructive_interference_size>; STATIC_REQUIRE(std::same_as>); diff --git a/test/concurrency/spsc_bound_queue_test.cpp b/test/concurrency/spsc_bound_queue_test.cpp index 86207f23..6c71f297 100644 --- a/test/concurrency/spsc_bound_queue_test.cpp +++ b/test/concurrency/spsc_bound_queue_test.cpp @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -148,32 +149,35 @@ TEMPLATE_TEST_CASE_SIG( (int, 16UZ) ) { + using buffer_type = forfun::concurrency::wait_free::spsc_bound_queue< + Type, + Size, + std::hardware_destructive_interference_size>; + SECTION("Initial span is empty") { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + buffer_type queue{}; REQUIRE(queue.to_span().empty()); } SECTION("Initially empty") { - forfun::concurrency::wait_free::spsc_bound_queue const - queue{}; + buffer_type const queue{}; REQUIRE(queue.empty()); } SECTION("Capacity is as requested") { - forfun::concurrency::wait_free::spsc_bound_queue const - queue{}; + buffer_type const queue{}; REQUIRE(queue.capacity() == Size); } SECTION("Emplace affects empty state") { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + buffer_type queue{}; queue.emplace_back(677); @@ -186,7 +190,7 @@ TEMPLATE_TEST_CASE_SIG( SECTION("Emplace affects span size") { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + buffer_type queue{}; queue.emplace_back(691); @@ -207,7 +211,7 @@ TEMPLATE_TEST_CASE_SIG( SECTION("Emplace affects span back") { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + buffer_type queue{}; queue.emplace_back(-2); @@ -232,7 +236,7 @@ TEMPLATE_TEST_CASE_SIG( SECTION("Emplace returns reference to emplaced element") { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + buffer_type queue{}; decltype(auto) ref_to_emplaced{queue.emplace_back(225149)}; @@ -249,39 +253,31 @@ TEMPLATE_TEST_CASE_SIG( SECTION("Emplace till full then read all") { - using ValueType = int; - - constexpr std::size_t const queue_capacity{8}; - - forfun::concurrency::wait_free:: - spsc_bound_queue - queue{}; + buffer_type buffer{}; - for ( - ValueType const n : - std::views::iota(ValueType{1}) | std::views::take(queue_capacity) - ) + for (Type const n : std::views::iota(Type{1}) | std::views::take(Size)) { - auto const& ref{queue.emplace_back(n)}; + auto const& ref{buffer.emplace_back(n)}; + REQUIRE(ref == n); } - REQUIRE_FALSE(queue.empty()); + REQUIRE_FALSE(buffer.empty()); - REQUIRE(queue.to_span().size() == queue_capacity); + REQUIRE(buffer.to_span().size() == Size); REQUIRE( std::ranges::equal( - queue.to_span(), - std::views::iota(ValueType{1}) - | std::views::take(queue.to_span().size()) + buffer.to_span(), + std::views::iota(Type{1}) + | std::views::take(buffer.to_span().size()) ) ); } SECTION("To span") { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + buffer_type queue{}; queue.emplace_back(727); queue.emplace_back(733); @@ -297,7 +293,7 @@ TEMPLATE_TEST_CASE_SIG( SECTION("Reset call on empty queue") { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + buffer_type queue{}; queue.reset_unsafe(); @@ -306,7 +302,7 @@ TEMPLATE_TEST_CASE_SIG( SECTION("Reset call on non-empty non-full queue") { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + buffer_type queue{}; queue.emplace_back(1); queue.emplace_back(2); queue.emplace_back(3); @@ -319,8 +315,7 @@ TEMPLATE_TEST_CASE_SIG( SECTION("Destructor call on empty queue") { { - forfun::concurrency::wait_free::spsc_bound_queue const - queue{}; + buffer_type const queue{}; } SUCCEED(); @@ -329,8 +324,7 @@ TEMPLATE_TEST_CASE_SIG( SECTION("Destructor call on non-empty queue") { { - forfun::concurrency::wait_free::spsc_bound_queue - queue{}; + buffer_type queue{}; queue.emplace_back(1); } @@ -340,8 +334,7 @@ TEMPLATE_TEST_CASE_SIG( SECTION("Destructor call on non-empty non-full queue") { { - forfun::concurrency::wait_free::spsc_bound_queue - queue{}; + buffer_type queue{}; queue.emplace_back(1); queue.emplace_back(2); queue.emplace_back(3); @@ -362,28 +355,42 @@ TEST_CASE( { SECTION("Initial span is empty") { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + forfun::concurrency::wait_free::spsc_bound_queue< + int, + 1, + std::hardware_destructive_interference_size> + queue{}; REQUIRE(queue.to_span().empty()); } SECTION("Initially empty") { - forfun::concurrency::wait_free::spsc_bound_queue const queue{}; + forfun::concurrency::wait_free::spsc_bound_queue< + int, + 1, + std::hardware_destructive_interference_size> const queue{}; REQUIRE(queue.empty()); } SECTION("Capacity is as requested") { - forfun::concurrency::wait_free::spsc_bound_queue const queue{}; + forfun::concurrency::wait_free::spsc_bound_queue< + int, + 1, + std::hardware_destructive_interference_size> const queue{}; REQUIRE(queue.capacity() == 1UZ); } SECTION("Single-slot queue resets cleanly and refills") { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + forfun::concurrency::wait_free::spsc_bound_queue< + int, + 1, + std::hardware_destructive_interference_size> + queue{}; queue.emplace_back(11); @@ -408,7 +415,11 @@ TEST_CASE( SECTION("Reset call on full queue") { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + forfun::concurrency::wait_free::spsc_bound_queue< + int, + 8, + std::hardware_destructive_interference_size> + queue{}; queue.emplace_back(1); queue.emplace_back(2); queue.emplace_back(3); @@ -429,7 +440,11 @@ TEST_CASE( constexpr std::size_t const queue_capacity{8}; - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + forfun::concurrency::wait_free::spsc_bound_queue< + int, + 8, + std::hardware_destructive_interference_size> + queue{}; queue.emplace_back(10); queue.emplace_back(20); queue.emplace_back(30); @@ -468,7 +483,11 @@ TEST_CASE( SECTION("Destructor call on full queue") { { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + forfun::concurrency::wait_free::spsc_bound_queue< + int, + 8, + std::hardware_destructive_interference_size> + queue{}; queue.emplace_back(1); queue.emplace_back(2); queue.emplace_back(3); @@ -486,9 +505,11 @@ TEST_CASE( { destructor_call_counter_guard const guard; { - forfun::concurrency::wait_free:: - spsc_bound_queue - queue{}; + forfun::concurrency::wait_free::spsc_bound_queue< + dummy_with_tracked_destructor, + 4, + std::hardware_destructive_interference_size> + queue{}; queue.emplace_back(584141); queue.emplace_back(604171); @@ -520,9 +541,11 @@ TEST_CASE( { destructor_call_counter_guard const guard; { - forfun::concurrency::wait_free:: - spsc_bound_queue - queue{}; + forfun::concurrency::wait_free::spsc_bound_queue< + dummy_with_tracked_destructor, + 4, + std::hardware_destructive_interference_size> + queue{}; queue.emplace_back(1062599); queue.emplace_back(1282529); @@ -555,12 +578,19 @@ TEST_CASE( static constexpr auto const expected = {208739, 208759, 208787, 208799, 208807, 208837, 208843, 208877}; - using SizeType = forfun::concurrency::wait_free:: - spsc_bound_queue::size_type; - using ValueType = forfun::concurrency::wait_free:: - spsc_bound_queue::value_type; - - forfun::concurrency::wait_free::spsc_bound_queue + using SizeType = forfun::concurrency::wait_free::spsc_bound_queue< + int, + queue_size, + std::hardware_destructive_interference_size>::size_type; + using ValueType = forfun::concurrency::wait_free::spsc_bound_queue< + int, + queue_size, + std::hardware_destructive_interference_size>::value_type; + + forfun::concurrency::wait_free::spsc_bound_queue< + int, + queue_size, + std::hardware_destructive_interference_size> queue{}; std::vector consumer_bag{}; @@ -618,10 +648,15 @@ TEST_CASE( using ValueType = dummy_aggregate; - using SizeType = forfun::concurrency::wait_free:: - spsc_bound_queue::size_type; + using SizeType = forfun::concurrency::wait_free::spsc_bound_queue< + ValueType, + queue_size, + std::hardware_destructive_interference_size>::size_type; - forfun::concurrency::wait_free::spsc_bound_queue + forfun::concurrency::wait_free::spsc_bound_queue< + ValueType, + queue_size, + std::hardware_destructive_interference_size> queue{}; std::vector consumer_bag{}; @@ -692,12 +727,19 @@ TEST_CASE( static constexpr auto const expected = {208739, 208759, 208787, 208799, 208807, 208837, 208843, 208877}; - using SizeType = forfun::concurrency::wait_free:: - spsc_bound_queue::size_type; - using ValueType = forfun::concurrency::wait_free:: - spsc_bound_queue::value_type; - - forfun::concurrency::wait_free::spsc_bound_queue + using SizeType = forfun::concurrency::wait_free::spsc_bound_queue< + int, + queue_size, + std::hardware_destructive_interference_size>::size_type; + using ValueType = forfun::concurrency::wait_free::spsc_bound_queue< + int, + queue_size, + std::hardware_destructive_interference_size>::value_type; + + forfun::concurrency::wait_free::spsc_bound_queue< + int, + queue_size, + std::hardware_destructive_interference_size> queue{}; std::vector consumer_bag{}; @@ -761,10 +803,15 @@ TEST_CASE( using ValueType = dummy_aggregate; - using SizeType = forfun::concurrency::wait_free:: - spsc_bound_queue::size_type; + using SizeType = forfun::concurrency::wait_free::spsc_bound_queue< + ValueType, + queue_size, + std::hardware_destructive_interference_size>::size_type; - forfun::concurrency::wait_free::spsc_bound_queue + forfun::concurrency::wait_free::spsc_bound_queue< + ValueType, + queue_size, + std::hardware_destructive_interference_size> queue{}; std::vector consumer_bag{}; @@ -833,7 +880,11 @@ TEST_CASE( // NOLINTNEXTLINE(cppcoreguidelines-init-variables) int volatile val /*[[indeterminate]]*/; - forfun::concurrency::wait_free::spsc_bound_queue queue{}; + forfun::concurrency::wait_free::spsc_bound_queue< + int, + capacity, + std::hardware_destructive_interference_size> + queue{}; queue.emplace_back(502807); val = queue.to_span().back(); From dbda947deb35989ed14753371952f0b1f60693eb Mon Sep 17 00:00:00 2001 From: Omar Boukli-Hacene Date: Mon, 9 Nov 2026 22:45:18 +0200 Subject: [PATCH 8/9] refactor: Revisit constraints --- .../forfun/concurrency/spsc_bound_queue.hpp | 20 ++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/include/forfun/concurrency/spsc_bound_queue.hpp b/include/forfun/concurrency/spsc_bound_queue.hpp index c3f042f1..ffc39d1f 100644 --- a/include/forfun/concurrency/spsc_bound_queue.hpp +++ b/include/forfun/concurrency/spsc_bound_queue.hpp @@ -9,11 +9,14 @@ #include #include +#include #include #include #include +#include #include #include +#include #include namespace forfun::concurrency::wait_free { @@ -51,7 +54,20 @@ get_ptr_to_obj(std::byte* const buffer, std::size_t const offset) noexcept /// /// @note Internal storage and padding area might not be (zero-)initialized. template - requires std::destructible + requires std::is_object_v + and std::same_as> + and (not std::is_array_v) + and std::destructible + and (Size > 0UZ) + // NOLINTNEXTLINE(readability-redundant-parentheses) + and (std::cmp_less_equal( + Size, std::numeric_limits::max() / sizeof(Type) + )) + // NOLINTNEXTLINE(readability-redundant-parentheses) + and (std::cmp_less_equal(Size, std::numeric_limits::max())) + // NOLINTNEXTLINE(readability-redundant-parentheses) + and (std::has_single_bit(CacheLineSeparation)) + and (CacheLineSeparation >= alignof(std::atomic)) // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,clang-analyzer-optin.performance.Padding) class spsc_bound_queue final { private: @@ -106,8 +122,6 @@ class spsc_bound_queue final { using std::atomic_load_explicit; using std::atomic_store_explicit; - static_assert(capacity_ != 0UZ); - auto const write_cursor_copy{ atomic_load_explicit(&write_cursor_, std::memory_order_relaxed) }; From 39c6bec4b2fa27fbed1eae85c6a389d72c74ba58 Mon Sep 17 00:00:00 2001 From: Omar Boukli-Hacene Date: Mon, 9 Nov 2026 22:50:18 +0200 Subject: [PATCH 9/9] refactor: Rename wait-free data structure --- CMakeLists.txt | 4 +- README.md | 4 +- .../spsc_bound_queue_benchmark.cpp | 103 -- .../swmr_append_buffer_benchmark.cpp | 100 ++ cmake/BenchmarkTargets.cmake | 2 +- cmake/TestTargets.cmake | 4 +- docs/problem_alias.md | 2 +- ...bound_queue.hpp => swmr_append_buffer.hpp} | 42 +- ...bound_queue.cpp => swmr_append_buffer.cpp} | 2 +- test/concurrency/spsc_bound_queue_test.cpp | 939 ------------------ ....cpp => swmr_append_buffer_statictest.cpp} | 34 +- test/concurrency/swmr_append_buffer_test.cpp | 920 +++++++++++++++++ 12 files changed, 1066 insertions(+), 1090 deletions(-) delete mode 100644 benchmark/concurrency/spsc_bound_queue_benchmark.cpp create mode 100644 benchmark/concurrency/swmr_append_buffer_benchmark.cpp rename include/forfun/concurrency/{spsc_bound_queue.hpp => swmr_append_buffer.hpp} (83%) rename src/forfun/concurrency/{spsc_bound_queue.cpp => swmr_append_buffer.cpp} (70%) delete mode 100644 test/concurrency/spsc_bound_queue_test.cpp rename test/concurrency/{spsc_bound_queue_statictest.cpp => swmr_append_buffer_statictest.cpp} (61%) create mode 100644 test/concurrency/swmr_append_buffer_test.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index e65e6cff..c2993046 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -215,9 +215,9 @@ forfun_target_config( forfun_target_config( forfun_lock_free HEADERS - "forfun/concurrency/spsc_bound_queue.hpp" + "forfun/concurrency/swmr_append_buffer.hpp" SOURCES - "forfun/concurrency/spsc_bound_queue.cpp" + "forfun/concurrency/swmr_append_buffer.cpp" ) forfun_target_config( diff --git a/README.md b/README.md index f83f2377..cb052d9d 100644 --- a/README.md +++ b/README.md @@ -44,7 +44,7 @@ leveraged by this project: - EditorConfig - Markdown - Diagramming with Mermaid -- Lock-free and wait-free algorithms +- Lock-free and wait-free algorithms and data structure ## Index @@ -121,7 +121,7 @@ leveraged by this project: | Valid Anagram | [`include/forfun/valid_anagram.hpp`](include/forfun/valid_anagram.hpp) | | Valid Parentheses | [`src/forfun/valid_parentheses.cpp`](src/forfun/valid_parentheses.cpp) | | Valid Sudoku | [`include/forfun/valid_sudoku.hpp`](include/forfun/valid_sudoku.hpp) | -| Wait-free (lock-free) SPSC append-only bounded queue | [`include/forfun/concurrency/spsc_bound_queue.hpp`](include/forfun/concurrency/spsc_bound_queue.hpp) | +| Wait-free (lock-free) SWMR append buffer | [`include/forfun/concurrency/swmr_append_buffer.hpp`](include/forfun/concurrency/swmr_append_buffer.hpp) | ## Disclaimer diff --git a/benchmark/concurrency/spsc_bound_queue_benchmark.cpp b/benchmark/concurrency/spsc_bound_queue_benchmark.cpp deleted file mode 100644 index c048bcea..00000000 --- a/benchmark/concurrency/spsc_bound_queue_benchmark.cpp +++ /dev/null @@ -1,103 +0,0 @@ -// Copyright (c) Omar Boukli-Hacene. All rights reserved. -// Distributed under an MIT-style license that can be -// found in the LICENSE file. - -// SPDX-License-Identifier: MIT - -#include -#include - -#include - -#include - -#include - -#include - -TEST_CASE( - "Wait-free SPSC append-only bounded queue benchmarking", - "[benchmark][spsc_bound_queue]" -) -{ - using namespace forfun::concurrency; - - static constexpr std::size_t const capacity{16}; - - ankerl::nanobench::Bench() - - .title("Wait-free SPSC append-only bounded queue") - .relative(true) - - .run( - NAMEOF_RAW( - wait_free::spsc_bound_queue< - int, - capacity, - std::hardware_destructive_interference_size>{} - ) - .c_str(), - [] noexcept -> void { - // NOLINTNEXTLINE(cppcoreguidelines-init-variables) - int volatile val /*[[indeterminate]]*/; - - wait_free::spsc_bound_queue< - int, - capacity, - std::hardware_destructive_interference_size> - queue{}; - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - ankerl::nanobench::doNotOptimizeAway(&val); - } - ) - - ; -} diff --git a/benchmark/concurrency/swmr_append_buffer_benchmark.cpp b/benchmark/concurrency/swmr_append_buffer_benchmark.cpp new file mode 100644 index 00000000..43cd14e2 --- /dev/null +++ b/benchmark/concurrency/swmr_append_buffer_benchmark.cpp @@ -0,0 +1,100 @@ +// Copyright (c) Omar Boukli-Hacene. All rights reserved. +// Distributed under an MIT-style license that can be +// found in the LICENSE file. + +// SPDX-License-Identifier: MIT + +#include +#include + +#include + +#include + +#include + +#include + +TEST_CASE("SWMR append buffer benchmarking", "[benchmark][swmr_append_buffer]") +{ + using namespace forfun::concurrency; + + static constexpr std::size_t const capacity{16}; + + ankerl::nanobench::Bench() + + .title("SWMR append buffer") + .relative(true) + + .run( + NAMEOF_RAW( + wait_free::swmr_append_buffer< + int, + capacity, + std::hardware_destructive_interference_size>{} + ) + .c_str(), + [] noexcept -> void { + // NOLINTNEXTLINE(cppcoreguidelines-init-variables) + int volatile val /*[[indeterminate]]*/; + + wait_free::swmr_append_buffer< + int, + capacity, + std::hardware_destructive_interference_size> + buffer{}; + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + ankerl::nanobench::doNotOptimizeAway(&val); + } + ) + + ; +} diff --git a/cmake/BenchmarkTargets.cmake b/cmake/BenchmarkTargets.cmake index 1c0f3ad7..c4e05f61 100644 --- a/cmake/BenchmarkTargets.cmake +++ b/cmake/BenchmarkTargets.cmake @@ -130,7 +130,7 @@ forfun_target_config( SOURCES_DIR "benchmark" SOURCES "benchmark.cpp" - "concurrency/spsc_bound_queue_benchmark.cpp" + "concurrency/swmr_append_buffer_benchmark.cpp" ) target_link_libraries( benchmark_driver_lock_free diff --git a/cmake/TestTargets.cmake b/cmake/TestTargets.cmake index be3798bd..6d09435a 100644 --- a/cmake/TestTargets.cmake +++ b/cmake/TestTargets.cmake @@ -24,7 +24,7 @@ forfun_target_config( "common/concepts_statictest.cpp" "common/limits_statictest.cpp" "common/type_traits_statictest.cpp" - "concurrency/spsc_bound_queue_statictest.cpp" + "concurrency/swmr_append_buffer_statictest.cpp" "container/forward_list_cycle_statictest.cpp" "container/forward_list_statictest.cpp" "container/internal/list_const_iterator_statictest.cpp" @@ -199,7 +199,7 @@ forfun_target_config( test_driver_lock_free SOURCES_DIR "test" SOURCES - "concurrency/spsc_bound_queue_test.cpp" + "concurrency/swmr_append_buffer_test.cpp" ) target_link_libraries( test_driver_lock_free diff --git a/docs/problem_alias.md b/docs/problem_alias.md index 56684508..12cdb536 100644 --- a/docs/problem_alias.md +++ b/docs/problem_alias.md @@ -35,7 +35,7 @@ benchmarks. | List Bidirectional Iterator | | Primality Test | | Tower of Hanoi | -| Wait-free (lock-free) SPSC append-only bounded queue | +| Wait-free (lock-free) SWMR append buffer | ### LeetCode problems diff --git a/include/forfun/concurrency/spsc_bound_queue.hpp b/include/forfun/concurrency/swmr_append_buffer.hpp similarity index 83% rename from include/forfun/concurrency/spsc_bound_queue.hpp rename to include/forfun/concurrency/swmr_append_buffer.hpp index ffc39d1f..314e1a5f 100644 --- a/include/forfun/concurrency/spsc_bound_queue.hpp +++ b/include/forfun/concurrency/swmr_append_buffer.hpp @@ -4,8 +4,8 @@ // SPDX-License-Identifier: MIT -#ifndef FORFUN_CONCURRENCY_SPSC_APPEND_QUEUE_HPP_ -#define FORFUN_CONCURRENCY_SPSC_APPEND_QUEUE_HPP_ +#ifndef FORFUN_CONCURRENCY_SWMR_APPEND_BUFFER_HPP_ +#define FORFUN_CONCURRENCY_SWMR_APPEND_BUFFER_HPP_ #include #include @@ -40,19 +40,17 @@ get_ptr_to_obj(std::byte* const buffer, std::size_t const offset) noexcept } // namespace detail -/// Single-producer single-consumer (SPSC) bound queue. +/// Single-writer multiple non-claiming readers, bounded append-only buffer. /// /// Features: /// - Wait-free (lock-free) concurrency model -/// - First in, first out (FIFO) order semantics +/// - Fixed-capacity, and non-circular /// - Multi-pass reads via @c std::span -/// - Bounded, fixed-capacity, and non-circular /// - Inline storage with no dynamic allocation -/// - Append-only; elements are deconstructed when the queue is deconstructed. +/// - Append-one by one; Reset all, manually or when buffer is destroyed. /// -/// @note The implementation prioritizes performance over safety and security. -/// -/// @note Internal storage and padding area might not be (zero-)initialized. +/// @warning Experimental implementation. Has not been reviewed for safety or +/// security. template requires std::is_object_v and std::same_as> @@ -69,7 +67,7 @@ template and (std::has_single_bit(CacheLineSeparation)) and (CacheLineSeparation >= alignof(std::atomic)) // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,clang-analyzer-optin.performance.Padding) -class spsc_bound_queue final { +class swmr_append_buffer final { private: // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays) using storage_type = std::byte[Size * sizeof(Type)]; @@ -84,28 +82,28 @@ class spsc_bound_queue final { using span_type = std::span; // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,modernize-use-equals-default) - spsc_bound_queue() noexcept + swmr_append_buffer() noexcept { // Avoid zero initialization. } - spsc_bound_queue(spsc_bound_queue const&) = delete; + swmr_append_buffer(swmr_append_buffer const&) = delete; - spsc_bound_queue(spsc_bound_queue&&) = delete; + swmr_append_buffer(swmr_append_buffer&&) = delete; - ~spsc_bound_queue() + ~swmr_append_buffer() requires std::is_trivially_destructible_v = default; - ~spsc_bound_queue() + ~swmr_append_buffer() requires(not std::is_trivially_destructible_v) { reset_storage(); } - auto operator=(spsc_bound_queue const&) -> spsc_bound_queue& = delete; + auto operator=(swmr_append_buffer const&) -> swmr_append_buffer& = delete; - auto operator=(spsc_bound_queue&&) -> spsc_bound_queue& = delete; + auto operator=(swmr_append_buffer&&) -> swmr_append_buffer& = delete; [[nodiscard]] auto empty() const noexcept -> bool { @@ -130,7 +128,7 @@ class spsc_bound_queue final { auto* const ptr_emplaced{std::construct_at( detail::get_ptr_to_obj( - std::data(raw_queue_), write_cursor_copy + std::data(storage_), write_cursor_copy ), std::forward(args)... )}; @@ -164,7 +162,7 @@ class spsc_bound_queue final { }; return span_type( - detail::get_ptr_to_obj(std::data(raw_queue_), {}), + detail::get_ptr_to_obj(std::data(storage_), {}), static_cast(last) ); } @@ -182,7 +180,7 @@ class spsc_bound_queue final { static_assert(std::atomic::is_always_lock_free); - alignas(Type) storage_type raw_queue_; + alignas(Type) storage_type storage_; static_assert(std::same_as); @@ -217,7 +215,7 @@ class spsc_bound_queue final { { auto const size{static_cast(write_cursor_copy)}; auto* reversed_first{detail::get_ptr_to_obj( - std::data(raw_queue_), static_cast(write_cursor_copy) + std::data(storage_), static_cast(write_cursor_copy) )}; for (auto i{size}; i != size_type{}; --i) { @@ -230,4 +228,4 @@ class spsc_bound_queue final { } // namespace forfun::concurrency::wait_free -#endif // FORFUN_CONCURRENCY_SPSC_APPEND_QUEUE_HPP_ +#endif // FORFUN_CONCURRENCY_SWMR_APPEND_BUFFER_HPP_ diff --git a/src/forfun/concurrency/spsc_bound_queue.cpp b/src/forfun/concurrency/swmr_append_buffer.cpp similarity index 70% rename from src/forfun/concurrency/spsc_bound_queue.cpp rename to src/forfun/concurrency/swmr_append_buffer.cpp index 8a56741c..e5e65abf 100644 --- a/src/forfun/concurrency/spsc_bound_queue.cpp +++ b/src/forfun/concurrency/swmr_append_buffer.cpp @@ -4,4 +4,4 @@ // SPDX-License-Identifier: MIT -#include "forfun/concurrency/spsc_bound_queue.hpp" // IWYU pragma: keep +#include "forfun/concurrency/swmr_append_buffer.hpp" // IWYU pragma: keep diff --git a/test/concurrency/spsc_bound_queue_test.cpp b/test/concurrency/spsc_bound_queue_test.cpp deleted file mode 100644 index 6c71f297..00000000 --- a/test/concurrency/spsc_bound_queue_test.cpp +++ /dev/null @@ -1,939 +0,0 @@ -// Copyright (c) Omar Boukli-Hacene. All rights reserved. -// Distributed under an MIT-style license that can be -// found in the LICENSE file. - -// SPDX-License-Identifier: MIT - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include - -#include - -namespace { - -struct dummy_aggregate final { - // NOLINTBEGIN(misc-non-private-member-variables-in-classes) - int a; - - int b; - - int c; - - int d; - // NOLINTEND(misc-non-private-member-variables-in-classes) - - auto operator==(dummy_aggregate const&) const -> bool = default; -}; - -struct dummy_with_tracked_destructor final { -private: - static inline std::atomic alive_instances_{}; - - static inline std::atomic destructor_calls_{}; - - int dummy_value_; - -public: - static auto reset_destructor_call_counter() noexcept -> void - { - std::atomic_store_explicit( - &destructor_calls_, 0UZ, std::memory_order_relaxed - ); - } - - [[nodiscard]] static auto alive_instances() noexcept -> std::size_t - { - return std::atomic_load_explicit( - &alive_instances_, std::memory_order_relaxed - ); - } - - [[nodiscard]] static auto destructor_calls() noexcept -> std::size_t - { - return std::atomic_load_explicit( - &destructor_calls_, std::memory_order_relaxed - ); - } - - explicit dummy_with_tracked_destructor(int dummy_value) noexcept : - dummy_value_{dummy_value} - { - std::atomic_fetch_add_explicit( - &alive_instances_, 1UZ, std::memory_order_relaxed - ); - } - - dummy_with_tracked_destructor(dummy_with_tracked_destructor const&) noexcept - = default; - - dummy_with_tracked_destructor(dummy_with_tracked_destructor&&) noexcept - = default; - - ~dummy_with_tracked_destructor() - { - std::atomic_fetch_sub_explicit( - &alive_instances_, 1UZ, std::memory_order_relaxed - ); - - std::atomic_fetch_add_explicit( - &destructor_calls_, 1UZ, std::memory_order_relaxed - ); - } - - auto operator=(dummy_with_tracked_destructor const&) noexcept - -> dummy_with_tracked_destructor& = default; - - auto operator=(dummy_with_tracked_destructor&&) noexcept - -> dummy_with_tracked_destructor& = default; - - [[nodiscard]] auto get_value() const noexcept -> int - { - return dummy_value_; - } -}; - -static_assert( - std::is_nothrow_constructible_v -); - -class destructor_call_counter_guard final { -public: - destructor_call_counter_guard() noexcept - { - dummy_with_tracked_destructor::reset_destructor_call_counter(); - } - - destructor_call_counter_guard(destructor_call_counter_guard const&) - = delete; - - destructor_call_counter_guard(destructor_call_counter_guard&&) = delete; - - ~destructor_call_counter_guard() - { - dummy_with_tracked_destructor::reset_destructor_call_counter(); - } - - auto operator=(destructor_call_counter_guard const&) - -> destructor_call_counter_guard& = delete; - - auto operator=(destructor_call_counter_guard&&) - -> destructor_call_counter_guard& = delete; -}; - -} // namespace - -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wdisabled-macro-expansion" -#endif // __clang__ - -TEMPLATE_TEST_CASE_SIG( - "Wait-free SPSC append-only bounded queue", - "[spsc_bound_queue]", - ((typename Type, std::size_t Size), Type, Size), - (int, 4UZ), - (int, 8UZ), - (int, 16UZ) -) -{ - using buffer_type = forfun::concurrency::wait_free::spsc_bound_queue< - Type, - Size, - std::hardware_destructive_interference_size>; - - SECTION("Initial span is empty") - { - buffer_type queue{}; - - REQUIRE(queue.to_span().empty()); - } - - SECTION("Initially empty") - { - buffer_type const queue{}; - - REQUIRE(queue.empty()); - } - - SECTION("Capacity is as requested") - { - buffer_type const queue{}; - - REQUIRE(queue.capacity() == Size); - } - - SECTION("Emplace affects empty state") - { - buffer_type queue{}; - - queue.emplace_back(677); - - REQUIRE_FALSE(queue.empty()); - - queue.emplace_back(683); - - REQUIRE_FALSE(queue.empty()); - } - - SECTION("Emplace affects span size") - { - buffer_type queue{}; - - queue.emplace_back(691); - - REQUIRE(queue.to_span().size() == 1UZ); - - queue.emplace_back(701); - - REQUIRE(queue.to_span().size() == 2UZ); - - queue.emplace_back(709); - - REQUIRE(queue.to_span().size() == 3UZ); - - queue.emplace_back(719); - - REQUIRE(queue.to_span().size() == 4UZ); - } - - SECTION("Emplace affects span back") - { - buffer_type queue{}; - - queue.emplace_back(-2); - - REQUIRE(queue.to_span().front() == -2); - - REQUIRE(queue.to_span().back() == -2); - - queue.emplace_back(0); - - REQUIRE(queue.to_span().back() == 0); - - queue.emplace_back(-3); - - REQUIRE(queue.to_span().back() == -3); - - queue.emplace_back(12); - - REQUIRE(queue.to_span().back() == 12); - - REQUIRE(queue.to_span().front() == -2); - } - - SECTION("Emplace returns reference to emplaced element") - { - buffer_type queue{}; - - decltype(auto) ref_to_emplaced{queue.emplace_back(225149)}; - - static_assert(std::is_reference_v); - - REQUIRE(ref_to_emplaced == 225149); - - REQUIRE(queue.to_span().front() == 225149); - - ref_to_emplaced = 75773; - - REQUIRE(queue.to_span().front() == 75773); - } - - SECTION("Emplace till full then read all") - { - buffer_type buffer{}; - - for (Type const n : std::views::iota(Type{1}) | std::views::take(Size)) - { - auto const& ref{buffer.emplace_back(n)}; - - REQUIRE(ref == n); - } - - REQUIRE_FALSE(buffer.empty()); - - REQUIRE(buffer.to_span().size() == Size); - - REQUIRE( - std::ranges::equal( - buffer.to_span(), - std::views::iota(Type{1}) - | std::views::take(buffer.to_span().size()) - ) - ); - } - - SECTION("To span") - { - buffer_type queue{}; - - queue.emplace_back(727); - queue.emplace_back(733); - - auto const consumable_span{queue.to_span()}; - - REQUIRE(consumable_span.size() == 2UZ); - - REQUIRE(consumable_span.front() == 727); - - REQUIRE(consumable_span.back() == 733); - } - - SECTION("Reset call on empty queue") - { - buffer_type queue{}; - - queue.reset_unsafe(); - - REQUIRE(queue.empty()); - } - - SECTION("Reset call on non-empty non-full queue") - { - buffer_type queue{}; - queue.emplace_back(1); - queue.emplace_back(2); - queue.emplace_back(3); - - queue.reset_unsafe(); - - REQUIRE(queue.empty()); - } - - SECTION("Destructor call on empty queue") - { - { - buffer_type const queue{}; - } - - SUCCEED(); - } - - SECTION("Destructor call on non-empty queue") - { - { - buffer_type queue{}; - queue.emplace_back(1); - } - - SUCCEED(); - } - - SECTION("Destructor call on non-empty non-full queue") - { - { - buffer_type queue{}; - queue.emplace_back(1); - queue.emplace_back(2); - queue.emplace_back(3); - } - - SUCCEED(); - } -} - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif // __clang__ - -TEST_CASE( - "Wait-free SPSC append-only bounded queue (miscellaneous)", - "[spsc_bound_queue]" -) -{ - SECTION("Initial span is empty") - { - forfun::concurrency::wait_free::spsc_bound_queue< - int, - 1, - std::hardware_destructive_interference_size> - queue{}; - - REQUIRE(queue.to_span().empty()); - } - - SECTION("Initially empty") - { - forfun::concurrency::wait_free::spsc_bound_queue< - int, - 1, - std::hardware_destructive_interference_size> const queue{}; - - REQUIRE(queue.empty()); - } - - SECTION("Capacity is as requested") - { - forfun::concurrency::wait_free::spsc_bound_queue< - int, - 1, - std::hardware_destructive_interference_size> const queue{}; - - REQUIRE(queue.capacity() == 1UZ); - } - - SECTION("Single-slot queue resets cleanly and refills") - { - forfun::concurrency::wait_free::spsc_bound_queue< - int, - 1, - std::hardware_destructive_interference_size> - queue{}; - - queue.emplace_back(11); - - REQUIRE(queue.to_span().size() == 1UZ); - - REQUIRE(queue.to_span().front() == 11); - - queue.reset_unsafe(); - - REQUIRE(queue.empty()); - - REQUIRE(queue.to_span().empty()); - - queue.emplace_back(17); - - REQUIRE(queue.to_span().size() == 1UZ); - - REQUIRE(queue.to_span().front() == 17); - - REQUIRE(queue.to_span().back() == 17); - } - - SECTION("Reset call on full queue") - { - forfun::concurrency::wait_free::spsc_bound_queue< - int, - 8, - std::hardware_destructive_interference_size> - queue{}; - queue.emplace_back(1); - queue.emplace_back(2); - queue.emplace_back(3); - queue.emplace_back(4); - queue.emplace_back(5); - queue.emplace_back(6); - queue.emplace_back(7); - queue.emplace_back(8); - - queue.reset_unsafe(); - - REQUIRE(queue.empty()); - } - - SECTION("Fill, reset, refill, and read queue") - { - using ValueType = int; - - constexpr std::size_t const queue_capacity{8}; - - forfun::concurrency::wait_free::spsc_bound_queue< - int, - 8, - std::hardware_destructive_interference_size> - queue{}; - queue.emplace_back(10); - queue.emplace_back(20); - queue.emplace_back(30); - queue.emplace_back(40); - queue.emplace_back(50); - queue.emplace_back(60); - queue.emplace_back(70); - queue.emplace_back(80); - - queue.reset_unsafe(); - - REQUIRE(queue.empty()); - - queue.emplace_back(1); - queue.emplace_back(2); - queue.emplace_back(3); - queue.emplace_back(4); - queue.emplace_back(5); - queue.emplace_back(6); - queue.emplace_back(7); - queue.emplace_back(8); - - REQUIRE_FALSE(queue.empty()); - - REQUIRE(queue.to_span().size() == queue_capacity); - - REQUIRE( - std::ranges::equal( - queue.to_span(), - std::views::iota(ValueType{1}) - | std::views::take(queue.to_span().size()) - ) - ); - } - - SECTION("Destructor call on full queue") - { - { - forfun::concurrency::wait_free::spsc_bound_queue< - int, - 8, - std::hardware_destructive_interference_size> - queue{}; - queue.emplace_back(1); - queue.emplace_back(2); - queue.emplace_back(3); - queue.emplace_back(4); - queue.emplace_back(5); - queue.emplace_back(6); - queue.emplace_back(7); - queue.emplace_back(8); - } - - SUCCEED(); - } - - SECTION("Reset destroys queued non-trivial objects") - { - destructor_call_counter_guard const guard; - { - forfun::concurrency::wait_free::spsc_bound_queue< - dummy_with_tracked_destructor, - 4, - std::hardware_destructive_interference_size> - queue{}; - - queue.emplace_back(584141); - queue.emplace_back(604171); - queue.emplace_back(971767); - - REQUIRE_FALSE(queue.empty()); - - REQUIRE(dummy_with_tracked_destructor::alive_instances() == 3UZ); - - REQUIRE(queue.to_span().size() == 3UZ); - - REQUIRE(queue.to_span().front().get_value() == 584141); - - REQUIRE(dummy_with_tracked_destructor::destructor_calls() == 0UZ); - - queue.reset_unsafe(); - - REQUIRE(queue.empty()); - - REQUIRE(dummy_with_tracked_destructor::alive_instances() == 0UZ); - } - - REQUIRE(dummy_with_tracked_destructor::destructor_calls() == 3UZ); - - REQUIRE(dummy_with_tracked_destructor::alive_instances() == 0UZ); - } - - SECTION("Destructor destroys buffered non-trivial objects") - { - destructor_call_counter_guard const guard; - { - forfun::concurrency::wait_free::spsc_bound_queue< - dummy_with_tracked_destructor, - 4, - std::hardware_destructive_interference_size> - queue{}; - - queue.emplace_back(1062599); - queue.emplace_back(1282529); - - REQUIRE_FALSE(queue.empty()); - - REQUIRE(dummy_with_tracked_destructor::alive_instances() == 2UZ); - - REQUIRE(queue.to_span().size() == 2UZ); - - REQUIRE(queue.to_span().front().get_value() == 1062599); - - REQUIRE(dummy_with_tracked_destructor::destructor_calls() == 0UZ); - - REQUIRE(dummy_with_tracked_destructor::alive_instances() == 2UZ); - } - - REQUIRE(dummy_with_tracked_destructor::destructor_calls() == 2UZ); - - REQUIRE(dummy_with_tracked_destructor::alive_instances() == 0UZ); - } - - SECTION( - "Nondeterministic one producer and one consumer of int values " - "(immediate write)" - ) - { - constexpr std::size_t const queue_size{8}; - - static constexpr auto const expected - = {208739, 208759, 208787, 208799, 208807, 208837, 208843, 208877}; - - using SizeType = forfun::concurrency::wait_free::spsc_bound_queue< - int, - queue_size, - std::hardware_destructive_interference_size>::size_type; - using ValueType = forfun::concurrency::wait_free::spsc_bound_queue< - int, - queue_size, - std::hardware_destructive_interference_size>::value_type; - - forfun::concurrency::wait_free::spsc_bound_queue< - int, - queue_size, - std::hardware_destructive_interference_size> - queue{}; - - std::vector consumer_bag{}; - consumer_bag.reserve(queue_size); - - SizeType produced_count{}; - SizeType consumed_count{}; - - { - std::jthread const - consumer([&queue, &consumer_bag, &consumed_count] -> void { - while (consumed_count < queue_size) - { - for (auto&& val : queue.to_span().subspan(consumed_count)) - { - consumer_bag.emplace_back(val); - REQUIRE(std::ranges::contains(expected, val)); - ++consumed_count; - } - } - - REQUIRE(consumer_bag.size() == queue_size); - }); - - std::jthread const producer( - [&queue, &produced_count] noexcept -> void { - for (auto&& val : expected) - { - queue.emplace_back(val); - ++produced_count; - } - } - ); - } - - REQUIRE(produced_count == queue_size); - - REQUIRE(consumed_count == queue_size); - - REQUIRE(produced_count == consumed_count); - - REQUIRE(consumer_bag.size() == consumed_count); - - REQUIRE(queue.to_span().size() == queue_size); - - REQUIRE_THAT(consumer_bag, Catch::Matchers::RangeEquals(expected)); - } - - SECTION( - "Nondeterministic one producer and one consumer of aggregate values " - "(immediate write)" - ) - { - static constexpr std::size_t const queue_size{8}; - - using ValueType = dummy_aggregate; - - using SizeType = forfun::concurrency::wait_free::spsc_bound_queue< - ValueType, - queue_size, - std::hardware_destructive_interference_size>::size_type; - - forfun::concurrency::wait_free::spsc_bound_queue< - ValueType, - queue_size, - std::hardware_destructive_interference_size> - queue{}; - - std::vector consumer_bag{}; - consumer_bag.reserve(queue_size); - - SizeType produced_count{}; - SizeType consumed_count{}; - - { - std::jthread const - consumer([&queue, &consumer_bag, &consumed_count] -> void { - while (consumed_count < queue_size) - { - for (auto&& val : queue.to_span().subspan(consumed_count)) - { - consumer_bag.emplace_back(val); - ++consumed_count; - } - } - - REQUIRE(consumer_bag.size() == queue_size); - }); - - std::jthread const producer( - [&queue, &produced_count] noexcept -> void { - for ( - auto&& n : - std::views::iota(1) | std::views::take(queue_size) - ) - { - queue.emplace_back(n * 11, n * 2, n * 5, n * 10); - ++produced_count; - } - } - ); - } - - REQUIRE(produced_count == queue_size); - - REQUIRE(consumed_count == queue_size); - - REQUIRE(produced_count == consumed_count); - - REQUIRE(consumer_bag.size() == consumed_count); - - REQUIRE(queue.to_span().size() == queue_size); - - int generator_state{1}; - std::array expected{}; - for (auto& val : expected) - { - auto const n{generator_state++}; - val = {.a = n * 11, .b = n * 2, .c = n * 5, .d = n * 10}; - } - - REQUIRE_THAT(consumer_bag, Catch::Matchers::RangeEquals(expected)); - } - - SECTION( - "Nondeterministic one producer and one consumer of int values (delayed " - "producer)" - ) - { - using std::chrono::operator""ms; - - constexpr std::size_t const queue_size{8}; - - static constexpr auto const expected - = {208739, 208759, 208787, 208799, 208807, 208837, 208843, 208877}; - - using SizeType = forfun::concurrency::wait_free::spsc_bound_queue< - int, - queue_size, - std::hardware_destructive_interference_size>::size_type; - using ValueType = forfun::concurrency::wait_free::spsc_bound_queue< - int, - queue_size, - std::hardware_destructive_interference_size>::value_type; - - forfun::concurrency::wait_free::spsc_bound_queue< - int, - queue_size, - std::hardware_destructive_interference_size> - queue{}; - - std::vector consumer_bag{}; - consumer_bag.reserve(queue_size); - - SizeType produced_count{}; - SizeType consumed_count{}; - - { - std::jthread const - consumer([&queue, &consumer_bag, &consumed_count] -> void { - while (consumed_count < queue_size) - { - for (auto&& val : queue.to_span().subspan(consumed_count)) - { - consumer_bag.emplace_back(val); - REQUIRE(std::ranges::contains(expected, val)); - ++consumed_count; - } - } - - REQUIRE(consumer_bag.size() == queue_size); - }); - - std::jthread const producer( - [&queue, &produced_count] noexcept -> void { - std::this_thread::sleep_for(10ms); - - for (auto&& val : expected) - { - std::this_thread::sleep_for(3ms); - - queue.emplace_back(val); - ++produced_count; - } - } - ); - } - - REQUIRE(produced_count == queue_size); - - REQUIRE(consumed_count == queue_size); - - REQUIRE(produced_count == consumed_count); - - REQUIRE(consumer_bag.size() == consumed_count); - - REQUIRE(queue.to_span().size() == queue_size); - - REQUIRE_THAT(consumer_bag, Catch::Matchers::RangeEquals(expected)); - } - - SECTION( - "Nondeterministic one producer and one consumer of aggregate values " - "(delayed producer)" - ) - { - using std::chrono::operator""ms; - - static constexpr std::size_t const queue_size{8}; - - using ValueType = dummy_aggregate; - - using SizeType = forfun::concurrency::wait_free::spsc_bound_queue< - ValueType, - queue_size, - std::hardware_destructive_interference_size>::size_type; - - forfun::concurrency::wait_free::spsc_bound_queue< - ValueType, - queue_size, - std::hardware_destructive_interference_size> - queue{}; - - std::vector consumer_bag{}; - consumer_bag.reserve(queue_size); - - SizeType produced_count{}; - SizeType consumed_count{}; - - { - std::jthread const - consumer([&queue, &consumer_bag, &consumed_count] -> void { - while (consumed_count < queue_size) - { - for (auto&& val : queue.to_span().subspan(consumed_count)) - { - consumer_bag.emplace_back(val); - ++consumed_count; - } - } - - REQUIRE(consumer_bag.size() == queue_size); - }); - - std::jthread const producer( - [&queue, &produced_count] noexcept -> void { - std::this_thread::sleep_for(10ms); - - for ( - auto&& n : - std::views::iota(1) | std::views::take(queue_size) - ) - { - std::this_thread::sleep_for(10ms); - - queue.emplace_back(n * 111, n * 4, n * 8, n * 20); - ++produced_count; - } - } - ); - } - - REQUIRE(produced_count == queue_size); - - REQUIRE(consumed_count == queue_size); - - REQUIRE(produced_count == consumed_count); - - REQUIRE(consumer_bag.size() == consumed_count); - - REQUIRE(queue.to_span().size() == queue_size); - - int generator_state{1}; - std::array expected{}; - for (auto& val : expected) - { - auto const n{generator_state++}; - val = {.a = n * 111, .b = n * 4, .c = n * 8, .d = n * 20}; - } - - REQUIRE_THAT(consumer_bag, Catch::Matchers::RangeEquals(expected)); - } - - SECTION("Benchmark case") - { - constexpr std::size_t const capacity{16}; - - // NOLINTNEXTLINE(cppcoreguidelines-init-variables) - int volatile val /*[[indeterminate]]*/; - forfun::concurrency::wait_free::spsc_bound_queue< - int, - capacity, - std::hardware_destructive_interference_size> - queue{}; - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - queue.emplace_back(502807); - val = queue.to_span().back(); - - REQUIRE(val == 502807); - } -} diff --git a/test/concurrency/spsc_bound_queue_statictest.cpp b/test/concurrency/swmr_append_buffer_statictest.cpp similarity index 61% rename from test/concurrency/spsc_bound_queue_statictest.cpp rename to test/concurrency/swmr_append_buffer_statictest.cpp index 0d778af2..fd729433 100644 --- a/test/concurrency/spsc_bound_queue_statictest.cpp +++ b/test/concurrency/swmr_append_buffer_statictest.cpp @@ -13,15 +13,15 @@ #include -#include +#include -TEST_CASE("Wait-free SPSC append-only bounded queue", "[spsc_bound_queue]") +TEST_CASE("Wait-free SWMR append buffer", "[swmr_append_buffer]") { SECTION("Object representations is not unique") { STATIC_REQUIRE_FALSE( std::has_unique_object_representations_v< - forfun::concurrency::wait_free::spsc_bound_queue< + forfun::concurrency::wait_free::swmr_append_buffer< char, 8, std::hardware_destructive_interference_size>> @@ -29,7 +29,7 @@ TEST_CASE("Wait-free SPSC append-only bounded queue", "[spsc_bound_queue]") STATIC_REQUIRE_FALSE( std::has_unique_object_representations_v< - forfun::concurrency::wait_free::spsc_bound_queue< + forfun::concurrency::wait_free::swmr_append_buffer< int, 8, std::hardware_destructive_interference_size>> @@ -39,14 +39,14 @@ TEST_CASE("Wait-free SPSC append-only bounded queue", "[spsc_bound_queue]") SECTION("Construction and initialization") { STATIC_REQUIRE_FALSE( - std::copyable> ); STATIC_REQUIRE_FALSE( - std::movable> @@ -57,7 +57,7 @@ TEST_CASE("Wait-free SPSC append-only bounded queue", "[spsc_bound_queue]") { STATIC_REQUIRE_FALSE( std::equality_comparable< - forfun::concurrency::wait_free::spsc_bound_queue< + forfun::concurrency::wait_free::swmr_append_buffer< int, 8, std::hardware_destructive_interference_size>> @@ -66,41 +66,41 @@ TEST_CASE("Wait-free SPSC append-only bounded queue", "[spsc_bound_queue]") SECTION("Capacity is as requested") { - using queue_type = forfun::concurrency::wait_free::spsc_bound_queue< + using buffer_type = forfun::concurrency::wait_free::swmr_append_buffer< int, 8, std::hardware_destructive_interference_size>; - STATIC_REQUIRE(queue_type::capacity() == 8UZ); + STATIC_REQUIRE(buffer_type::capacity() == 8UZ); } SECTION("Type aliases") { - using queue_type = forfun::concurrency::wait_free::spsc_bound_queue< + using buffer_type = forfun::concurrency::wait_free::swmr_append_buffer< int, 8, std::hardware_destructive_interference_size>; - STATIC_REQUIRE(std::same_as); + STATIC_REQUIRE(std::same_as); - STATIC_REQUIRE(std::same_as); + STATIC_REQUIRE(std::same_as); - STATIC_REQUIRE(std::same_as); + STATIC_REQUIRE(std::same_as); } SECTION("To span") { - using queue_type = forfun::concurrency::wait_free::spsc_bound_queue< + using buffer_type = forfun::concurrency::wait_free::swmr_append_buffer< int, 8, std::hardware_destructive_interference_size>; - STATIC_REQUIRE(std::same_as>); + STATIC_REQUIRE(std::same_as>); STATIC_REQUIRE( std::same_as< - queue_type::span_type, - decltype(std::declval().to_span())> + buffer_type::span_type, + decltype(std::declval().to_span())> ); } } diff --git a/test/concurrency/swmr_append_buffer_test.cpp b/test/concurrency/swmr_append_buffer_test.cpp new file mode 100644 index 00000000..0753ecfd --- /dev/null +++ b/test/concurrency/swmr_append_buffer_test.cpp @@ -0,0 +1,920 @@ +// Copyright (c) Omar Boukli-Hacene. All rights reserved. +// Distributed under an MIT-style license that can be +// found in the LICENSE file. + +// SPDX-License-Identifier: MIT + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +namespace { + +struct dummy_aggregate final { + // NOLINTBEGIN(misc-non-private-member-variables-in-classes) + int a; + + int b; + + int c; + + int d; + // NOLINTEND(misc-non-private-member-variables-in-classes) + + auto operator==(dummy_aggregate const&) const -> bool = default; +}; + +struct dummy_with_tracked_destructor final { +private: + static inline std::atomic alive_instances_{}; + + static inline std::atomic destructor_calls_{}; + + int dummy_value_; + +public: + static auto reset_destructor_call_counter() noexcept -> void + { + std::atomic_store_explicit( + &destructor_calls_, 0UZ, std::memory_order_relaxed + ); + } + + [[nodiscard]] static auto alive_instances() noexcept -> std::size_t + { + return std::atomic_load_explicit( + &alive_instances_, std::memory_order_relaxed + ); + } + + [[nodiscard]] static auto destructor_calls() noexcept -> std::size_t + { + return std::atomic_load_explicit( + &destructor_calls_, std::memory_order_relaxed + ); + } + + explicit dummy_with_tracked_destructor(int dummy_value) noexcept : + dummy_value_{dummy_value} + { + std::atomic_fetch_add_explicit( + &alive_instances_, 1UZ, std::memory_order_relaxed + ); + } + + dummy_with_tracked_destructor(dummy_with_tracked_destructor const&) noexcept + = default; + + dummy_with_tracked_destructor(dummy_with_tracked_destructor&&) noexcept + = default; + + ~dummy_with_tracked_destructor() + { + std::atomic_fetch_sub_explicit( + &alive_instances_, 1UZ, std::memory_order_relaxed + ); + + std::atomic_fetch_add_explicit( + &destructor_calls_, 1UZ, std::memory_order_relaxed + ); + } + + auto operator=(dummy_with_tracked_destructor const&) noexcept + -> dummy_with_tracked_destructor& = default; + + auto operator=(dummy_with_tracked_destructor&&) noexcept + -> dummy_with_tracked_destructor& = default; + + [[nodiscard]] auto get_value() const noexcept -> int + { + return dummy_value_; + } +}; + +static_assert( + std::is_nothrow_constructible_v +); + +class destructor_call_counter_guard final { +public: + destructor_call_counter_guard() noexcept + { + dummy_with_tracked_destructor::reset_destructor_call_counter(); + } + + destructor_call_counter_guard(destructor_call_counter_guard const&) + = delete; + + destructor_call_counter_guard(destructor_call_counter_guard&&) = delete; + + ~destructor_call_counter_guard() + { + dummy_with_tracked_destructor::reset_destructor_call_counter(); + } + + auto operator=(destructor_call_counter_guard const&) + -> destructor_call_counter_guard& = delete; + + auto operator=(destructor_call_counter_guard&&) + -> destructor_call_counter_guard& = delete; +}; + +} // namespace + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdisabled-macro-expansion" +#endif // __clang__ + +TEMPLATE_TEST_CASE_SIG( + "Wait-free SWMR append buffer", + "[swmr_append_buffer]", + ((typename Type, std::size_t Size), Type, Size), + (int, 4UZ), + (int, 8UZ), + (int, 16UZ) +) +{ + using buffer_type = forfun::concurrency::wait_free::swmr_append_buffer< + Type, + Size, + std::hardware_destructive_interference_size>; + + SECTION("Initial span is empty") + { + buffer_type buffer{}; + + REQUIRE(buffer.to_span().empty()); + } + + SECTION("Initially empty") + { + buffer_type const buffer{}; + + REQUIRE(buffer.empty()); + } + + SECTION("Capacity is as requested") + { + buffer_type const buffer{}; + + REQUIRE(buffer.capacity() == Size); + } + + SECTION("Emplace affects empty state") + { + buffer_type buffer{}; + + buffer.emplace_back(677); + + REQUIRE_FALSE(buffer.empty()); + + buffer.emplace_back(683); + + REQUIRE_FALSE(buffer.empty()); + } + + SECTION("Emplace affects span size") + { + buffer_type buffer{}; + + buffer.emplace_back(691); + + REQUIRE(buffer.to_span().size() == 1UZ); + + buffer.emplace_back(701); + + REQUIRE(buffer.to_span().size() == 2UZ); + + buffer.emplace_back(709); + + REQUIRE(buffer.to_span().size() == 3UZ); + + buffer.emplace_back(719); + + REQUIRE(buffer.to_span().size() == 4UZ); + } + + SECTION("Emplace affects span back") + { + buffer_type buffer{}; + + buffer.emplace_back(-2); + + REQUIRE(buffer.to_span().front() == -2); + + REQUIRE(buffer.to_span().back() == -2); + + buffer.emplace_back(0); + + REQUIRE(buffer.to_span().back() == 0); + + buffer.emplace_back(-3); + + REQUIRE(buffer.to_span().back() == -3); + + buffer.emplace_back(12); + + REQUIRE(buffer.to_span().back() == 12); + + REQUIRE(buffer.to_span().front() == -2); + } + + SECTION("Emplace returns reference to emplaced element") + { + buffer_type buffer{}; + + decltype(auto) ref_to_emplaced{buffer.emplace_back(225149)}; + + static_assert(std::is_reference_v); + + REQUIRE(ref_to_emplaced == 225149); + + REQUIRE(buffer.to_span().front() == 225149); + + ref_to_emplaced = 75773; + + REQUIRE(buffer.to_span().front() == 75773); + } + + SECTION("Emplace till full then read all") + { + buffer_type buffer{}; + + for (Type const n : std::views::iota(Type{1}) | std::views::take(Size)) + { + auto const& ref{buffer.emplace_back(n)}; + + REQUIRE(ref == n); + } + + REQUIRE_FALSE(buffer.empty()); + + REQUIRE(buffer.to_span().size() == Size); + + REQUIRE( + std::ranges::equal( + buffer.to_span(), + std::views::iota(Type{1}) + | std::views::take(buffer.to_span().size()) + ) + ); + } + + SECTION("To span") + { + buffer_type buffer{}; + + buffer.emplace_back(727); + buffer.emplace_back(733); + + auto const non_empty_span{buffer.to_span()}; + + REQUIRE(non_empty_span.size() == 2UZ); + + REQUIRE(non_empty_span.front() == 727); + + REQUIRE(non_empty_span.back() == 733); + } + + SECTION("Reset call on empty buffer") + { + buffer_type buffer{}; + + buffer.reset_unsafe(); + + REQUIRE(buffer.empty()); + } + + SECTION("Reset call on non-empty non-full buffer") + { + buffer_type buffer{}; + buffer.emplace_back(1); + buffer.emplace_back(2); + buffer.emplace_back(3); + + buffer.reset_unsafe(); + + REQUIRE(buffer.empty()); + } + + SECTION("Destructor call on empty buffer") + { + { + buffer_type const buffer{}; + } + + SUCCEED(); + } + + SECTION("Destructor call on non-empty buffer") + { + { + buffer_type buffer{}; + buffer.emplace_back(1); + } + + SUCCEED(); + } + + SECTION("Destructor call on non-empty non-full buffer") + { + { + buffer_type buffer{}; + buffer.emplace_back(1); + buffer.emplace_back(2); + buffer.emplace_back(3); + } + + SUCCEED(); + } +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif // __clang__ + +TEST_CASE( + "Wait-free SWMR append buffer (miscellaneous cases)", "[swmr_append_buffer]" +) +{ + SECTION("Initial span is empty") + { + forfun::concurrency::wait_free::swmr_append_buffer< + int, + 1, + std::hardware_destructive_interference_size> + buffer{}; + + REQUIRE(buffer.to_span().empty()); + } + + SECTION("Initially empty") + { + forfun::concurrency::wait_free::swmr_append_buffer< + int, + 1, + std::hardware_destructive_interference_size> const buffer{}; + + REQUIRE(buffer.empty()); + } + + SECTION("Capacity is as requested") + { + forfun::concurrency::wait_free::swmr_append_buffer< + int, + 1, + std::hardware_destructive_interference_size> const buffer{}; + + REQUIRE(buffer.capacity() == 1UZ); + } + + SECTION("Single-slot buffer resets cleanly and refills") + { + forfun::concurrency::wait_free::swmr_append_buffer< + int, + 1, + std::hardware_destructive_interference_size> + buffer{}; + + buffer.emplace_back(11); + + REQUIRE(buffer.to_span().size() == 1UZ); + + REQUIRE(buffer.to_span().front() == 11); + + buffer.reset_unsafe(); + + REQUIRE(buffer.empty()); + + REQUIRE(buffer.to_span().empty()); + + buffer.emplace_back(17); + + REQUIRE(buffer.to_span().size() == 1UZ); + + REQUIRE(buffer.to_span().front() == 17); + + REQUIRE(buffer.to_span().back() == 17); + } + + SECTION("Reset call on full buffer") + { + forfun::concurrency::wait_free::swmr_append_buffer< + int, + 8, + std::hardware_destructive_interference_size> + buffer{}; + buffer.emplace_back(1); + buffer.emplace_back(2); + buffer.emplace_back(3); + buffer.emplace_back(4); + buffer.emplace_back(5); + buffer.emplace_back(6); + buffer.emplace_back(7); + buffer.emplace_back(8); + + buffer.reset_unsafe(); + + REQUIRE(buffer.empty()); + } + + SECTION("Fill, reset, refill, and read buffer") + { + using ValueType = int; + + constexpr std::size_t const buffer_capacity{8}; + + forfun::concurrency::wait_free::swmr_append_buffer< + int, + 8, + std::hardware_destructive_interference_size> + buffer{}; + buffer.emplace_back(10); + buffer.emplace_back(20); + buffer.emplace_back(30); + buffer.emplace_back(40); + buffer.emplace_back(50); + buffer.emplace_back(60); + buffer.emplace_back(70); + buffer.emplace_back(80); + + buffer.reset_unsafe(); + + REQUIRE(buffer.empty()); + + buffer.emplace_back(1); + buffer.emplace_back(2); + buffer.emplace_back(3); + buffer.emplace_back(4); + buffer.emplace_back(5); + buffer.emplace_back(6); + buffer.emplace_back(7); + buffer.emplace_back(8); + + REQUIRE_FALSE(buffer.empty()); + + REQUIRE(buffer.to_span().size() == buffer_capacity); + + REQUIRE( + std::ranges::equal( + buffer.to_span(), + std::views::iota(ValueType{1}) + | std::views::take(buffer.to_span().size()) + ) + ); + } + + SECTION("Destructor call on full buffer") + { + { + forfun::concurrency::wait_free::swmr_append_buffer< + int, + 8, + std::hardware_destructive_interference_size> + buffer{}; + buffer.emplace_back(1); + buffer.emplace_back(2); + buffer.emplace_back(3); + buffer.emplace_back(4); + buffer.emplace_back(5); + buffer.emplace_back(6); + buffer.emplace_back(7); + buffer.emplace_back(8); + } + + SUCCEED(); + } + + SECTION("Reset destroys bufferd non-trivial objects") + { + destructor_call_counter_guard const guard; + { + forfun::concurrency::wait_free::swmr_append_buffer< + dummy_with_tracked_destructor, + 4, + std::hardware_destructive_interference_size> + buffer{}; + + buffer.emplace_back(584141); + buffer.emplace_back(604171); + buffer.emplace_back(971767); + + REQUIRE_FALSE(buffer.empty()); + + REQUIRE(dummy_with_tracked_destructor::alive_instances() == 3UZ); + + REQUIRE(buffer.to_span().size() == 3UZ); + + REQUIRE(buffer.to_span().front().get_value() == 584141); + + REQUIRE(dummy_with_tracked_destructor::destructor_calls() == 0UZ); + + buffer.reset_unsafe(); + + REQUIRE(buffer.empty()); + + REQUIRE(dummy_with_tracked_destructor::alive_instances() == 0UZ); + } + + REQUIRE(dummy_with_tracked_destructor::destructor_calls() == 3UZ); + + REQUIRE(dummy_with_tracked_destructor::alive_instances() == 0UZ); + } + + SECTION("Destructor destroys buffered non-trivial objects") + { + destructor_call_counter_guard const guard; + { + forfun::concurrency::wait_free::swmr_append_buffer< + dummy_with_tracked_destructor, + 4, + std::hardware_destructive_interference_size> + buffer{}; + + buffer.emplace_back(1062599); + buffer.emplace_back(1282529); + + REQUIRE_FALSE(buffer.empty()); + + REQUIRE(dummy_with_tracked_destructor::alive_instances() == 2UZ); + + REQUIRE(buffer.to_span().size() == 2UZ); + + REQUIRE(buffer.to_span().front().get_value() == 1062599); + + REQUIRE(dummy_with_tracked_destructor::destructor_calls() == 0UZ); + + REQUIRE(dummy_with_tracked_destructor::alive_instances() == 2UZ); + } + + REQUIRE(dummy_with_tracked_destructor::destructor_calls() == 2UZ); + + REQUIRE(dummy_with_tracked_destructor::alive_instances() == 0UZ); + } + + SECTION("One writer and one reader of int values (immediate write)") + { + constexpr std::size_t const buffer_size{8}; + + static constexpr auto const expected + = {208739, 208759, 208787, 208799, 208807, 208837, 208843, 208877}; + + using SizeType = forfun::concurrency::wait_free::swmr_append_buffer< + int, + buffer_size, + std::hardware_destructive_interference_size>::size_type; + using ValueType = forfun::concurrency::wait_free::swmr_append_buffer< + int, + buffer_size, + std::hardware_destructive_interference_size>::value_type; + + forfun::concurrency::wait_free::swmr_append_buffer< + int, + buffer_size, + std::hardware_destructive_interference_size> + buffer{}; + + std::vector reader_bag{}; + reader_bag.reserve(buffer_size); + + SizeType written_count{}; + SizeType read_count{}; + + { + std::jthread const reader( + [&buffer, &reader_bag, &read_count] -> void { + while (read_count < buffer_size) + { + for (auto&& val : buffer.to_span().subspan(read_count)) + { + reader_bag.emplace_back(val); + ++read_count; + } + } + } + ); + + std::jthread const writer( + [&buffer, &written_count] noexcept -> void { + for (auto&& val : expected) + { + buffer.emplace_back(val); + ++written_count; + } + } + ); + } + + REQUIRE(written_count == buffer_size); + + REQUIRE(read_count == buffer_size); + + REQUIRE(written_count == read_count); + + REQUIRE(reader_bag.size() == read_count); + + REQUIRE(buffer.to_span().size() == buffer_size); + + REQUIRE_THAT(reader_bag, Catch::Matchers::RangeEquals(expected)); + } + + SECTION("One writer and one reader of aggregate values (immediate write)") + { + static constexpr std::size_t const buffer_size{8}; + + using ValueType = dummy_aggregate; + + using SizeType = forfun::concurrency::wait_free::swmr_append_buffer< + ValueType, + buffer_size, + std::hardware_destructive_interference_size>::size_type; + + forfun::concurrency::wait_free::swmr_append_buffer< + ValueType, + buffer_size, + std::hardware_destructive_interference_size> + buffer{}; + + std::vector reader_bag{}; + reader_bag.reserve(buffer_size); + + SizeType written_count{}; + SizeType read_count{}; + + { + std::jthread const reader( + [&buffer, &reader_bag, &read_count] -> void { + while (read_count < buffer_size) + { + for (auto&& val : buffer.to_span().subspan(read_count)) + { + reader_bag.emplace_back(val); + ++read_count; + } + } + } + ); + + std::jthread const writer( + [&buffer, &written_count] noexcept -> void { + for ( + auto&& n : + std::views::iota(1) | std::views::take(buffer_size) + ) + { + buffer.emplace_back(n * 11, n * 2, n * 5, n * 10); + ++written_count; + } + } + ); + } + + REQUIRE(written_count == buffer_size); + + REQUIRE(read_count == buffer_size); + + REQUIRE(written_count == read_count); + + REQUIRE(reader_bag.size() == read_count); + + REQUIRE(buffer.to_span().size() == buffer_size); + + int generator_state{1}; + std::array expected{}; + for (auto& val : expected) + { + auto const n{generator_state++}; + val = {.a = n * 11, .b = n * 2, .c = n * 5, .d = n * 10}; + } + + REQUIRE_THAT(reader_bag, Catch::Matchers::RangeEquals(expected)); + } + + SECTION("One writer and one reader of int values (delayed writer)") + { + using std::chrono::operator""ms; + + constexpr std::size_t const buffer_size{8}; + + static constexpr auto const expected + = {208739, 208759, 208787, 208799, 208807, 208837, 208843, 208877}; + + using SizeType = forfun::concurrency::wait_free::swmr_append_buffer< + int, + buffer_size, + std::hardware_destructive_interference_size>::size_type; + using ValueType = forfun::concurrency::wait_free::swmr_append_buffer< + int, + buffer_size, + std::hardware_destructive_interference_size>::value_type; + + forfun::concurrency::wait_free::swmr_append_buffer< + int, + buffer_size, + std::hardware_destructive_interference_size> + buffer{}; + + std::vector reader_bag{}; + reader_bag.reserve(buffer_size); + + SizeType written_count{}; + SizeType read_count{}; + + { + std::jthread const reader( + [&buffer, &reader_bag, &read_count] -> void { + while (read_count < buffer_size) + { + for (auto&& val : buffer.to_span().subspan(read_count)) + { + reader_bag.emplace_back(val); + ++read_count; + } + } + } + ); + + std::jthread const writer( + [&buffer, &written_count] noexcept -> void { + std::this_thread::sleep_for(10ms); + + for (auto&& val : expected) + { + std::this_thread::sleep_for(3ms); + + buffer.emplace_back(val); + ++written_count; + } + } + ); + } + + REQUIRE(written_count == buffer_size); + + REQUIRE(read_count == buffer_size); + + REQUIRE(written_count == read_count); + + REQUIRE(reader_bag.size() == read_count); + + REQUIRE(buffer.to_span().size() == buffer_size); + + REQUIRE_THAT(reader_bag, Catch::Matchers::RangeEquals(expected)); + } + + SECTION("One writer and one reader of aggregate values (delayed writer)") + { + using std::chrono::operator""ms; + + static constexpr std::size_t const buffer_size{8}; + + using ValueType = dummy_aggregate; + + using SizeType = forfun::concurrency::wait_free::swmr_append_buffer< + ValueType, + buffer_size, + std::hardware_destructive_interference_size>::size_type; + + forfun::concurrency::wait_free::swmr_append_buffer< + ValueType, + buffer_size, + std::hardware_destructive_interference_size> + buffer{}; + + std::vector reader_bag{}; + reader_bag.reserve(buffer_size); + + SizeType written_count{}; + SizeType read_count{}; + + { + std::jthread const reader( + [&buffer, &reader_bag, &read_count] -> void { + while (read_count < buffer_size) + { + for (auto&& val : buffer.to_span().subspan(read_count)) + { + reader_bag.emplace_back(val); + ++read_count; + } + } + } + ); + + std::jthread const writer( + [&buffer, &written_count] noexcept -> void { + std::this_thread::sleep_for(10ms); + + for ( + auto&& n : + std::views::iota(1) | std::views::take(buffer_size) + ) + { + std::this_thread::sleep_for(10ms); + + buffer.emplace_back(n * 111, n * 4, n * 8, n * 20); + ++written_count; + } + } + ); + } + + REQUIRE(written_count == buffer_size); + + REQUIRE(read_count == buffer_size); + + REQUIRE(written_count == read_count); + + REQUIRE(reader_bag.size() == read_count); + + REQUIRE(buffer.to_span().size() == buffer_size); + + int generator_state{1}; + std::array expected{}; + for (auto& val : expected) + { + auto const n{generator_state++}; + val = {.a = n * 111, .b = n * 4, .c = n * 8, .d = n * 20}; + } + + REQUIRE_THAT(reader_bag, Catch::Matchers::RangeEquals(expected)); + } + + SECTION("Benchmark case") + { + constexpr std::size_t const capacity{16}; + + // NOLINTNEXTLINE(cppcoreguidelines-init-variables) + int volatile val /*[[indeterminate]]*/; + forfun::concurrency::wait_free::swmr_append_buffer< + int, + capacity, + std::hardware_destructive_interference_size> + buffer{}; + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + buffer.emplace_back(502807); + val = buffer.to_span().back(); + + REQUIRE(val == 502807); + } +}