WIP

Author: Charlie Frasch

.gitignore

@@ -0,0 +1 @@
+build

CMakeLists.txt

@@ -60,11 +60,19 @@ target_compile_options(fifo4.tsan PRIVATE -fsanitize=thread)
 target_link_libraries(fifo4.tsan PRIVATE pthread tsan)
 
 
+# add_executable(fifo7 fifo7.cpp)
+# target_link_libraries(fifo7 pthread)
+# 
+# add_executable(fifo7.tsan fifo7.cpp)
+# target_compile_options(fifo7.tsan PRIVATE -fsanitize=thread)
+# target_link_libraries(fifo7.tsan PRIVATE pthread tsan)
+
+
 include(GoogleTest)
 enable_testing()
 
-add_executable(tests sanitizers.cpp Fifo1_ut.cpp)
-target_compile_options(tests PRIVATE -fsanitize=undefined -fsanitize=address)
-target_link_libraries(tests PRIVATE asan ubsan gtest gtest_main)
-target_link_options(tests PRIVATE -fsanitize=undefined -fsanitize=address)
-gtest_add_tests(TARGET tests)
+add_executable(unitTests sanitizers.cpp unitTests.cpp)
+target_compile_options(unitTests PRIVATE -fsanitize=undefined -fsanitize=address)
+target_link_libraries(unitTests PRIVATE asan ubsan gtest gtest_main)
+target_link_options(unitTests PRIVATE -fsanitize=undefined -fsanitize=address)
+gtest_add_tests(TARGET unitTests)

Fifo1.hpp

@@ -13,11 +13,15 @@ class Fifo1
 
     explicit Fifo1(std::size_t size)
         : size_{size}
-        , ring_{
-              static_cast<ValueType*>(std::aligned_alloc(alignof(T), size * sizeof(T))),
-              &std::free}
+        , ring_{static_cast<ValueType*>(std::aligned_alloc(alignof(T), size * sizeof(T))), &std::free}
     {}
 
+    ~Fifo1() {
+        while(not empty()) {
+            ring_[popCursor_ % size_].~T();
+            ++popCursor_;
+        }
+    }
 
     std::size_t size() const { return size_; }
     bool empty() const { return popCursor_ == pushCursor_; }
@@ -29,7 +33,6 @@ class Fifo1
         }
         new (&ring_[pushCursor_ % size_]) T(value);
         ++pushCursor_;
-
         return true;
     }
 
@@ -42,7 +45,6 @@ class Fifo1
         value = ring_[popCursor_ % size_];
         ring_[popCursor_ % size_].~T();
         ++popCursor_;
-
         return true;
     }
 
@@ -52,6 +54,6 @@ class Fifo1
     using RingType = std::unique_ptr<ValueType[], decltype(&std::free)>;
     RingType ring_;
 
-    std::size_t pushCursor_{};
-    std::size_t popCursor_{};
+    std::size_t pushCursor_;
+    std::size_t popCursor_;
 };

Fifo1_ut.cpp

@@ -14,12 +14,10 @@ class Fifo2
 
     explicit Fifo2(std::size_t size)
         : size_{size}
-        , ring_{
-              static_cast<ValueType*>(std::aligned_alloc(alignof(T), size * sizeof(T))),
+        , ring_{static_cast<ValueType*>(std::aligned_alloc(alignof(T), size * sizeof(T))),
               &std::free}
     {}
 
-
     std::size_t size() const { return size_; }
     bool empty() const { return popCursor_ == pushCursor_; }
     bool full() const { return (pushCursor_ - popCursor_) == size_; }
@@ -30,7 +28,6 @@ class Fifo2
         }
         new (&ring_[pushCursor_ % size_]) T(value);
         ++pushCursor_;
-
         return true;
     }
 
@@ -43,7 +40,6 @@ class Fifo2
         value = ring_[popCursor_ % size_];
         ring_[popCursor_ % size_].~T();
         ++popCursor_;
-
         return true;
     }
 
@@ -54,8 +50,8 @@ class Fifo2
     RingType ring_;
 
     /// Loaded and stored by the push thread; loaded by the pop thread
-    std::atomic<std::size_t> pushCursor_{};
+    std::atomic<std::size_t> pushCursor_;
 
     /// Loaded and stored by the pop thread; loaded by the push thread
-    std::atomic<std::size_t> popCursor_{};
+    std::atomic<std::size_t> popCursor_;
 };

Fifo2.hpp

@@ -15,12 +15,10 @@ class Fifo3
 
     explicit Fifo3(std::size_t size)
         : size_{size}
-        , ring_{
-              static_cast<ValueType*>(std::aligned_alloc(alignof(T), size * sizeof(T))),
+        , ring_{static_cast<ValueType*>(std::aligned_alloc(alignof(T), size * sizeof(T))),
               &std::free}
     {}
 
-
     std::size_t size() const { return size_; }
     bool empty() const { return popCursor_ == pushCursor_; }
     bool full() const { return (pushCursor_ - popCursor_) == size_; }
@@ -68,8 +66,8 @@ class Fifo3
     static constexpr auto hardware_destructive_interference_size = std::size_t{128};
 
     /// Loaded and stored by the push thread; loaded by the pop thread
-    alignas(hardware_destructive_interference_size) std::atomic<std::size_t> pushCursor_{};
+    alignas(hardware_destructive_interference_size) std::atomic<std::size_t> pushCursor_;
 
     /// Loaded and stored by the pop thread; loaded by the push thread
-    alignas(hardware_destructive_interference_size) std::atomic<std::size_t> popCursor_{};
+    alignas(hardware_destructive_interference_size) std::atomic<std::size_t> popCursor_;
 };

Fifo3.hpp

@@ -6,7 +6,7 @@
 #include <new>
 
 
-/// Threadsafe, efficient circular FIFO
+/// Threadsafe, efficient circular FIFO with cached cursors
 template<typename T>
 class Fifo4
 {
@@ -15,12 +15,10 @@ class Fifo4
 
     explicit Fifo4(std::size_t size)
         : size_{size}
-        , ring_{
-              static_cast<ValueType*>(std::aligned_alloc(alignof(T), size * sizeof(T))),
+        , ring_{static_cast<ValueType*>(std::aligned_alloc(alignof(T), size * sizeof(T))),
               &std::free}
     {}
 
-
     std::size_t size() const { return size_; }
     bool empty() const { return popCursor_ == pushCursor_; }
     bool full() const { return (pushCursor_ - popCursor_) == size_; }
@@ -74,7 +72,6 @@ class Fifo4
     static constexpr auto hardware_destructive_interference_size = std::size_t{128};
 
     /// Loaded and stored by the push thread; loaded by the pop thread
-    // TODO fix initialization on the others
     alignas(hardware_destructive_interference_size) std::atomic<std::size_t> pushCursor_;
 
     /// Exclusive to the pop thread

Fifo4.hpp

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <cstdlib>
+#include <functional>
+#include <memory>
+
+
+/// adds allocator
+// TODO make same as others esp thread safety
+template<typename T, typename Allocator = std::allocator<T>>
+class Fifo7 : private Allocator
+{
+public:
+    using ValueType = T;
+    using allocator_traits = std::allocator_traits<Allocator>;
+
+    using RingType = std::unique_ptr<ValueType[], std::function<void(ValueType*)>>;
+
+    explicit Fifo7(std::size_t size, const Allocator& alloc = Allocator())
+        : Allocator(alloc)
+        , size_{size}
+        , ring_{
+              allocator_traits::allocate(*this, size_),
+              [this](ValueType* ring) {
+                  allocator_traits::deallocate(*this, ring, size_);
+              }}
+    {}
+
+    ~Fifo7() {
+        while(not empty()) {
+            ring_[popCursor_ % size_].~T();
+            ++popCursor_;
+        }
+    }
+
+    std::size_t size() const { return size_; }
+    bool empty() const { return popCursor_ == pushCursor_; }
+    bool full() const { return (pushCursor_ - popCursor_) == size_; }
+
+    bool push(T const& value) {
+        if (full()) {
+            return false;
+        }
+        new (&ring_[pushCursor_ % size_]) T(value);
+        ++pushCursor_;
+        return true;
+    }
+
+    /// Pop one object from the fifo.
+    /// @return `true` if the pop operation is successful; `false` if fifo was empty.
+    bool pop(T& value) {
+        if (empty()) {
+            return false;
+        }
+        value = ring_[popCursor_ % size_];
+        ring_[popCursor_ % size_].~T();
+        ++popCursor_;
+        return true;
+    }
+
+private:
+    std::size_t size_;
+    RingType ring_;
+    std::size_t pushCursor_;
+    std::size_t popCursor_;
+};

Fifo7.hpp

@@ -5,6 +5,7 @@
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
+#include <iomanip>
 #include <iostream>
 #include <stdexcept>
 #include <thread>
@@ -42,7 +43,7 @@ void bench(char const* name, int cpu1, int cpu2) {
                 ;
             }
             if (val[0] != i) {
-                throw std::runtime_error("foo");
+                throw std::runtime_error("invalid value");
             }
         }
     });
@@ -59,8 +60,9 @@ void bench(char const* name, int cpu1, int cpu2) {
     }
     auto stop = std::chrono::steady_clock::now();
     t.join();
-    std::cout << name << ": " << iters * 1'000'000'000 /
-        std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count()
+    auto delta = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
+    std::cout << name << ": "
+        << std::setw(8) << std::right << iters * 1'000'000'000 / delta.count()
         << " ops/s\n";
 }