Better CapacityArgAdaptor name.

Author: Maxim Egorushkin

Makefile

@@ -6,7 +6,7 @@
 #   time make -rC ~/src/atomic_queue -j$(($(nproc)/2)) BUILD=debug run_tests
 #   time make -rC ~/src/atomic_queue -j$(($(nproc)/2)) all run_tests
 #   time make -rC ~/src/atomic_queue -j$(($(nproc)/2)) run_benchmarks
-#   time make -rC ~/src/atomic_queue -j$(($(nproc)/2)) TAGS
+#   time make -rC ~/src/atomic_queue -j$(($(nproc)/2)) TOOLSET=clang-20 BUILD=debug TAGS
 #   time make -rC ~/src/atomic_queue -j$(($(nproc)/2)) TOOLSET=clang-20 BUILD=debug run_tests
 #   time make -rC ~/src/atomic_queue -j$(($(nproc)/2)) TOOLSET=clang BUILD=sanitize run_tests
 #   time make -rC ~/src/atomic_queue -j$(($(nproc)/2)) TOOLSET=clang run_benchmarks

include/atomic_queue/atomic_queue.h

@@ -650,8 +650,8 @@ struct RetryDecorator : Queue {
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 template<class Queue, size_t Capacity>
-struct CapacityArgDecorator : Queue {
-    CapacityArgDecorator()
+struct CapacityArgAdaptor : Queue {
+    CapacityArgAdaptor()
         : Queue(Capacity)
     {}
 };

src/benchmarks.cc

@@ -152,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<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>>;
+    using AtomicQueueB =        Type<RetryDecorator<CapacityArgAdaptor<atomic_queue::AtomicQueueB<T, Allocator, T{}, MAXIMIZE_THROUGHPUT, false, SPSC>, SIZE>>>;
+    using OptimistAtomicQueueB =               Type<CapacityArgAdaptor<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<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>>;
+    using AtomicQueueB2 = Type<RetryDecorator<CapacityArgAdaptor<atomic_queue::AtomicQueueB2<T, Allocator, MAXIMIZE_THROUGHPUT, false, SPSC>, SIZE>>>;
+    using OptimistAtomicQueueB2 =        Type<CapacityArgAdaptor<atomic_queue::AtomicQueueB2<T, Allocator, MAXIMIZE_THROUGHPUT, false, SPSC>, SIZE>>;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -346,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<CapacityArgDecorator<xenium::vyukov_bounded_queue<unsigned>, SIZE>>>{});
+        Type<RetryDecorator<CapacityArgAdaptor<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.
@@ -493,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<CapacityArgDecorator<xenium::vyukov_bounded_queue<unsigned>, SIZE>>>("xenium::vyukov_bounded_queue", hp, hw_thread_ids);
+    run_ping_pong_benchmark<RetryDecorator<CapacityArgAdaptor<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

@@ -189,35 +189,35 @@ BOOST_AUTO_TEST_CASE(spsc_stress_OptimistAtomicQueue2) {
 }
 
 BOOST_AUTO_TEST_CASE(stress_AtomicQueueB) {
-    stress<RetryDecorator<CapacityArgDecorator<AtomicQueueB<unsigned>, CAPACITY>>>();
+    stress<RetryDecorator<CapacityArgAdaptor<AtomicQueueB<unsigned>, CAPACITY>>>();
 }
 
 BOOST_AUTO_TEST_CASE(stress_OptimistAtomicQueueB) {
-    stress<CapacityArgDecorator<AtomicQueueB<unsigned>, CAPACITY>>();
+    stress<CapacityArgAdaptor<AtomicQueueB<unsigned>, CAPACITY>>();
 }
 
 BOOST_AUTO_TEST_CASE(stress_AtomicQueueB2) {
-    stress<RetryDecorator<CapacityArgDecorator<AtomicQueueB2<unsigned>, CAPACITY>>>();
+    stress<RetryDecorator<CapacityArgAdaptor<AtomicQueueB2<unsigned>, CAPACITY>>>();
 }
 
 BOOST_AUTO_TEST_CASE(stress_OptimistAtomicQueueB2) {
-    stress<CapacityArgDecorator<AtomicQueueB2<unsigned>, CAPACITY>>();
+    stress<CapacityArgAdaptor<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>();
+    stress<RetryDecorator<CapacityArgAdaptor<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>();
+    stress<CapacityArgAdaptor<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>();
+    stress<RetryDecorator<CapacityArgAdaptor<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>();
+    stress<CapacityArgAdaptor<AtomicQueueB2<unsigned, std::allocator<unsigned>, true, false, true>, CAPACITY>, 1, 1>();
 }
 
 BOOST_AUTO_TEST_CASE(move_only_2) {