Add B variant stress tests for MPMC and SPSC modes

Author: Maxim Egorushkin

include/atomic_queue/atomic_queue.h

@@ -649,6 +649,15 @@ struct RetryDecorator : Queue {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+template<class Queue, size_t Capacity>
+struct CapacityArgDecorator : Queue {
+    CapacityArgDecorator()
+        : Queue(Capacity)
+    {}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 } // namespace atomic_queue
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

src/benchmarks.cc

@@ -129,14 +129,6 @@ struct TbbAdapter : RetryDecorator<Queue> {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-template<class Queue, size_t Capacity>
-struct CapacityToConstructor : Queue {
-    CapacityToConstructor()
-        : Queue(Capacity) {}
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
 using Allocator = HugePageAllocator<unsigned>;
 using BoostAllocator = boost::lockfree::allocator<Allocator>;
 
@@ -160,14 +152,14 @@ struct QueueTypes {
     // For atomic elements only.
     using AtomicQueue =                                Type<RetryDecorator<atomic_queue::AtomicQueue<T, SIZE, T{}, MINIMIZE_CONTENTION, MAXIMIZE_THROUGHPUT, false, SPSC>>>;
     using OptimistAtomicQueue =                                       Type<atomic_queue::AtomicQueue<T, SIZE, T{}, MINIMIZE_CONTENTION, MAXIMIZE_THROUGHPUT, false, SPSC>>;
-    using AtomicQueueB =        Type<RetryDecorator<CapacityToConstructor<atomic_queue::AtomicQueueB<T, Allocator, T{}, MAXIMIZE_THROUGHPUT, false, SPSC>, SIZE>>>;
-    using OptimistAtomicQueueB =               Type<CapacityToConstructor<atomic_queue::AtomicQueueB<T, Allocator, T{}, MAXIMIZE_THROUGHPUT, false, SPSC>, SIZE>>;
+    using AtomicQueueB =        Type<RetryDecorator<CapacityArgDecorator<atomic_queue::AtomicQueueB<T, Allocator, T{}, MAXIMIZE_THROUGHPUT, false, SPSC>, SIZE>>>;
+    using OptimistAtomicQueueB =               Type<CapacityArgDecorator<atomic_queue::AtomicQueueB<T, Allocator, T{}, MAXIMIZE_THROUGHPUT, false, SPSC>, SIZE>>;
 
     // For non-atomic elements.
     using AtomicQueue2 =                         Type<RetryDecorator<atomic_queue::AtomicQueue2<T, SIZE, MINIMIZE_CONTENTION, MAXIMIZE_THROUGHPUT, false, SPSC>>>;
     using OptimistAtomicQueue2 =                                Type<atomic_queue::AtomicQueue2<T, SIZE, MINIMIZE_CONTENTION, MAXIMIZE_THROUGHPUT, false, SPSC>>;
-    using AtomicQueueB2 = Type<RetryDecorator<CapacityToConstructor<atomic_queue::AtomicQueueB2<T, Allocator, MAXIMIZE_THROUGHPUT, false, SPSC>, SIZE>>>;
-    using OptimistAtomicQueueB2 =        Type<CapacityToConstructor<atomic_queue::AtomicQueueB2<T, Allocator, MAXIMIZE_THROUGHPUT, false, SPSC>, SIZE>>;
+    using AtomicQueueB2 = Type<RetryDecorator<CapacityArgDecorator<atomic_queue::AtomicQueueB2<T, Allocator, MAXIMIZE_THROUGHPUT, false, SPSC>, SIZE>>>;
+    using OptimistAtomicQueueB2 =        Type<CapacityArgDecorator<atomic_queue::AtomicQueueB2<T, Allocator, MAXIMIZE_THROUGHPUT, false, SPSC>, SIZE>>;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -354,7 +346,7 @@ void run_throughput_benchmarks(HugePages& hp, std::vector<CpuTopologyInfo> const
     run_throughput_mpmc_benchmark("xenium::ramalhete_queue", hp, hw_thread_ids,
         Type<XeniumQueueAdapter<xenium::ramalhete_queue<unsigned, xenium::policy::reclaimer<Reclaimer>>>>{});
     run_throughput_mpmc_benchmark("xenium::vyukov_bounded_queue", hp, hw_thread_ids,
-        Type<RetryDecorator<CapacityToConstructor<xenium::vyukov_bounded_queue<unsigned>, SIZE>>>{});
+        Type<RetryDecorator<CapacityArgDecorator<xenium::vyukov_bounded_queue<unsigned>, SIZE>>>{});
 
     using SPSC = QueueTypes<SIZE, true, false, false>;
     using MPMC = QueueTypes<SIZE, false, true, true>; // Enable MAXIMIZE_THROUGHPUT for 2 or more producers/consumers.
@@ -501,7 +493,7 @@ void run_ping_pong_benchmarks(HugePages& hp, std::vector<CpuTopologyInfo> const&
 
     run_ping_pong_benchmark<XeniumQueueAdapter<xenium::michael_scott_queue<unsigned, xenium::policy::reclaimer<Reclaimer>>>>("xenium::michael_scott_queue", hp, hw_thread_ids);
     run_ping_pong_benchmark<XeniumQueueAdapter<xenium::ramalhete_queue<unsigned, xenium::policy::reclaimer<Reclaimer>>>>("xenium::ramalhete_queue", hp, hw_thread_ids);
-    run_ping_pong_benchmark<RetryDecorator<CapacityToConstructor<xenium::vyukov_bounded_queue<unsigned>, SIZE>>>("xenium::vyukov_bounded_queue", hp, hw_thread_ids);
+    run_ping_pong_benchmark<RetryDecorator<CapacityArgDecorator<xenium::vyukov_bounded_queue<unsigned>, SIZE>>>("xenium::vyukov_bounded_queue", hp, hw_thread_ids);
 
     // Use MAXIMIZE_THROUGHPUT=false for better latency.
     using SPSC = QueueTypes<SIZE, true, false, false>;

src/tests.cc

@@ -188,6 +188,37 @@ BOOST_AUTO_TEST_CASE(spsc_stress_OptimistAtomicQueue2) {
     stress<AtomicQueue2<unsigned, CAPACITY, true, true, false, true>, 1, 1>();
 }
 
+BOOST_AUTO_TEST_CASE(stress_AtomicQueueB) {
+    stress<RetryDecorator<CapacityArgDecorator<AtomicQueueB<unsigned>, CAPACITY>>>();
+}
+
+BOOST_AUTO_TEST_CASE(stress_OptimistAtomicQueueB) {
+    stress<CapacityArgDecorator<AtomicQueueB<unsigned>, CAPACITY>>();
+}
+
+BOOST_AUTO_TEST_CASE(stress_AtomicQueueB2) {
+    stress<RetryDecorator<CapacityArgDecorator<AtomicQueueB2<unsigned>, CAPACITY>>>();
+}
+
+BOOST_AUTO_TEST_CASE(stress_OptimistAtomicQueueB2) {
+    stress<CapacityArgDecorator<AtomicQueueB2<unsigned>, CAPACITY>>();
+}
+
+BOOST_AUTO_TEST_CASE(spsc_stress_AtomicQueueB) {
+    stress<RetryDecorator<CapacityArgDecorator<AtomicQueueB<unsigned, std::allocator<unsigned>, 0u, true, false, true>, CAPACITY>>, 1, 1>();
+}
+
+BOOST_AUTO_TEST_CASE(spsc_stress_OptimistAtomicQueueB) {
+    stress<CapacityArgDecorator<AtomicQueueB<unsigned, std::allocator<unsigned>, 0u, true, false, true>, CAPACITY>, 1, 1>();
+}
+
+BOOST_AUTO_TEST_CASE(spsc_stress_AtomicQueueB2) {
+    stress<RetryDecorator<CapacityArgDecorator<AtomicQueueB2<unsigned, std::allocator<unsigned>, true, false, true>, CAPACITY>>, 1, 1>();
+}
+
+BOOST_AUTO_TEST_CASE(spsc_stress_OptimistAtomicQueueB2) {
+    stress<CapacityArgDecorator<AtomicQueueB2<unsigned, std::allocator<unsigned>, true, false, true>, CAPACITY>, 1, 1>();
+}
 
 BOOST_AUTO_TEST_CASE(move_only_2) {
     AtomicQueue2<std::unique_ptr<int>, 2> q;