Fix small compilation issues.

Author: IYP-Programer-Yeah

Test/Source/single-producer-single-conumer-test.cpp

@@ -9,17 +9,15 @@ namespace Iyp
 {
 namespace SingleProducerSingleConsumerRingBufferTest
 {
-
-constexpr static std::size_t RingSize = 4096;
+static constexpr std::size_t RingSize = 4096;
+static constexpr std::size_t NumberOfTries = 4096;
 using TestRingBufferType = WaitFreeRingBufferUtilities::RingBuffer<std::size_t,
                                                                    WaitFreeRingBufferUtilities::AccessRequirements::SINGLE_CONSUMER |
                                                                        WaitFreeRingBufferUtilities::AccessRequirements::SINGLE_PRODUCER,
                                                                    RingSize>;
 
 TEST(SingleProducerSingleConsumerRingBufferTest, EmptyAndFullRingTest)
 {
-    constexpr std::size_t NumberOfTries = 256;
-
     TestRingBufferType ring;
 
     EXPECT_FALSE(ring.pop());
@@ -40,8 +38,6 @@ TEST(SingleProducerSingleConsumerRingBufferTest, EmptyAndFullRingTest)
 
 TEST(SingleProducerSingleConsumerRingBufferTest, PushPopIntegrity)
 {
-    constexpr std::size_t NumberOfTries = 256;
-
     TestRingBufferType ring;
 
     for (std::size_t try_index = 0; try_index < NumberOfTries; try_index++)
@@ -64,8 +60,6 @@ TEST(SingleProducerSingleConsumerRingBufferTest, PushPopIntegrity)
 
 TEST(SingleProducerSingleConsumerRingBufferTest, OrderedPushPop)
 {
-    constexpr std::size_t NumberOfTries = 256;
-
     TestRingBufferType ring;
 
     for (std::size_t try_index = 0; try_index < NumberOfTries; try_index++)
@@ -81,44 +75,33 @@ TEST(SingleProducerSingleConsumerRingBufferTest, OrderedPushPop)
     }
 }
 
-TEST(SingleProducerSingleConsumerRingBufferTest, SingleProducerSingleConsumerPushPopIntergrity)
+TEST(SingleProducerSingleConsumerRingBufferTest, SingleProducerSingleConsumerPushPopIntergrityAndOrder)
 {
-    constexpr std::size_t NumberOfTries = 256;
-
     TestRingBufferType ring;
 
     std::array<std::atomic_size_t, RingSize> pop_counts;
 
     for (auto &pop_count : pop_counts)
         pop_count = 0;
 
-    std::thread popper([&ring, &pop_counts, NumberOfTries]() {
+    std::thread popper([&ring, &pop_counts]() {
         for (std::size_t try_index = 0; try_index < NumberOfTries; try_index++)
-        {
-            for (std::size_t i = 0; i < RingSize; i++)
+            for (std::size_t i = 0; i < RingSize;)
             {
-                while (true)
+                const auto popped_value = ring.pop();
+                if (popped_value)
                 {
-                    const auto popped_value = ring.pop();
-                    if (popped_value)
-                    {
-                        pop_counts[*popped_value].fetch_add(1, std::memory_order_relaxed);
-                        break;
-                    }
+                    if (popped_value.get() == i)
+                        pop_counts[i].fetch_add(1, std::memory_order_relaxed);
+                    i++;
                 }
             }
-        }
     });
 
     for (std::size_t try_index = 0; try_index < NumberOfTries; try_index++)
-    {
-        for (std::size_t i = 0; i < RingSize; i++)
-        {
-            while (!ring.push(i))
-            {
-            }
-        }
-    }
+        for (std::size_t i = 0; i < RingSize;)
+            if (ring.push(i))
+                i++;
 
     popper.join();
 

WaitFreeRingBufferUtilities/Include/details/ring-buffer-type-constructor.inl

@@ -30,13 +30,11 @@ template <typename T>
 struct Element
 {
     using ElementType = T;
-    CacheAlignedAndPaddedObject<std::atomic<std::uint_fast8_t>> state{ElementState::READY_FOR_PUSH};
+    std::atomic<std::uint_fast8_t> state{ElementState::READY_FOR_PUSH};
     T *value_ptr;
     typename std::aligned_storage<sizeof(T), alignof(T)>::type storage;
 
-    Element() : value_ptr(nullptr)
-    {
-    }
+    Element() = default;
 
     Element(const Element &) = delete;
     Element(Element &&) = delete;
@@ -46,7 +44,7 @@ struct Element
 
     ~Element()
     {
-        if (value_ptr)
+        if (state.load(std::memory_order_acquire) == ElementState::READY_FOR_POP)
             value_ptr->~T();
     }
 };
@@ -80,6 +78,14 @@ struct CountInt64CompatibilityCheck
 {
     static_assert(Count <= static_cast<std::size_t>(std::numeric_limits<std::int64_t>::max()), "Count exceeds the maximum. Count should fit in a std::int64_t.");
 };
+
+struct DummyAtomicSizeT
+{
+    std::size_t fetch_add(const std::size_t, const std::memory_order)
+    {
+        return 0;
+    }
+};
 } // namespace Private
 
 template <typename ProducerTypeTraits, typename ConsumerTypeTraits, typename T, std::size_t Count>
@@ -113,14 +119,14 @@ struct MultiProducerTypeTraits
 
             while (true)
             {
-                const std::size_t local_end = end.fetch_add(1, std::memory_order_acquire);
-                const std::size_t element_index = local_end & BaseType::COUNT_MASK;
+                const std::size_t element_index = end.fetch_add(1, std::memory_order_acquire) & BaseType::COUNT_MASK;
+                auto &element = BaseType::elements[element_index];
 
-                auto expected_element_state = ElementState::READY_FOR_PUSH;
-                if (std::atomic_compare_exchange_strong(&BaseType::elements[element_index].state, &expected_element_state, ElementState::IN_PROGRESS))
+                std::uint_fast8_t expected_element_state = ElementState::READY_FOR_PUSH;
+                if (std::atomic_compare_exchange_strong(&element.state, &expected_element_state, std::uint_fast8_t(ElementState::IN_PROGRESS)))
                 {
-                    BaseType::elements[element_index].value_ptr = new (&BaseType::elements[element_index].storage) ElementType(std::forward<Args>(args)...);
-                    BaseType::elements[element_index].state.store(ElementState::READY_FOR_POP, std::memory_order_release);
+                    element.value_ptr = new (&element.storage) ElementType(std::forward<Args>(args)...);
+                    element.state.store(ElementState::READY_FOR_POP, std::memory_order_release);
                     BaseType::pop_task_count.fetch_add(1, std::memory_order_release);
                     return true;
                 }
@@ -157,16 +163,16 @@ struct MultiConsumerTypeTraits
 
             while (true)
             {
-                const std::size_t local_begin = begin.fetch_add(1, std::memory_order_acquire);
-                const std::size_t element_index = local_begin & BaseType::COUNT_MASK;
+                const std::size_t element_index = begin.fetch_add(1, std::memory_order_acquire) & BaseType::COUNT_MASK;
+                auto &element = BaseType::elements[element_index];
 
-                auto expected_element_state = ElementState::READY_FOR_POP;
-                if (std::atomic_compare_exchange_strong(&BaseType::elements[element_index].state, &expected_element_state, ElementState::IN_PROGRESS))
+                std::uint_fast8_t expected_element_state = ElementState::READY_FOR_POP;
+                if (std::atomic_compare_exchange_strong(&element.state, &expected_element_state, std::uint_fast8_t(ElementState::IN_PROGRESS)))
                 {
-                    OptionalType<ElementType> result{std::move(*BaseType::elements[element_index].value_ptr)};
-                    BaseType::elements[element_index].value_ptr->~ElementType();
+                    OptionalType<ElementType> result{std::move(*element.value_ptr)};
+                    element.value_ptr->~ElementType();
 
-                    BaseType::elements[element_index].state.store(ElementState::READY_FOR_PUSH, std::memory_order_release);
+                    element.state.store(ElementState::READY_FOR_PUSH, std::memory_order_release);
                     BaseType::push_task_count.fetch_add(1, std::memory_order_release);
                     return result;
                 }
@@ -190,50 +196,39 @@ struct SingleProducerTypeTraits
     private:
         struct State
         {
-            std::size_t pushed_task_count{0};
-            std::size_t local_push_task_count{BaseType::COUNT};
             std::size_t end{0};
         };
 
-        CacheAlignedAndPaddedObject<State> state{};
+        CacheAlignedAndPaddedObject<State> state;
 
     public:
         using ElementType = typename BaseType::ElementType;
 
         template <typename... Args>
         bool push(Args &&... args)
         {
-            if (state.local_push_task_count == state.pushed_task_count)
-            {
-                const auto stack_local_push_task_count = BaseType::push_task_count.load(std::memory_order_acquire);
-                if (state.local_push_task_count == stack_local_push_task_count)
-                    return false;
-                state.local_push_task_count = stack_local_push_task_count;
-            }
+            const std::size_t element_index = state.end & BaseType::COUNT_MASK;
+            auto &element = BaseType::elements[element_index];
 
-            state.pushed_task_count++;
-
-            while (true)
+            if (element.state.load(std::memory_order_acquire) == ElementState::READY_FOR_PUSH)
             {
-                const std::size_t element_index = (state.end++) & BaseType::COUNT_MASK;
-
-                if (BaseType::elements[element_index].state.load(std::memory_order_acquire) == ElementState::READY_FOR_PUSH)
-                {
-                    BaseType::elements[element_index].value_ptr = new (&BaseType::elements[element_index].storage) ElementType(std::forward<Args>(args)...);
-                    BaseType::elements[element_index].state.store(ElementState::READY_FOR_POP, std::memory_order_release);
-                    BaseType::pop_task_count.fetch_add(1, std::memory_order_release);
+                element.value_ptr = new (&element.storage) ElementType(std::forward<Args>(args)...);
+                element.state.store(ElementState::READY_FOR_POP, std::memory_order_release);
+                BaseType::pop_task_count.fetch_add(1, std::memory_order_release);
 
-                    return true;
-                }
+                state.end++;
+                return true;
             }
+            else
+                return false;
         }
     };
 
     template <typename BaseType>
     struct SharedState : BaseType
     {
     protected:
-        CacheAlignedAndPaddedObject<std::atomic_size_t> push_task_count{BaseType::COUNT};
+        Private::DummyAtomicSizeT push_task_count{};
     };
 };
 
@@ -245,51 +240,40 @@ struct SingleConsumerTypeTraits
     private:
         struct State
         {
-            std::size_t popped_task_count{0};
-            std::size_t local_pop_task_count{0};
             std::size_t begin{0};
         };
 
-        CacheAlignedAndPaddedObject<State> state{};
+        CacheAlignedAndPaddedObject<State> state;
 
     public:
         using ElementType = typename BaseType::ElementType;
 
         OptionalType<ElementType> pop()
         {
-            if (state.local_pop_task_count == state.popped_task_count)
-            {
-                const auto stack_local_pop_task_count = BaseType::pop_task_count.load(std::memory_order_acquire);
-                if (state.local_pop_task_count == stack_local_pop_task_count)
-                    return OptionalType<ElementType>{};
-                state.local_pop_task_count = stack_local_pop_task_count;
-            }
-
-            state.popped_task_count++;
+            const std::size_t element_index = state.begin & BaseType::COUNT_MASK;
+            auto &element = BaseType::elements[element_index];
 
-            while (true)
+            if (element.state.load(std::memory_order_acquire) == ElementState::READY_FOR_POP)
             {
-                const std::size_t element_index = (state.begin++) & BaseType::COUNT_MASK;
+                OptionalType<ElementType> result{std::move(*element.value_ptr)};
+                element.value_ptr->~ElementType();
 
-                if (BaseType::elements[element_index].state.load(std::memory_order_acquire) == ElementState::READY_FOR_POP)
-                {
-                    OptionalType<ElementType> result{std::move(*BaseType::elements[element_index].value_ptr)};
-                    BaseType::elements[element_index].value_ptr->~ElementType();
-
-                    BaseType::elements[element_index].state.store(ElementState::READY_FOR_PUSH, std::memory_order_release);
-                    BaseType::push_task_count.fetch_add(1, std::memory_order_release);
+                element.state.store(ElementState::READY_FOR_PUSH, std::memory_order_release);
+                BaseType::push_task_count.fetch_add(1, std::memory_order_release);
 
-                    return result;
-                }
+                state.begin++;
+                return result;
             }
+            else
+                return OptionalType<ElementType>{};
         }
     };
 
     template <typename BaseType>
     struct SharedState : BaseType
     {
     protected:
-        CacheAlignedAndPaddedObject<std::atomic_size_t> pop_task_count{std::size_t{0}};
+        Private::DummyAtomicSizeT pop_task_count{};
     };
 };