WIP

Author: Charlie Frasch

CMakeLists.txt

@@ -4,22 +4,61 @@ set(CMAKE_CXX_COMPILER /usr/bin/g++-12)
 
 project(cppcon2023)
 
+cmake_path(GET PROJECT_BINARY_DIR STEM buildDir)
+string(TOLOWER ${buildDir} buildDir)
+if(buildDir STREQUAL "release")
+    set(buildType RelWithDebInfo)
+elseif(buildDir STREQUAL "debug")
+    set(buildType Debug)
+else()
+    set(buildType Debug)
+endif()
 
-# TODO fix this
-set(CMAKE_BUILD_TYPE Debug)
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE ${buildType})
+endif()
 
-set(CMAKE_CXX_STANDARD 20)
+# if(CMAKE_BUILD_TYPE STREQUAL RelWithDebInfo OR CMAKE_BUILD_TYPE STREQUAL Release )
+# endif()
+
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED true)
 set(CMAKE_CXX_EXTENSIONS OFF)
 add_compile_options(-Wall -Werror -Wextra -Wconversion)
 add_compile_options(-Wno-unused-parameter)
 
-add_executable(benchmark benchmark.cpp)
-target_link_libraries(benchmark pthread)
 
-# add_executable(benchmark.tsan benchmark.cpp)
-# target_compile_options(benchmark.tsan -fsanitize=thread)
-# target_link_libraries(benchmark.tsan pthread)
+add_executable(fifo1 fifo1.cpp)
+target_link_libraries(fifo1 pthread)
+
+add_executable(fifo1.tsan fifo1.cpp)
+target_compile_options(fifo1.tsan PRIVATE -fsanitize=thread)
+target_link_libraries(fifo1.tsan PRIVATE pthread tsan)
+
+
+add_executable(fifo2 fifo2.cpp)
+target_link_libraries(fifo2 pthread)
+
+add_executable(fifo2.tsan fifo2.cpp)
+target_compile_options(fifo2.tsan PRIVATE -fsanitize=thread)
+target_link_libraries(fifo2.tsan PRIVATE pthread tsan)
+
+
+add_executable(fifo3 fifo3.cpp)
+target_link_libraries(fifo3 pthread)
+
+add_executable(fifo3.tsan fifo3.cpp)
+target_compile_options(fifo3.tsan PRIVATE -fsanitize=thread)
+target_link_libraries(fifo3.tsan PRIVATE pthread tsan)
+
+
+add_executable(fifo4 fifo4.cpp)
+target_link_libraries(fifo4 pthread)
+
+add_executable(fifo4.tsan fifo4.cpp)
+target_compile_options(fifo4.tsan PRIVATE -fsanitize=thread)
+target_link_libraries(fifo4.tsan PRIVATE pthread tsan)
+
 
 include(GoogleTest)
 enable_testing()

Fifo1.hpp

@@ -27,7 +27,7 @@ class Fifo1
         if (full()) {
             return false;
         }
-        new (ring_.get() + pushCursor_ % size_) T(value);
+        new (&ring_[pushCursor_ % size_]) T(value);
         ++pushCursor_;
 
         return true;
@@ -39,8 +39,8 @@ class Fifo1
         if (empty()) {
             return false;
         }
-        value = ring_.get()[popCursor_ % size_];
-        ring_.get()[popCursor_ % size_].~T();
+        value = ring_[popCursor_ % size_];
+        ring_[popCursor_ % size_].~T();
         ++popCursor_;
 
         return true;
@@ -49,7 +49,7 @@ class Fifo1
 private:
     std::size_t size_;
 
-    using RingType = std::unique_ptr<ValueType, decltype(&std::free)>;
+    using RingType = std::unique_ptr<ValueType[], decltype(&std::free)>;
     RingType ring_;
 
     std::size_t pushCursor_{};

Fifo1_ut.cpp

@@ -57,3 +57,37 @@ TEST(Fifo1, pop) {
     }
     EXPECT_FALSE(fifo.pop(value));
 }
+
+TEST(Fifo1, popFullFifo) {
+    auto fifo = TestFifo(4);
+
+    auto value = TestFifo::ValueType{};
+    EXPECT_FALSE(fifo.pop(value));
+
+    for (auto i = 0u; i < fifo.size(); ++i) {
+        fifo.push(42 + i);
+    }
+    EXPECT_TRUE(fifo.full());
+
+    for (auto i = 0u; i < fifo.size()*4; ++i) {
+        EXPECT_TRUE(fifo.pop(value));
+        EXPECT_EQ(42+i, value);
+
+        EXPECT_TRUE(fifo.push(42 + 4 + i));
+        EXPECT_TRUE(fifo.full());
+    }
+}
+
+TEST(Fifo1, popEmpty) {
+    auto fifo = TestFifo(4);
+
+    auto value = TestFifo::ValueType{};
+    EXPECT_FALSE(fifo.pop(value));
+
+    for (auto i = 0u; i < fifo.size()*4; ++i) {
+        EXPECT_TRUE(fifo.empty());
+        EXPECT_TRUE(fifo.push(42 + i));
+        EXPECT_TRUE(fifo.pop(value));
+        EXPECT_EQ(42+i, value);
+    }
+}

Fifo2.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <atomic>
+#include <cstdlib>
+#include <memory>
+
+
+/// Threadsafe but flawed circular FIFO
+template<typename T>
+class Fifo2
+{
+public:
+    using ValueType = T;
+
+    explicit Fifo2(std::size_t size)
+        : size_{size}
+        , 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_; }
+
+    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_;
+
+    using RingType = std::unique_ptr<ValueType[], decltype(&std::free)>;
+    RingType ring_;
+
+    /// Loaded and stored by the push thread; loaded by the pop thread
+    std::atomic<std::size_t> pushCursor_{};
+
+    /// Loaded and stored by the pop thread; loaded by the push thread
+    std::atomic<std::size_t> popCursor_{};
+};

Fifo3.hpp

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <atomic>
+#include <cstdlib>
+#include <memory>
+#include <new>
+
+
+/// Threadsafe, efficient circular FIFO
+template<typename T>
+class Fifo3
+{
+public:
+    using ValueType = T;
+
+    explicit Fifo3(std::size_t size)
+        : size_{size}
+        , 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_; }
+
+    bool push(T const& value) {
+        auto pushCursor = pushCursor_.load(std::memory_order_relaxed);
+        auto popCursor = popCursor_.load(std::memory_order_acquire);
+        if (full(pushCursor, popCursor)) {
+            return false;
+        }
+        new (&ring_[pushCursor % size_]) T(value);
+        pushCursor_.store(pushCursor + 1, std::memory_order_release);
+        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) {
+        auto pushCursor = pushCursor_.load(std::memory_order_acquire);
+        auto popCursor = popCursor_.load(std::memory_order_relaxed);
+        if (empty(pushCursor, popCursor)) {
+            return false;
+        }
+        value = ring_[popCursor % size_];
+        ring_[popCursor % size_].~T();
+        popCursor_.store(popCursor + 1, std::memory_order_release);
+        return true;
+    }
+
+private:
+    bool full(std::size_t pushCursor, std::size_t popCursor) const {
+        return (pushCursor - popCursor) == size_;
+    }
+    static bool empty(std::size_t pushCursor, std::size_t popCursor) {
+        return pushCursor == popCursor;
+    }
+
+private:
+    std::size_t size_;
+
+    using RingType = std::unique_ptr<ValueType[], decltype(&std::free)>;
+    RingType ring_;
+
+    // https://stackoverflow.com/questions/39680206/understanding-stdhardware-destructive-interference-size-and-stdhardware-cons
+    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_{};
+
+    /// Loaded and stored by the pop thread; loaded by the push thread
+    alignas(hardware_destructive_interference_size) std::atomic<std::size_t> popCursor_{};
+};

Fifo4.hpp

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <atomic>
+#include <cstdlib>
+#include <memory>
+#include <new>
+
+
+/// Threadsafe, efficient circular FIFO
+template<typename T>
+class Fifo4
+{
+public:
+    using ValueType = T;
+
+    explicit Fifo4(std::size_t size)
+        : size_{size}
+        , 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_; }
+
+    bool push(T const& value) {
+        auto pushCursor = pushCursor_.load(std::memory_order_relaxed);
+        if (full(pushCursor, popCursorCached_)) {
+            popCursorCached_ = popCursor_.load(std::memory_order_acquire);
+        }
+        if (full(pushCursor, popCursorCached_)) {
+            return false;
+        }
+
+        new (&ring_[pushCursor % size_]) T(value);
+        pushCursor_.store(pushCursor + 1, std::memory_order_release);
+        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) {
+        auto popCursor = popCursor_.load(std::memory_order_relaxed);
+        if (empty(pushCursorCached_, popCursor)) {
+            pushCursorCached_ = pushCursor_.load(std::memory_order_acquire);
+        }
+        if (empty(pushCursorCached_, popCursor)) {
+            return false;
+        }
+
+        value = ring_[popCursor % size_];
+        ring_[popCursor % size_].~T();
+        popCursor_.store(popCursor + 1, std::memory_order_release);
+        return true;
+    }
+
+private:
+    bool full(std::size_t pushCursor, std::size_t popCursor) const {
+        return (pushCursor - popCursor) == size_;
+    }
+    static bool empty(std::size_t pushCursor, std::size_t popCursor) {
+        return pushCursor == popCursor;
+    }
+
+private:
+    std::size_t size_;
+
+    using RingType = std::unique_ptr<ValueType[], decltype(&std::free)>;
+    RingType ring_;
+
+    // https://stackoverflow.com/questions/39680206/understanding-stdhardware-destructive-interference-size-and-stdhardware-cons
+    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
+    alignas(hardware_destructive_interference_size) std::size_t popCursorCached_{};
+
+    /// Loaded and stored by the pop thread; loaded by the push thread
+    alignas(hardware_destructive_interference_size) std::atomic<std::size_t> popCursor_;
+
+    /// Exclusive to the push thread
+    alignas(hardware_destructive_interference_size) std::size_t pushCursorCached_{};
+};