remove dead code (#260)

Author: tzcnt

.github/workflows/arm64-macos-clang-ubsan.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: macos-15
     strategy:
       matrix:
-        PRESET: [clang-macos-debug, clang-macos-release]
+        PRESET: [clang-macos-debug]
         WORK_ITEM: [CORO, FUNCORO]
     steps:
     - name: install-hwloc

include/tmc/detail/waiter_list.ipp

@@ -7,7 +7,6 @@
 
 #include "tmc/detail/impl.hpp" // IWYU pragma: keep
 
-#include "tmc/current.hpp"
 #include "tmc/detail/thread_locals.hpp"
 #include "tmc/detail/waiter_list.hpp"
 
@@ -44,9 +43,8 @@ void waiter_list_waiter::resume() noexcept {
   );
 }
 
-std::coroutine_handle<> waiter_list_waiter::try_symmetric_transfer(
-  std::coroutine_handle<> Outer
-) noexcept {
+std::coroutine_handle<>
+waiter_list_waiter::try_symmetric_transfer(std::coroutine_handle<> Outer) noexcept {
   if (tmc::detail::this_thread::exec_prio_is(
         continuation_executor, continuation_priority
       )) {
@@ -81,8 +79,8 @@ reverse_chain(tmc::detail::waiter_list_node* curr) noexcept {
 } // namespace
 
 std::coroutine_handle<> try_symmetric_transfer2_waiter(
-  waiter_list_waiter* ToWake, std::coroutine_handle<> Continuation,
-  tmc::ex_any* Executor, size_t Priority
+  waiter_list_waiter* ToWake, std::coroutine_handle<> Continuation, tmc::ex_any* Executor,
+  size_t Priority
 ) noexcept {
   if (ToWake != nullptr) {
     std::coroutine_handle<> toContinuation = ToWake->continuation;
@@ -97,9 +95,7 @@ std::coroutine_handle<> try_symmetric_transfer2_waiter(
     }
 
     // Transfer to primary disallowed
-    tmc::detail::post_checked(
-      toExecutor, std::move(toContinuation), toPriority
-    );
+    tmc::detail::post_checked(toExecutor, std::move(toContinuation), toPriority);
   }
 
   if (Continuation != nullptr) {
@@ -119,8 +115,7 @@ void waiter_list::configure_and_add_waiter(
 ) noexcept {
   Node.waiter.continuation = Outer;
   Node.waiter.continuation_executor = tmc::detail::this_thread::executor();
-  Node.waiter.continuation_priority =
-    tmc::detail::this_thread::this_task().prio;
+  Node.waiter.continuation_priority = tmc::detail::this_thread::this_task().prio;
 
   auto h = input.load(std::memory_order_acquire);
   do {
@@ -298,9 +293,7 @@ bool try_acquire(std::atomic<size_t>& Value) noexcept {
 } // namespace detail
 
 bool aw_acquire::await_ready() noexcept {
-  return tmc::detail::try_acquire(
-    parent.load(std::memory_order_relaxed)->value
-  );
+  return tmc::detail::try_acquire(parent.load(std::memory_order_relaxed)->value);
 }
 
 void aw_acquire::await_suspend(std::coroutine_handle<> Outer) noexcept {

include/tmc/qu_mpsc_unbounded.hpp

@@ -67,8 +67,7 @@ class qu_mpsc_unbounded {
   static inline constexpr size_t BlockSizeMask = BlockSize - 1;
   static inline constexpr bool ConsumerCanSuspend = Config::ConsumerCanSuspend;
   static_assert(
-    BlockSize && ((BlockSize & (BlockSize - 1)) == 0),
-    "BlockSize must be a power of 2"
+    BlockSize && ((BlockSize & (BlockSize - 1)) == 0), "BlockSize must be a power of 2"
   );
 
   // Ensure that the subtraction of unsigned offsets always results in a value
@@ -102,16 +101,14 @@ class qu_mpsc_unbounded {
 
     static constexpr size_t UNPADLEN =
       sizeof(std::atomic<void*>) + sizeof(tmc::detail::qu_storage<T>);
-    static constexpr size_t WANTLEN = (UNPADLEN + TMC_CACHE_LINE_SIZE - 1) &
-                                      static_cast<size_t>(
-                                        0 - TMC_CACHE_LINE_SIZE
-                                      ); // round up to TMC_CACHE_LINE_SIZE
-    static constexpr size_t PADLEN =
-      UNPADLEN < WANTLEN ? (WANTLEN - UNPADLEN) : 999;
+    static constexpr size_t WANTLEN =
+      (UNPADLEN + TMC_CACHE_LINE_SIZE - 1) &
+      static_cast<size_t>(0 - TMC_CACHE_LINE_SIZE); // round up to TMC_CACHE_LINE_SIZE
+    static constexpr size_t PADLEN = UNPADLEN < WANTLEN ? (WANTLEN - UNPADLEN) : 999;
 
     struct empty {};
-    using Padding = std::conditional_t<
-      Config::PackingLevel == 0 && PADLEN != 999, char[PADLEN], empty>;
+    using Padding =
+      std::conditional_t<Config::PackingLevel == 0 && PADLEN != 999, char[PADLEN], empty>;
     TMC_NO_UNIQUE_ADDRESS Padding pad;
 
     // Attempts to install Cons as a waiting consumer.
@@ -130,9 +127,8 @@ class qu_mpsc_unbounded {
     consumer_base* set_data_ready_or_get_waiting_consumer() noexcept
       requires(ConsumerCanSuspend)
     {
-      void* prev = flags.exchange(
-        reinterpret_cast<void*>(DATA_BIT), std::memory_order_acq_rel
-      );
+      void* prev =
+        flags.exchange(reinterpret_cast<void*>(DATA_BIT), std::memory_order_acq_rel);
       return static_cast<consumer_base*>(prev);
     }
 
@@ -146,9 +142,8 @@ class qu_mpsc_unbounded {
     // waiting, its consumer_base pointer is returned so the caller can wake it.
     // Used only by close() to mark the cutoff slot.
     consumer_base* set_closed_or_get_waiting_consumer() noexcept {
-      void* prev = flags.exchange(
-        reinterpret_cast<void*>(CLOSED_BIT), std::memory_order_acq_rel
-      );
+      void* prev =
+        flags.exchange(reinterpret_cast<void*>(CLOSED_BIT), std::memory_order_acq_rel);
       if (reinterpret_cast<uintptr_t>(prev) < 4) {
         return nullptr;
       }
@@ -160,11 +155,6 @@ class qu_mpsc_unbounded {
       return DATA_BIT == reinterpret_cast<uintptr_t>(f);
     }
 
-    bool is_closed_sentinel() noexcept {
-      void* f = flags.load(std::memory_order_acquire);
-      return CLOSED_BIT == reinterpret_cast<uintptr_t>(f);
-    }
-
     // Returns the raw flags value: DATA_BIT, CLOSED_BIT, or 0 (meaning empty).
     uintptr_t poll() noexcept {
       return reinterpret_cast<uintptr_t>(flags.load(std::memory_order_acquire));
@@ -218,8 +208,7 @@ class qu_mpsc_unbounded {
   char pad2[TMC_CACHE_LINE_SIZE - sizeof(void*)];
 
   struct empty {};
-  using EmbeddedBlock =
-    std::conditional_t<Config::EmbedFirstBlock, data_block, empty>;
+  using EmbeddedBlock = std::conditional_t<Config::EmbedFirstBlock, data_block, empty>;
   TMC_NO_UNIQUE_ADDRESS EmbeddedBlock embedded_block;
 
 public:
@@ -261,8 +250,8 @@ class qu_mpsc_unbounded {
     try_pull_zc_scope& operator=(const try_pull_zc_scope&) = delete;
 
     try_pull_zc_scope(try_pull_zc_scope&& Other) noexcept
-        : queue{Other.queue}, elem{Other.elem}, block{Other.block},
-          idx{Other.idx}, err{Other.err} {
+        : queue{Other.queue}, elem{Other.elem}, block{Other.block}, idx{Other.idx},
+          err{Other.err} {
       Other.elem = nullptr;
       Other.err = tmc::qu_mpsc_unbounded_err::EMPTY;
     }
@@ -335,15 +324,13 @@ class qu_mpsc_unbounded {
 
   public:
     /// Constructs an empty scope. Evaluates to false when converted to bool.
-    pull_zc_scope() noexcept
-        : queue{nullptr}, elem{nullptr}, block{nullptr}, idx{0} {}
+    pull_zc_scope() noexcept : queue{nullptr}, elem{nullptr}, block{nullptr}, idx{0} {}
 
     pull_zc_scope(const pull_zc_scope&) = delete;
     pull_zc_scope& operator=(const pull_zc_scope&) = delete;
 
     pull_zc_scope(pull_zc_scope&& Other) noexcept
-        : queue{Other.queue}, elem{Other.elem}, block{Other.block},
-          idx{Other.idx} {
+        : queue{Other.queue}, elem{Other.elem}, block{Other.block}, idx{Other.idx} {
       Other.elem = nullptr;
     }
 
@@ -447,23 +434,19 @@ class qu_mpsc_unbounded {
       }
       // Actually unlink the blocks from the head of the queue.
       // They stay linked to each other.
-      unlinked[unlinkedCount - 1]->next.store(
-        nullptr, std::memory_order_release
-      );
+      unlinked[unlinkedCount - 1]->next.store(nullptr, std::memory_order_release);
 
       while (true) {
         // Update their offsets to the end of the queue.
-        size_t boff =
-          tailBlock->offset.load(std::memory_order_relaxed) + BlockSize;
+        size_t boff = tailBlock->offset.load(std::memory_order_relaxed) + BlockSize;
         for (size_t i = 0; i < unlinkedCount; ++i) {
           unlinked[i]->offset.store(boff, std::memory_order_relaxed);
           boff += BlockSize;
         }
 
         // Re-link the tail of the queue to the head of the unlinked blocks.
         if (tailBlock->next.compare_exchange_strong(
-              next, unlinked[0], std::memory_order_acq_rel,
-              std::memory_order_acquire
+              next, unlinked[0], std::memory_order_acq_rel, std::memory_order_acquire
             )) {
           break;
         }
@@ -490,8 +473,7 @@ class qu_mpsc_unbounded {
       if (next == nullptr) {
         data_block* newBlock = new data_block(offset + BlockSize);
         if (Block->next.compare_exchange_strong(
-              next, newBlock, std::memory_order_acq_rel,
-              std::memory_order_acquire
+              next, newBlock, std::memory_order_acq_rel, std::memory_order_acquire
             )) {
           next = newBlock;
         } else {
@@ -512,18 +494,15 @@ class qu_mpsc_unbounded {
 
   static inline bool block_before(data_block* A, data_block* B) noexcept {
     return circular_less_than(
-      A->offset.load(std::memory_order_relaxed),
-      B->offset.load(std::memory_order_relaxed)
+      A->offset.load(std::memory_order_relaxed), B->offset.load(std::memory_order_relaxed)
     );
   }
 
-  void advance_write_block_hint_at_least(
-    data_block* Current, data_block* Target
-  ) noexcept {
+  void
+  advance_write_block_hint_at_least(data_block* Current, data_block* Target) noexcept {
     while (block_before(Current, Target)) {
       if (write_block_hint.compare_exchange_weak(
-            Current, Target, std::memory_order_seq_cst,
-            std::memory_order_seq_cst
+            Current, Target, std::memory_order_seq_cst, std::memory_order_seq_cst
           )) {
         return;
       }
@@ -538,16 +517,12 @@ class qu_mpsc_unbounded {
 
   data_block* get_mpsc_write_start_block(size_t Idx) noexcept {
     data_block* block = write_block_hint.load(std::memory_order_seq_cst);
-    if (!circular_less_than(
-          block->offset.load(std::memory_order_relaxed), 1 + Idx
-        )) {
+    if (!circular_less_than(block->offset.load(std::memory_order_relaxed), 1 + Idx)) {
       // A later producer may have advanced the hint past this producer's
       // earlier reservation. Fall back to the consumer-managed reclaim
       // frontier, which cannot advance past an unproduced reservation.
       block = write_block.load(std::memory_order_seq_cst);
-      assert(circular_less_than(
-        block->offset.load(std::memory_order_relaxed), 1 + Idx
-      ));
+      assert(circular_less_than(block->offset.load(std::memory_order_relaxed), 1 + Idx));
     }
     return block;
   }
@@ -626,18 +601,14 @@ class qu_mpsc_unbounded {
       while (!closed_ready.load(std::memory_order_acquire)) {
         TMC_CPU_PAUSE();
       }
-      if (circular_less_than(
-            write_closed_at.load(std::memory_order_acquire), 1 + Idx
-          )) {
+      if (circular_less_than(write_closed_at.load(std::memory_order_acquire), 1 + Idx)) {
         return nullptr;
       }
     }
 
     data_block* observed = get_mpsc_write_start_block(Idx);
 
-    assert(circular_less_than(
-      observed->offset.load(std::memory_order_relaxed), 1 + Idx
-    ));
+    assert(circular_less_than(observed->offset.load(std::memory_order_relaxed), 1 + Idx));
 
     data_block* block = find_block(observed, Idx);
     advance_write_block_hint_at_least(observed, block);
@@ -649,9 +620,7 @@ class qu_mpsc_unbounded {
     Idx = read_offset;
     Block = read_block;
 
-    assert(
-      circular_less_than(Block->offset.load(std::memory_order_relaxed), 1 + Idx)
-    );
+    assert(circular_less_than(Block->offset.load(std::memory_order_relaxed), 1 + Idx));
 
     Block = find_block(Block, Idx);
     return &Block->values[Idx & BlockSizeMask];
@@ -671,8 +640,7 @@ class qu_mpsc_unbounded {
   }
 
   template <typename... Args>
-  consumer_base*
-  write_element(element* Elem, Args&&... ConstructArgs) noexcept {
+  consumer_base* write_element(element* Elem, Args&&... ConstructArgs) noexcept {
     Elem->data.emplace(static_cast<Args&&>(ConstructArgs)...);
     if constexpr (ConsumerCanSuspend) {
       return Elem->set_data_ready_or_get_waiting_consumer();
@@ -697,9 +665,8 @@ class qu_mpsc_unbounded {
   // that case. Because close() takes a single fetch_add cutoff, a bulk
   // reservation cannot straddle the cutoff: it is either all pre-close or
   // all post-close in the seq_cst total order on write_offset.
-  data_block* get_write_ticket_bulk(
-    size_t Count, size_t& StartIdx, size_t& EndIdx
-  ) noexcept {
+  data_block*
+  get_write_ticket_bulk(size_t Count, size_t& StartIdx, size_t& EndIdx) noexcept {
     // seq_cst here serves the same purpose as in get_write_ticket: it orders
     // the reader's reclaim cutoff AND forms the producer side of the close
     // protocol (RMW-chain from close()'s release store to `closed`).
@@ -719,9 +686,9 @@ class qu_mpsc_unbounded {
 
     data_block* observed = get_mpsc_write_start_block(StartIdx);
 
-    assert(circular_less_than(
-      observed->offset.load(std::memory_order_relaxed), 1 + StartIdx
-    ));
+    assert(
+      circular_less_than(observed->offset.load(std::memory_order_relaxed), 1 + StartIdx)
+    );
 
     // Ensure all blocks for the operation are allocated and available.
     data_block* startBlock = find_block(observed, StartIdx);
@@ -753,8 +720,7 @@ class qu_mpsc_unbounded {
       return false;
     }
 
-    consumer_base* cons =
-      write_element(elem, static_cast<Args&&>(ConstructArgs)...);
+    consumer_base* cons = write_element(elem, static_cast<Args&&>(ConstructArgs)...);
     notify_consumer(cons);
     return true;
   }
@@ -777,9 +743,7 @@ class qu_mpsc_unbounded {
     // Implementing handling for throwing construction is not possible with the
     // current design. This assert will also fire if no matching constructor can
     // be found for the iterator's dereferenced value.
-    static_assert(
-      std::is_nothrow_constructible_v<T, decltype(std::move(*Items))>
-    );
+    static_assert(std::is_nothrow_constructible_v<T, decltype(std::move(*Items))>);
 
     if (Count == 0) [[unlikely]] {
       return true;
@@ -832,12 +796,8 @@ class qu_mpsc_unbounded {
     // Implementing handling for throwing construction is not possible with the
     // current design. This assert will also fire if no matching constructor can
     // be found for the iterator's dereferenced value.
-    static_assert(
-      std::is_nothrow_constructible_v<T, decltype(std::move(*Begin))>
-    );
-    return post_bulk(
-      static_cast<It&&>(Begin), static_cast<size_t>(End - Begin)
-    );
+    static_assert(std::is_nothrow_constructible_v<T, decltype(std::move(*Begin))>);
+    return post_bulk(static_cast<It&&>(Begin), static_cast<size_t>(End - Begin));
   }
 
   /// Calculates the number of elements via