Skip to content

Commit

Permalink
improve SPSC readability and slight performance in real world usage (#40
Browse files Browse the repository at this point in the history 
)


* refactor SPSC for readability and removing unnecessary cache line usage
  • Loading branch information
@geseq
geseq authored Feb 29, 2024
1 parent 304d5f0 commit 9ac4d13
Show file tree
Hide file tree
Showing 9 changed files with 168 additions and 304 deletions.
4 changes: 2 additions & 2 deletions README.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,7 @@ If the size provided is not a power if 2, it's rounded up to the next power of 2
// SPSC
fastchan::SPSC<int, blockingType, chan_size> c;
// OR
fastchan::SPSC<int, blockingType, chan_size, fastchan::WaitSpin> c;
fastchan::SPSC<int, blockingType, chan_size, fastchan::WaitPause> c;

c.put(0);
c.put(1);
Expand All @@ -24,7 +24,7 @@ auto val = c.get();
// MPSC
fastchan::MPSC<int, blockingType, chan_size> c;
// OR
fastchan::MPSC<int, blockingType, chan_size, fastchan::WaitSpin> c;
fastchan::MPSC<int, blockingType, chan_size, fastchan::WaitPause> c;

c.put(0);
c.put(1);
Expand Down
242 changes: 29 additions & 213 deletions bench/fastchan_bench.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,190 +11,6 @@
#include "boost/lockfree/policies.hpp"
#include "boost/lockfree/spsc_queue.hpp"

template <size_t min_size>
static void SPSC_BlockingBoth_Put(benchmark::State& state) {
fastchan::SPSC<uint8_t, fastchan::BlockingPutBlockingGet, min_size> c;
std::atomic_bool shouldRun = true;
std::thread reader([&]() {
while (shouldRun) {
auto&& it = c.get();
}
});

// Code inside this loop is measured repeatedly
for (auto _ : state) {
c.put(0);
}
shouldRun = false;

// clear any blocks
c.put(0);

reader.join();
}

BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Put, 16);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Put, 64);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Put, 256);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Put, 1024);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Put, 4096);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Put, 16'384);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Put, 65'536);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Put, 262'144);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Put, 1'048'576);

template <size_t min_size>
static void SPSC_BlockingBoth_Get(benchmark::State& state) {
fastchan::SPSC<uint8_t, fastchan::BlockingPutBlockingGet, min_size> c;
std::atomic_bool shouldRun = true;
std::thread reader([&]() {
while (shouldRun) {
c.put(0);
}
});

// Code inside this loop is measured repeatedly
for (auto _ : state) {
auto&& it = c.get();
}
shouldRun.store(false);

// clear any blocks
c.get();
reader.join();
}

BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Get, 16);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Get, 64);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Get, 256);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Get, 1024);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Get, 4096);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Get, 16'384);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Get, 65'536);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Get, 262'144);
BENCHMARK_TEMPLATE(SPSC_BlockingBoth_Get, 1'048'576);

template <size_t min_size>
static void SPSC_NonBlockingGet_Put(benchmark::State& state) {
fastchan::SPSC<uint8_t, fastchan::BlockingPutNonBlockingGet, min_size> c;
std::atomic_bool shouldRun = true;
std::thread reader([&]() {
while (shouldRun) {
auto&& it = c.get();
}
});

// Code inside this loop is measured repeatedly
for (auto _ : state) {
c.put(0);
}
shouldRun = false;

// clear any blocks
c.put(0);

reader.join();
}

BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Put, 16);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Put, 64);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Put, 256);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Put, 1024);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Put, 4096);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Put, 16'384);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Put, 65'536);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Put, 262'144);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Put, 1'048'576);

template <size_t min_size>
static void SPSC_NonBlockingGet_Get(benchmark::State& state) {
fastchan::SPSC<uint8_t, fastchan::BlockingPutNonBlockingGet, min_size> c;
std::atomic_bool shouldRun = true;
std::thread reader([&]() {
while (shouldRun) {
c.put(0);
}
});

// Code inside this loop is measured repeatedly
for (auto _ : state) {
auto&& it = c.get();
}
shouldRun = false;

// clear any blocks
c.get();
reader.join();
}

BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Get, 16);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Get, 64);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Get, 256);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Get, 1024);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Get, 4096);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Get, 16'384);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Get, 65'536);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Get, 262'144);
BENCHMARK_TEMPLATE(SPSC_NonBlockingGet_Get, 1'048'576);

template <size_t min_size>
static void SPSC_NonBlockingBoth_Put(benchmark::State& state) {
fastchan::SPSC<uint8_t, fastchan::NonBlockingPutNonBlockingGet, min_size> c;
std::atomic_bool shouldRun = true;
std::thread reader([&]() {
while (shouldRun) {
auto&& it = c.get();
}
});

// Code inside this loop is measured repeatedly
for (auto _ : state) {
c.put(0);
}
shouldRun = false;

reader.join();
}

BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Put, 16);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Put, 64);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Put, 256);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Put, 1024);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Put, 4096);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Put, 16'384);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Put, 65'536);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Put, 262'144);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Put, 1'048'576);

template <size_t min_size>
static void SPSC_NonBlockingBoth_Get(benchmark::State& state) {
fastchan::SPSC<uint8_t, fastchan::NonBlockingPutNonBlockingGet, min_size> c;
std::atomic_bool shouldRun = true;
std::thread reader([&]() {
while (shouldRun) {
c.put(0);
}
});

// Code inside this loop is measured repeatedly
for (auto _ : state) {
auto&& it = c.get();
}
shouldRun = false;

reader.join();
}

BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Get, 16);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Get, 64);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Get, 256);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Get, 1024);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Get, 4096);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Get, 16'384);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Get, 65'536);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Get, 262'144);
BENCHMARK_TEMPLATE(SPSC_NonBlockingBoth_Get, 1'048'576);

template <size_t min_size>
static void BoostSPSC_Put(benchmark::State& state) {
boost::lockfree::spsc_queue<uint8_t, boost::lockfree::capacity<min_size>> c;
Expand Down Expand Up @@ -328,35 +144,35 @@ BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 65'536, 5, fastchan::WaitYield);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 262'144, 5, fastchan::WaitYield);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1'048'576, 5, fastchan::WaitYield);

BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16, 1, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 64, 1, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 256, 1, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1024, 1, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 4096, 1, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16'384, 1, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 65'536, 1, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 262'144, 1, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1'048'576, 1, fastchan::WaitSpin);

BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16, 2, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 64, 2, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 256, 2, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1024, 2, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 4096, 2, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16'384, 2, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 65'536, 2, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 262'144, 2, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1'048'576, 2, fastchan::WaitSpin);

BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16, 5, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 64, 5, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 256, 5, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1024, 5, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 4096, 5, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16'384, 5, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 65'536, 5, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 262'144, 5, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1'048'576, 5, fastchan::WaitSpin);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16, 1, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 64, 1, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 256, 1, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1024, 1, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 4096, 1, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16'384, 1, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 65'536, 1, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 262'144, 1, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1'048'576, 1, fastchan::WaitPause);

BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16, 2, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 64, 2, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 256, 2, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1024, 2, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 4096, 2, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16'384, 2, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 65'536, 2, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 262'144, 2, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1'048'576, 2, fastchan::WaitPause);

BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16, 5, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 64, 5, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 256, 5, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1024, 5, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 4096, 5, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16'384, 5, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 65'536, 5, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 262'144, 5, fastchan::WaitPause);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 1'048'576, 5, fastchan::WaitPause);

BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 16, 1, fastchan::WaitCondition);
BENCHMARK_TEMPLATE(MPSC_BlockingBoth_Put, 64, 1, fastchan::WaitCondition);
Expand Down
31 changes: 16 additions & 15 deletions bench/simple_bench.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -132,50 +132,51 @@ void run_spsc_benchmark_for_all_cpu_pairs(const std::string &name) {

int main() {
#if defined(__linux__)
run_spsc_benchmark_for_all_cpu_pairs<SPSC<int, BlockingPutBlockingGet, 32768, WaitSpin>>("SPSC_Spin");
run_spsc_benchmark_for_all_cpu_pairs<SPSC<int, 32768, PauseWaitStrategy, PauseWaitStrategy>>("SPSC_Pause");
run_spsc_benchmark_for_all_cpu_pairs<SPSC<int, 32768, NoOpWaitStrategy, NoOpWaitStrategy>>("SPSC_NoOp");

std::cout << "============================" << std::endl;

run_benchmark<SPSC<int, BlockingPutBlockingGet, 32768, WaitYield>>("SPSC_Yield", 1);
run_benchmark<SPSC<int, BlockingPutBlockingGet, 32768, WaitYield>>("SPSC_Yield", 1);
run_benchmark<SPSC<int, BlockingPutBlockingGet, 32768, WaitSpin>>("SPSC_Spin", 1);
run_benchmark<SPSC<int, BlockingPutBlockingGet, 32768, WaitSpin>>("SPSC_Spin", 1);
run_benchmark<SPSC<int, BlockingPutBlockingGet, 32768, WaitCondition>>("SPSC_Cond", 1);
run_benchmark<SPSC<int, BlockingPutBlockingGet, 32768, WaitCondition>>("SPSC_Cond", 1);
run_benchmark<SPSC<int, 32768, YieldWaitStrategy, YieldWaitStrategy>>("SPSC_Yield", 1);
run_benchmark<SPSC<int, 32768, YieldWaitStrategy, YieldWaitStrategy>>("SPSC_Yield", 1);
run_benchmark<SPSC<int, 32768, PauseWaitStrategy, PauseWaitStrategy>>("SPSC_Pause", 1);
run_benchmark<SPSC<int, 32768, PauseWaitStrategy, PauseWaitStrategy>>("SPSC_Pause", 1);
run_benchmark<SPSC<int, 32768, CVWaitStrategy, CVWaitStrategy>>("SPSC_Cond", 1);
run_benchmark<SPSC<int, 32768, CVWaitStrategy, CVWaitStrategy>>("SPSC_Cond", 1);

std::cout << "============================" << std::endl;

run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitYield>>("MPSC_Yield", 1);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitYield>>("MPSC_Yield", 1);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitSpin>>("MPSC_Spin", 1);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitSpin>>("MPSC_Spin", 1);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitPause>>("MPSC_Pause", 1);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitPause>>("MPSC_Pause", 1);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitCondition>>("MPSC_Cond", 1);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitCondition>>("MPSC_Cond", 1);

std::cout << "============================" << std::endl;

run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitYield>>("MPSC_Yield", 3);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitYield>>("MPSC_Yield", 3);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitSpin>>("MPSC_Spin", 3);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitSpin>>("MPSC_Spin", 3);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitPause>>("MPSC_Pause", 3);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitPause>>("MPSC_Pause", 3);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitCondition>>("MPSC_Cond", 3);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitCondition>>("MPSC_Cond", 3);

std::cout << "============================" << std::endl;

run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitYield>>("MPSC_Yield", 5);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitYield>>("MPSC_Yield", 5);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitSpin>>("MPSC_Spin", 5);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitSpin>>("MPSC_Spin", 5);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitPause>>("MPSC_Pause", 5);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitPause>>("MPSC_Pause", 5);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitCondition>>("MPSC_Cond", 5);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitCondition>>("MPSC_Cond", 5);

std::cout << "============================" << std::endl;

run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitYield>>("MPSC_Yield", 7);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitYield>>("MPSC_Yield", 7);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitSpin>>("MPSC_Spin", 7);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitSpin>>("MPSC_Spin", 7);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitPause>>("MPSC_Pause", 7);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitPause>>("MPSC_Pause", 7);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitCondition>>("MPSC_Cond", 7);
run_benchmark<MPSC<int, BlockingPutBlockingGet, 32768, WaitCondition>>("MPSC_Cond", 7);
;
Expand Down
2 changes: 1 addition & 1 deletion include/common.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ enum BlockingType {
};

enum WaitType {
WaitSpin,
WaitPause,
WaitYield,
WaitCondition,
WaitNoOp,
Expand Down
6 changes: 3 additions & 3 deletions include/mpsc.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ class MPSC {
} else if constexpr (wait_type == WaitCondition) {
std::unique_lock<std::mutex> lock(put_mutex_);
put_cv_.wait(lock, [this, write_index] { return write_index <= (reader_index_.load(std::memory_order_relaxed) + index_mask_); });
} else if constexpr (wait_type == WaitSpin) {
} else if constexpr (wait_type == WaitPause) {
cpu_pause();
}
} else {
Expand All @@ -42,7 +42,7 @@ class MPSC {
while (last_committed_index_.load(std::memory_order_relaxed) != write_index) {
if constexpr (wait_type == WaitYield) {
std::this_thread::yield();
} else if constexpr (wait_type == WaitSpin) {
} else if constexpr (wait_type == WaitPause) {
cpu_pause();
}
}
Expand All @@ -67,7 +67,7 @@ class MPSC {
} else if constexpr (wait_type == WaitCondition) {
std::unique_lock<std::mutex> lock(get_mutex_);
get_cv_.wait(lock, [this] { return reader_index_2_ < last_committed_index_.load(std::memory_order_relaxed); });
} else if constexpr (wait_type == WaitSpin) {
} else if constexpr (wait_type == WaitPause) {
cpu_pause();
}
} else {
Expand Down
Loading

0 comments on commit 9ac4d13

Please sign in to comment.