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 ded4761b..00000000 --- a/benchmark/concurrency/spsc_bound_queue_benchmark.cpp +++ /dev/null @@ -1,92 +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 - -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{}).c_str(), - [] noexcept -> void { - // NOLINTNEXTLINE(cppcoreguidelines-init-variables) - int volatile val /*[[indeterminate]]*/; - - wait_free::spsc_bound_queue 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/spsc_bound_queue.hpp deleted file mode 100644 index f8f699f0..00000000 --- a/include/forfun/concurrency/spsc_bound_queue.hpp +++ /dev/null @@ -1,302 +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 - -#ifndef FORFUN_CONCURRENCY_SPSC_APPEND_QUEUE_HPP_ -#define FORFUN_CONCURRENCY_SPSC_APPEND_QUEUE_HPP_ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace forfun::concurrency::wait_free { - -namespace detail { - -/// @note Assumes @p buffer is correctly aligned. -template -[[nodiscard]] constexpr auto -get_ptr_to_obj(std::byte* const buffer, Offset const offset) noexcept -> Pointer -{ -#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__ - - // NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast,cppcoreguidelines-pro-bounds-pointer-arithmetic) - assert( - reinterpret_cast( - reinterpret_cast(buffer) + offset - ) % alignof(std::remove_pointer_t) - == 0UZ - ); - - return reinterpret_cast(buffer) + offset; - // NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast,cppcoreguidelines-pro-bounds-pointer-arithmetic) - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif // __clang__ - -#if defined(__GNUC__) && !defined(__clang__) -#pragma GCC diagnostic pop -#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. -/// -/// Features: -/// - Wait-free (lock-free) concurrency model -/// - First in, first out (FIFO) order semantics -/// - 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. -/// -/// @note The implementation prioritizes performance over safety and security. -/// -/// @note Internal storage and padding area might not be (zero-)initialized. -template - requires std::destructible -// 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; - -public: - using size_type = std::size_t; - - using value_type = T; - - using reference = value_type&; - - 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 - - spsc_bound_queue(spsc_bound_queue const&) = delete; - - spsc_bound_queue(spsc_bound_queue&&) = delete; - - constexpr ~spsc_bound_queue() noexcept(noexcept(reset_storage())) - { - reset_storage(); - } - - auto operator=(spsc_bound_queue const&) -> spsc_bound_queue& = delete; - - 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; - - /// @note Not thread-safe. - [[nodiscard]] auto empty_unsafe() const noexcept -> bool - { - using std::atomic_load_explicit; - - return atomic_load_explicit(&write_cursor_, std::memory_order_relaxed) - == cursor_type{}; - } - - /// @note Undefined behavior when pushing to a full container. - template - auto emplace_back(Args&&... args) noexcept -> reference - { - using std::atomic_fetch_add_explicit; - using std::atomic_load_explicit; - using std::data; - - static_assert(capacity_ != 0UZ); - - assert(std::cmp_less(write_cursor_cached_, capacity_)); - - auto* const ptr_emplaced{std::construct_at( - detail::get_ptr_to_obj( - data(raw_queue_), write_cursor_cached_ - ), - std::forward(args)... - )}; - - ++write_cursor_cached_; - atomic_store_explicit( - &write_cursor_, write_cursor_cached_, std::memory_order_release - ); - - return *ptr_emplaced; - } - - auto reset_unsafe() noexcept(noexcept(reset_storage())) -> void - { - reset_storage(); - - reset_indices(); - } - - [[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) - }; - -#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(data(raw_queue_)), - static_cast(cursor_snapshot) - ); - -#ifdef __clang__ -#pragma clang diagnostic pop -#endif // __clang__ - } - - [[nodiscard]] static consteval auto capacity() noexcept -> size_type - { - return capacity_; - } - -private: - static_assert(std::has_single_bit(Capacity)); - static constexpr std::size_t const capacity_{Capacity}; - - /// Raw cursor type, without atomic wrapper. - using cursor_type = std::ptrdiff_t; - - static_assert(std::atomic::is_always_lock_free); - - alignas(T) raw_queue_type raw_queue_ - /*[[indeterminate]]*/; - - static_assert(std::same_as); - 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}; - -#ifdef _MSC_VER -#pragma warning(pop) // C4324 -#endif // _MSC_VER - - cursor_type write_cursor_cached_{}; - - static_assert( - std::hardware_destructive_interference_size >= sizeof(cursor_type) - ); - -#if defined(__GNUC__) && !defined(__clang__) -#pragma GCC diagnostic pop -#endif // defined(__GNUC__) && !defined(__clang__) - - 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_ = {}; - - atomic_store_explicit( - &write_cursor_, cursor_type{}, std::memory_order_release - ); - } - - constexpr auto reset_storage() noexcept(noexcept(detail::destroy_n( - std::declval(), capacity_ - ))) -> void - { - using std::data; - - assert(std::cmp_less_equal(write_cursor_cached_, capacity_)); - - detail::destroy_n(data(raw_queue_), write_cursor_cached_); - } -}; - -} // namespace forfun::concurrency::wait_free - -#endif // FORFUN_CONCURRENCY_SPSC_APPEND_QUEUE_HPP_ diff --git a/include/forfun/concurrency/swmr_append_buffer.hpp b/include/forfun/concurrency/swmr_append_buffer.hpp new file mode 100644 index 00000000..314e1a5f --- /dev/null +++ b/include/forfun/concurrency/swmr_append_buffer.hpp @@ -0,0 +1,231 @@ +// 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 + +#ifndef FORFUN_CONCURRENCY_SWMR_APPEND_BUFFER_HPP_ +#define FORFUN_CONCURRENCY_SWMR_APPEND_BUFFER_HPP_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace forfun::concurrency::wait_free { + +namespace detail { + +/// @note Assumes @p buffer is aligned as Type. +template +[[nodiscard]] auto +get_ptr_to_obj(std::byte* const buffer, std::size_t const offset) noexcept + -> Type* +{ + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) + assert(reinterpret_cast(buffer) % alignof(Type) == 0UZ); + + return static_cast( + // NOLINTNEXTLINE(bugprone-casting-through-void,cppcoreguidelines-pro-bounds-pointer-arithmetic) + static_cast(buffer + (offset * sizeof(Type))) + ); +} + +} // namespace detail + +/// Single-writer multiple non-claiming readers, bounded append-only buffer. +/// +/// Features: +/// - Wait-free (lock-free) concurrency model +/// - Fixed-capacity, and non-circular +/// - Multi-pass reads via @c std::span +/// - Inline storage with no dynamic allocation +/// - Append-one by one; Reset all, manually or when buffer is destroyed. +/// +/// @warning Experimental implementation. Has not been reviewed for safety or +/// security. +template + 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 swmr_append_buffer final { +private: + // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays) + using storage_type = std::byte[Size * sizeof(Type)]; + +public: + using size_type = std::size_t; + + using value_type = Type; + + using reference = value_type&; + + using span_type = std::span; + + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,modernize-use-equals-default) + swmr_append_buffer() noexcept + { + // Avoid zero initialization. + } + + swmr_append_buffer(swmr_append_buffer const&) = delete; + + swmr_append_buffer(swmr_append_buffer&&) = delete; + + ~swmr_append_buffer() + requires std::is_trivially_destructible_v + = default; + + ~swmr_append_buffer() + requires(not std::is_trivially_destructible_v) + { + reset_storage(); + } + + auto operator=(swmr_append_buffer const&) -> swmr_append_buffer& = delete; + + auto operator=(swmr_append_buffer&&) -> swmr_append_buffer& = delete; + + [[nodiscard]] auto empty() const noexcept -> bool + { + using std::atomic_load_explicit; + + return atomic_load_explicit(&write_cursor_, std::memory_order_relaxed) + == cursor_type{}; + } + + /// @note Undefined behavior when pushing to a full container. + template + auto emplace_back(Args&&... args) noexcept -> reference + { + using std::atomic_load_explicit; + using std::atomic_store_explicit; + + 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(storage_), write_cursor_copy + ), + std::forward(args)... + )}; + + atomic_store_explicit( + &write_cursor_, + write_cursor_copy + cursor_type{1}, + std::memory_order_release + ); + + return *ptr_emplaced; + } + + auto reset_unsafe() noexcept -> void + { + using std::atomic_store_explicit; + + reset_storage(); + + atomic_store_explicit( + &write_cursor_, cursor_type{}, std::memory_order_release + ); + } + + [[nodiscard]] auto to_span() noexcept -> span_type + { + using std::atomic_load_explicit; + + auto const last{ + atomic_load_explicit(&write_cursor_, std::memory_order_acquire) + }; + + return span_type( + detail::get_ptr_to_obj(std::data(storage_), {}), + static_cast(last) + ); + } + + [[nodiscard]] static constexpr auto capacity() noexcept -> size_type + { + return capacity_; + } + +private: + 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(Type) storage_type storage_; + + static_assert(std::same_as); + +#ifdef _MSC_VER +#pragma warning(push) +// Warning C4324: 'type': structure was padded due to alignment specifier. +#pragma warning(disable : 4324) +#endif // _MSC_VER + + alignas(CacheLineSeparation) std::atomic write_cursor_{0}; + +#ifdef _MSC_VER +#pragma warning(pop) // C4324 +#endif // _MSC_VER + + static_assert(CacheLineSeparation >= sizeof(cursor_type)); + + std::array + end_of_object_padding_; + + auto reset_storage() noexcept -> void + { + 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_copy)}; + auto* reversed_first{detail::get_ptr_to_obj( + std::data(storage_), static_cast(write_cursor_copy) + )}; + for (auto i{size}; i != size_type{}; --i) + { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + std::destroy_at(reversed_first + (i - size_type{1})); + } + } + } +}; + +} // namespace forfun::concurrency::wait_free + +#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_statictest.cpp b/test/concurrency/spsc_bound_queue_statictest.cpp deleted file mode 100644 index 21426973..00000000 --- a/test/concurrency/spsc_bound_queue_statictest.cpp +++ /dev/null @@ -1,113 +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 - -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") - { - STATIC_REQUIRE_FALSE( - std::has_unique_object_representations_v< - forfun::concurrency::wait_free::spsc_bound_queue> - ); - - STATIC_REQUIRE_FALSE( - std::has_unique_object_representations_v< - forfun::concurrency::wait_free::spsc_bound_queue> - ); - } - - SECTION("Construction and initialization") - { - STATIC_REQUIRE_FALSE( - std::copyable< - forfun::concurrency::wait_free::spsc_bound_queue> - ); - - STATIC_REQUIRE_FALSE( - std::movable< - forfun::concurrency::wait_free::spsc_bound_queue> - ); - } - - SECTION("Destructor call on empty queue") - { - STATIC_REQUIRE(is_constexpr_destructor()); - } - - SECTION("Comparision") - { - STATIC_REQUIRE_FALSE( - std::equality_comparable< - forfun::concurrency::wait_free::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 - = forfun::concurrency::wait_free::spsc_bound_queue; - - STATIC_REQUIRE(queue_type::capacity() == 8UZ); - } - - SECTION("Type aliases") - { - using queue_type - = forfun::concurrency::wait_free::spsc_bound_queue; - - 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; - - STATIC_REQUIRE(std::same_as>); - - STATIC_REQUIRE( - std::same_as< - queue_type::span_type, - decltype(std::declval().to_span())> - ); - } -} diff --git a/test/concurrency/spsc_bound_queue_test.cpp b/test/concurrency/spsc_bound_queue_test.cpp deleted file mode 100644 index 97940aaa..00000000 --- a/test/concurrency/spsc_bound_queue_test.cpp +++ /dev/null @@ -1,729 +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 - -namespace { - -struct dummy_aggregate { - // 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; -}; - -} // 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) -) -{ - SECTION("Initial span is empty") - { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; - - REQUIRE(queue.to_span().empty()); - } - - SECTION("Initially empty") - { - forfun::concurrency::wait_free::spsc_bound_queue const - queue{}; - - REQUIRE(queue.empty_unsafe()); - } - - SECTION("Capacity is as requested") - { - forfun::concurrency::wait_free::spsc_bound_queue const - queue{}; - - REQUIRE(queue.capacity() == Size); - } - - SECTION("Emplace affects empty state") - { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; - - queue.emplace_back(677); - - REQUIRE_FALSE(queue.empty_unsafe()); - - queue.emplace_back(683); - - REQUIRE_FALSE(queue.empty_unsafe()); - } - - SECTION("Emplace affects span size") - { - forfun::concurrency::wait_free::spsc_bound_queue 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") - { - forfun::concurrency::wait_free::spsc_bound_queue 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") - { - forfun::concurrency::wait_free::spsc_bound_queue 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") - { - using ValueType = int; - - constexpr std::size_t const queue_capacity{8}; - - forfun::concurrency::wait_free:: - spsc_bound_queue - queue{}; - - for ( - ValueType const n : - std::views::iota(ValueType{1}) | std::views::take(queue_capacity) - ) - { - auto const& ref{queue.emplace_back(n)}; - REQUIRE(ref == n); - } - - REQUIRE_FALSE(queue.empty_unsafe()); - - 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("To span") - { - forfun::concurrency::wait_free::spsc_bound_queue 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") - { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; - - queue.reset_unsafe(); - - REQUIRE(queue.empty_unsafe()); - } - - SECTION("Reset call on non-empty non-full queue") - { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; - queue.emplace_back(1); - queue.emplace_back(2); - queue.emplace_back(3); - - queue.reset_unsafe(); - - REQUIRE(queue.empty_unsafe()); - } - - SECTION("Destructor call on empty queue") - { - { - forfun::concurrency::wait_free::spsc_bound_queue const - queue{}; - } - - SUCCEED(); - } - - SECTION("Destructor call on non-empty queue") - { - { - forfun::concurrency::wait_free::spsc_bound_queue - queue{}; - queue.emplace_back(1); - } - - SUCCEED(); - } - - SECTION("Destructor call on non-empty non-full queue") - { - { - forfun::concurrency::wait_free::spsc_bound_queue - 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 queue{}; - - REQUIRE(queue.to_span().empty()); - } - - SECTION("Initially empty") - { - forfun::concurrency::wait_free::spsc_bound_queue const queue{}; - - REQUIRE(queue.empty_unsafe()); - } - - SECTION("Capacity is as requested") - { - forfun::concurrency::wait_free::spsc_bound_queue const queue{}; - - REQUIRE(queue.capacity() == 1UZ); - } - - SECTION("Single-slot queue resets cleanly and refills") - { - forfun::concurrency::wait_free::spsc_bound_queue queue{}; - - queue.emplace_back(11); - - REQUIRE(queue.to_span().size() == 1UZ); - - REQUIRE(queue.to_span().front() == 11); - - queue.reset_unsafe(); - - REQUIRE(queue.empty_unsafe()); - - 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 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_unsafe()); - } - - 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 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_unsafe()); - - 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_unsafe()); - - 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 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( - "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::size_type; - using ValueType = forfun::concurrency::wait_free:: - spsc_bound_queue::value_type; - - forfun::concurrency::wait_free::spsc_bound_queue - 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::size_type; - - forfun::concurrency::wait_free::spsc_bound_queue - 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::size_type; - using ValueType = forfun::concurrency::wait_free:: - spsc_bound_queue::value_type; - - forfun::concurrency::wait_free::spsc_bound_queue - 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::size_type; - - forfun::concurrency::wait_free::spsc_bound_queue - 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 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/swmr_append_buffer_statictest.cpp b/test/concurrency/swmr_append_buffer_statictest.cpp new file mode 100644 index 00000000..fd729433 --- /dev/null +++ b/test/concurrency/swmr_append_buffer_statictest.cpp @@ -0,0 +1,106 @@ +// 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 + +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::swmr_append_buffer< + char, + 8, + std::hardware_destructive_interference_size>> + ); + + STATIC_REQUIRE_FALSE( + std::has_unique_object_representations_v< + forfun::concurrency::wait_free::swmr_append_buffer< + int, + 8, + std::hardware_destructive_interference_size>> + ); + } + + SECTION("Construction and initialization") + { + STATIC_REQUIRE_FALSE( + std::copyable> + ); + + STATIC_REQUIRE_FALSE( + std::movable> + ); + } + + SECTION("Comparision") + { + STATIC_REQUIRE_FALSE( + std::equality_comparable< + forfun::concurrency::wait_free::swmr_append_buffer< + int, + 8, + std::hardware_destructive_interference_size>> + ); + } + + SECTION("Capacity is as requested") + { + using buffer_type = forfun::concurrency::wait_free::swmr_append_buffer< + int, + 8, + std::hardware_destructive_interference_size>; + + STATIC_REQUIRE(buffer_type::capacity() == 8UZ); + } + + SECTION("Type aliases") + { + 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); + } + + SECTION("To span") + { + 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< + 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); + } +}