WIP

Author: Charlie Frasch

Fifo4.hpp

@@ -5,6 +5,8 @@
 #include <memory>
 #include <new>
 
+#include <sanitizer/tsan_interface.h>
+
 
 /// Threadsafe, efficient circular FIFO with cached cursors
 template<typename T, typename Alloc = std::allocator<T>>
@@ -54,11 +56,14 @@ class Fifo4 : private Alloc
         auto pushCursor = pushCursor_.load(std::memory_order_relaxed);
         if (full(pushCursor, popCursorCached_)) {
             popCursorCached_ = popCursor_.load(std::memory_order_acquire);
+            // popCursorCached_ = popCursor_.load(std::memory_order_relaxed);
             if (full(pushCursor, popCursorCached_)) {
                 return false;
             }
         }
 
+        //__tsan_acquire(&popCursor_);
+        // std::atomic_thread_fence(std::memory_order_acquire);
         new (element(pushCursor)) T(value);
         pushCursor_.store(pushCursor + 1, std::memory_order_release);
         return true;
@@ -70,11 +75,14 @@ class Fifo4 : private Alloc
         auto popCursor = popCursor_.load(std::memory_order_relaxed);
         if (empty(pushCursorCached_, popCursor)) {
             pushCursorCached_ = pushCursor_.load(std::memory_order_acquire);
+            // pushCursorCached_ = pushCursor_.load(std::memory_order_relaxed);
             if (empty(pushCursorCached_, popCursor)) {
                 return false;
             }
         }
 
+        // __tsan_acquire(&pushCursor_);
+        // std::atomic_thread_fence(std::memory_order_acquire);
         value = *element(popCursor);
         element(popCursor)->~T();
         popCursor_.store(popCursor + 1, std::memory_order_release);

Fifo5a.hpp

@@ -133,8 +133,7 @@ class Fifo5a : private Alloc
     /// Push one object onto the fifo.
     /// @return `true` if the operation is successful; `false` if fifo is full.
     auto push(T const& value) noexcept {
-        auto pusher = push();
-        if (pusher) {
+        if (auto pusher = push(); pusher) {
             pusher = value;
             return true;
         }
@@ -211,8 +210,7 @@ class Fifo5a : private Alloc
     /// Pop one object from the fifo.
     /// @return `true` if the pop operation is successful; `false` if fifo is empty.
     auto pop(T& value) noexcept {
-        auto popper = pop();
-        if (popper) {
+        if (auto popper = pop(); popper) {
             value = *popper;
             return true;
         }

bench.cpp

@@ -68,18 +68,18 @@ void BM_Fifo(benchmark::State& state) {
     pinThread(cpu2);
     for (auto _ : state) {
         if constexpr(isRigtorp<fifo_type>::value) {
-            while (not fifo.try_push(value)) {
-                ;
+            while (auto again = not fifo.try_push(value)) {
+                benchmark::DoNotOptimize(again);
             }
         } else {
-            while (not fifo.push(value)) {
-                ;
+            while (auto again = not fifo.push(value)) {
+                benchmark::DoNotOptimize(again);
             }
         }
         ++value;
 
-        while (not fifo.empty()) {
-          ;
+        while (auto again = not fifo.empty()) {
+            benchmark::DoNotOptimize(again);
         }
     }
     state.counters["ops/sec"] = benchmark::Counter(double(value), benchmark::Counter::kIsRate);