bench: sweep the non-blocking path across capacity, on one clock

[jadecubes]

What this adds

main only benchmarks the blocking push/pop path. This adds the non-blocking one: BM_QueueTryThroughput<Queue>, swept across capacities 1, 2, 8, 64 and 1024 for MutexQueue, SpscQueue and MpmcQueue.

Failed attempts are retried inside the timed iteration, so they cost time but never count as transferred work — items/s stays the same unit as the blocking rows. The pressure that caused them is reported separately as retries/op, split into push_retries/push and pop_retries/pop.

Result

5 invocations × 10 repetitions, load 3.5–6.1, items/s as mean (min–max):

capacity	MutexQueue	SpscQueue	MpmcQueue	Spsc/Mutex
1	5.6 (5.3–6.0)	7.8 (7.6–7.9)	6.9 (6.7–7.2)	1.3–1.5×
2	9.6 (9.2–10.0)	15.1 (14.5–15.5)	14.1 (13.6–14.4)	1.5–1.6×
8	27.2 (25.8–28.9)	61.3 (59.9–62.2)	50.7 (48.6–54.1)	2.1–2.4×
64	20.1 (19.5–20.5)	521.1 (501.1–531.1)	186.4 (183.9–190.4)	24.6–26.9×
1024	54.3 (53.8–55.2)	622.6 (616.3–627.4)	195.2 (189.9–198.3)	11.3–11.7×

The lock-free advantage is not a constant. It is small while the ring is shallow and opens up once a producer can run ahead. retries/op tracks it: 1.05–1.30 at capacity 1, 0.0005–0.0054 at 1024.

Read the table with the retry policy in mind. The loop yields after each failure, which only helps MutexQueue — its try_ calls take a blocking lock_guard, so an unyielding spinner barges the lock back from the counterpart that would have made room. The lock-free queues have no lock to barge, so the yield is pure overhead there. Removing it at capacity 1 costs MutexQueue ~10× and gains each lock-free queue 2–3×, moving Spsc/Mutex from under 2× to around 40×.

The yield stays (without it the mutex row degenerates, and a 2-vCPU runner would be worse than this 12-core box), but it is now named in the helper and in the sweep's comment. Ratios rather than rates throughout: absolute figures move 10–25% with machine load.

Two defects fixed along the way

Clock. The five single_thread_roundtrip registrations set no UseRealTime(), so they reported items/s per CPU-second while every threaded row is per wall-second — despite a comment claiming the units matched. Small (1.004–1.015) but two different quantities.

Lint coverage. HeaderFilterRegex covered only include/cq/, so tests/queue_test_util.hpp and the new bench/try_operation.hpp got no clang-tidy diagnostics at all. Widening it exposed a second problem: the filter matches a path segment above the repo root, so a checkout under /home/runner/work/bench/bench/ lints benchmark.h under WarningsAsErrors (reproduced at 187 errors). Fixed by declaring benchmark SYSTEM, as concurrentqueue and tbb already are.

One open question

MutexQueue is slower at capacity 64 than at capacity 8. Paired sampling — both points inside the same invocation, eight invocations — gives 8/8 in the same direction, difference +9.47 ± 2.36 M/s. It is real, and I have no explanation for it.

Scope

Only the cq queues are swept: neither external adapter has a try_pop, and moodycamel is unbounded so it has no capacity to vary.

Files

File	+/−	What changed
bench/queue_bench.cpp	+138 −10	Adds BM_QueueTryThroughput<Queue> — same thread split as the blocking benchmark, but each iteration retries until it succeeds and accumulates the failures, then publishes three kAvgIterations counters. Adds setup_queue_at_capacity<Queue>, which reads the capacity from the registered Arg so one benchmark can sweep it, and hoists the prefill both setups share into install_half_full_queue<Queue>. Registers the sweep three times against a named capacity_sweep list. Adds ->UseRealTime() to the five single_thread_roundtrip registrations.
bench/try_operation.hpp	+51	New. count_failures_until_success(op) — retry until success, return the failure count, std::this_thread::yield() after each failure. Constrained with invocable<Operation&> && convertible_to<invoke_result_t<Operation&>, bool> rather than std::predicate, which would demand equality-preserving invocation this deliberately violates. Most of the file is the rationale for the yield: what it buys, what it costs, and why the ratios and not the rates are quoted.
bench/CMakeLists.txt	+16	Adds the bench_retry_pressure ctest, which runs the capacity-1 sweep point and asserts retries/op is non-zero on the _mean row. Separate from bench_smoke because PASS_REGULAR_EXPRESSION suppresses CTest's exit-code check, and bench_smoke should keep it.
tests/try_operation_test.cpp	+23	New. One test: an operation that succeeds on its third call is invoked exactly three times and reports exactly two failures. Catches a helper that gives up early — which the ctest gate cannot, since such a helper still reports non-zero.
tests/CMakeLists.txt	+4 −1	Compiles the new test and points the test target at bench/ so it can include the helper.
.clang-tidy	+7 −1	HeaderFilterRegex: 'include/cq/.*' → '(^|/)(include/cq|bench|tests)/'. Both tests/queue_test_util.hpp and the new bench/try_operation.hpp sit outside include/cq/ and were receiving no diagnostics at all.
CMakeLists.txt	+8 −1	Adds SYSTEM to benchmark's FetchContent_Declare. Required by the row above: it is the only dependency arriving as a plain -I, so it is the only one the widened filter can reach.

Verification

Release ctest 68/68 (66 before), TSan 66/66, clang-format and clang-tidy clean. Stubbing the helper to return 0; fails bench_retry_pressure while bench_smoke still passes.

---

_{Originally opened against feat/mutex-queue, a branch already merged as #2 that main has since moved past. Rebuilt on main and re-targeted; pre-rebuild head was da2874c.}

🤖 Generated with Claude Code