Clang format everywhere

Author: toshit3q34

include/FAST_lockfree_spsc_unbounded/block.hpp

@@ -5,57 +5,52 @@
 #include "slots.hpp"
 #include <atomic>
 
-namespace tsfqueue::impl{
-    template <typename T> 
-    class Block_FAST{
-    private:
-        using Slot_FAST = tsfqueue::FAST::Slot_FAST;
-        std::size_t capacity;
-        std::size_t mask;
-        char* raw;
-        char* data;
-        std::unique_ptr<Slot_FAST> slots;
-        template<typename U>
-        void inner_enqueue(U&& data){
+namespace tsfqueue::impl {
+template <typename T> class Block_FAST {
+private:
+  using Slot_FAST = tsfqueue::FAST::Slot_FAST;
+  std::size_t capacity;
+  std::size_t mask;
+  char *raw;
+  char *data;
+  std::unique_ptr<Slot_FAST> slots;
+  template <typename U> void inner_enqueue(U &&data) {}
 
-        }
-    public:
-        Block_FAST(std::size_t cap){
-            // Initialize by bringing it to the closest power of 2
-            // And then make mask
-            slots(static_cast<int>(cap));
-        }
-        ~Block_FAST(){
-            // Make destructor
-        }
-        Block_FAST(const Block_FAST& other) = delete;
-        Block_FAST& operator=(const Block_FAST& other) = delete;
-        Block_FAST(Block_FAST&& other){
-            // Move constructor
-        }
-        template<typename U>
-        bool try_enqueue(U&& data){
-            // Try to check if can push
-            if(slots->try_get()){
-                inner_enqueue(std::forward<U>(data));
-                return true;
-            }
-            return false;
-        }
-        template <typename U>
-        void wait_enqueue(U&& data){
-            slots->wait_and_get();
-            inner_enqueue(std::forward<U>(data));
-        }
-        template <typename U>
-        bool wait_enqueue_timed(U&& data, std::int64_t time_usecs){
-            if(slots->timed_get(time_usecs)){
-                inner_enqueue(std::forward<U>(data));
-                return true;
-            }
-            return false;
-        }
-    };
-}
+public:
+  Block_FAST(std::size_t cap) {
+    // Initialize by bringing it to the closest power of 2
+    // And then make mask
+    slots(static_cast<int>(cap));
+  }
+  ~Block_FAST() {
+    // Make destructor
+  }
+  Block_FAST(const Block_FAST &other) = delete;
+  Block_FAST &operator=(const Block_FAST &other) = delete;
+  Block_FAST(Block_FAST &&other) {
+    // Move constructor
+  }
+  template <typename U> bool try_enqueue(U &&data) {
+    // Try to check if can push
+    if (slots->try_get()) {
+      inner_enqueue(std::forward<U>(data));
+      return true;
+    }
+    return false;
+  }
+  template <typename U> void wait_enqueue(U &&data) {
+    slots->wait_and_get();
+    inner_enqueue(std::forward<U>(data));
+  }
+  template <typename U>
+  bool wait_enqueue_timed(U &&data, std::int64_t time_usecs) {
+    if (slots->timed_get(time_usecs)) {
+      inner_enqueue(std::forward<U>(data));
+      return true;
+    }
+    return false;
+  }
+};
+} // namespace tsfqueue::impl
 
 #endif

include/FAST_lockfree_spsc_unbounded/slots.hpp

@@ -4,103 +4,99 @@
 #include "../utils.hpp"
 #include <atomic>
 
-namespace tsfqueue::FAST{
+namespace tsfqueue::FAST {
 #if defined(__MACH__)
 #include <mach/mach.h>
-    class Semaphore_FAST{
-    private:
-        semaphore_t sema;
-        Semaphore_FAST(const Semaphore& other) = delete;
-        Semaphore_FAST(Semaphore&& other) = delete;
-    public:
-        Semaphore_FAST(int count = 0){
-            assert(count >= 0);
-            kern_return_t ret = semaphore_create(mach_task_self(), &sema, SYNC_POLICY_FIFO, count);
-            assert(ret == KERN_SUCCESS);
-        }
-        ~Semaphore_FAST(){
-            semaphore_destroy(mach_task_self(), sema);
-        }
-        bool try_get(){
-            return timed_get(0);
-        }
-        bool timed_get(std::uint64_t time_usecs){
-            mach_timespec_t time;
-            time.tv_sec = static_cast<unsigned int>(time_usecs / 1000000);
-			time.tv_nsec = static_cast<int>((time_usecs % 1000000) * 1000);
-            kern_return_t ret = semaphore_timedwait(sema, time);
-            return ret == KERN_SUCCESS;
-        }
-        void wait_and_get(){
-            semaphore_wait(sema);
-        }
-        void signal(int times = 1){
-            while(times--)
-                while(semaphore_signal(sema) != KERN_SUCCESS);
-        }
-    };
+class Semaphore_FAST {
+private:
+  semaphore_t sema;
+  Semaphore_FAST(const Semaphore &other) = delete;
+  Semaphore_FAST(Semaphore &&other) = delete;
+
+public:
+  Semaphore_FAST(int count = 0) {
+    assert(count >= 0);
+    kern_return_t ret =
+        semaphore_create(mach_task_self(), &sema, SYNC_POLICY_FIFO, count);
+    assert(ret == KERN_SUCCESS);
+  }
+  ~Semaphore_FAST() { semaphore_destroy(mach_task_self(), sema); }
+  bool try_get() { return timed_get(0); }
+  bool timed_get(std::uint64_t time_usecs) {
+    mach_timespec_t time;
+    time.tv_sec = static_cast<unsigned int>(time_usecs / 1000000);
+    time.tv_nsec = static_cast<int>((time_usecs % 1000000) * 1000);
+    kern_return_t ret = semaphore_timedwait(sema, time);
+    return ret == KERN_SUCCESS;
+  }
+  void wait_and_get() { semaphore_wait(sema); }
+  void signal(int times = 1) {
+    while (times--)
+      while (semaphore_signal(sema) != KERN_SUCCESS)
+        ;
+  }
+};
 #endif
 
+class Slot_FAST {
+private:
+  std::atomic<int> counter;
+  Semaphore_FAST sema;
+  static constexpr int SPIN_COUNT =
+      1024; // Change this for benchmakrs & set to best possible
+  inline bool hot_path() {
+    for (int i = 0; i < SPIN_COUNT; i++) {
+      if (counter.load(std::memory_order_acquire) > 0) {
+        counter.fetch_sub(1);
+        return true;
+      }
+    }
+    return false;
+  }
+  bool get_with_sleep(std::int64_t time_usecs = -1) {
+    if (hot_path())
+      return true;
+    counter.fetch_sub(1);
+    if (time_usecs < 0) {
+      sema.wait_and_get() return true;
+    }
+    if (sema.timed_get(static_cast<std::uint64_t>(time_usecs))) {
+      return true;
+    }
 
-    class Slot_FAST{
-    private:
-        std::atomic<int> counter;
-        Semaphore_FAST sema;
-        static constexpr int SPIN_COUNT = 1024; // Change this for benchmakrs & set to best possible
-        inline bool hot_path(){
-            for (int i = 0; i < SPIN_COUNT; i++){
-                if(counter.load(std::memory_order_acquire) > 0){
-                    counter.fetch_sub(1);
-                    return true;
-                }
-            }
-            return false;
-        }
-        bool get_with_sleep(std::int64_t time_usecs = -1){
-            if(hot_path()) return true;
-            counter.fetch_sub(1);
-            if(time_usecs < 0){
-                sema.wait_and_get()
-                return true;
-            }
-            if(sema.timed_get(static_cast<std::uint64_t>(time_usecs))){
-                return true;
-            }
+    // Restore the semaphore
+    // Signal happened just after timeout expired
+    // Thus we add a while loop which keeps checking until all boundary
+    // conditions are gone. Super clever.
+    while (true) {
+      int old = counter.fetch_add(1);
+      if (old < 0)
+        return false; // Restored successfully
+      old = counter.fetch_sub(1);
+      if (old > 0 && sema.try_get()) {
+        return true;
+      }
+    }
+  }
 
-            // Restore the semaphore
-            // Signal happened just after timeout expired
-            // Thus we add a while loop which keeps checking until all boundary conditions
-            // are gone. Super clever. 
-            while(true){
-                int old = counter.fetch_add(1);
-                if(old < 0) return false; // Restored successfully
-                old = counter.fetch_sub(1);
-                if(old > 0 && sema.try_get()){
-                    return true;
-                }
-            }
-        }
-    public:
-        Slot_FAST(int count) : counter(count), sema(0) {}
-        bool try_get(){
-            // Ok since SPSC so counter cannot be decremented between load and fetch_sub
-            if(counter.load(std::memory_order_acquire) > 0){
-                counter.fetch_sub(1);
-                return true;
-            }
-            return false;
-        }
-        bool timed_get(std::int64_t time_usecs){
-            return get_with_sleep(time_usecs);
-        }
-        void wait_and_get(){
-            return get_with_sleep();
-        }
-        void signal(int times = 1){
-            int old = counter.fetch_add(1);
-            if(old < 0) sema.signal();
-        }
+public:
+  Slot_FAST(int count) : counter(count), sema(0) {}
+  bool try_get() {
+    // Ok since SPSC so counter cannot be decremented between load and fetch_sub
+    if (counter.load(std::memory_order_acquire) > 0) {
+      counter.fetch_sub(1);
+      return true;
     }
-};
+    return false;
+  }
+  bool timed_get(std::int64_t time_usecs) { return get_with_sleep(time_usecs); }
+  void wait_and_get() { return get_with_sleep(); }
+  void signal(int times = 1) {
+    int old = counter.fetch_add(1);
+    if (old < 0)
+      sema.signal();
+  }
+}
+}; // namespace tsfqueue::FAST
 
 #endif

include/blocking_mpmc_unbounded/impl.hpp

@@ -44,7 +44,8 @@ template <typename T> void blocking_mpmc_unbounded<T>::push(T value) {
 }
 
 template <typename T>
-std::unique_ptr<typename blocking_mpmc_unbounded<T>::node> blocking_mpmc_unbounded<T>::wait_and_get() {
+std::unique_ptr<typename blocking_mpmc_unbounded<T>::node>
+blocking_mpmc_unbounded<T>::wait_and_get() {
   // Locking the head mutex
   std::unique_lock<std::mutex> head_lock(head_mutex);
 
@@ -65,7 +66,8 @@ std::unique_ptr<typename blocking_mpmc_unbounded<T>::node> blocking_mpmc_unbound
 }
 
 template <typename T>
-std::unique_ptr<typename blocking_mpmc_unbounded<T>::node> blocking_mpmc_unbounded<T>::try_get() {
+std::unique_ptr<typename blocking_mpmc_unbounded<T>::node>
+blocking_mpmc_unbounded<T>::try_get() {
   std::lock_guard<std::mutex> guard_head_mutex(head_mutex);
   if (size() > 0) {
     std::unique_ptr<node> removing_node = std::move(head);
@@ -216,7 +218,8 @@ std::shared_ptr<T> blocking_mpmc_unbounded<T>::unsafe_peek() {
 }
 
 template <typename T>
-std::unique_ptr<typename blocking_mpmc_unbounded<T>::node> blocking_mpmc_unbounded<T>::wait_for_and_get(
+std::unique_ptr<typename blocking_mpmc_unbounded<T>::node>
+blocking_mpmc_unbounded<T>::wait_for_and_get(
     std::chrono::milliseconds timeout) {
   // Using unique_lock to lock and unlock on our will.
   std::unique_lock<std::mutex> lock_head(head_mutex);