1//===----------------------------------------------------------------------===//
2// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
3// See https://llvm.org/LICENSE.txt for license information.
4// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
5//
6//===----------------------------------------------------------------------===//
7
8#include <atomic>
9#include <numeric>
10#include <thread>
11
12#include "benchmark/benchmark.h"
13#include "make_test_thread.h"
14
15using namespace std::chrono_literals;
16
17void BM_atomic_wait_one_thread_one_atomic_wait(benchmark::State& state) {
18 std::atomic<std::uint64_t> a;
19 auto thread_func = [&](std::stop_token st) {
20 while (!st.stop_requested()) {
21 a.fetch_add(i: 1, m: std::memory_order_relaxed);
22 a.notify_all();
23 }
24 };
25
26 std::uint64_t total_loop_test_param = state.range(pos: 0);
27
28 auto thread = support::make_test_jthread(thread_func);
29
30 for (auto _ : state) {
31 for (std::uint64_t i = 0; i < total_loop_test_param; ++i) {
32 auto old = a.load(m: std::memory_order_relaxed);
33 a.wait(old);
34 }
35 }
36}
37BENCHMARK(BM_atomic_wait_one_thread_one_atomic_wait)->RangeMultiplier(multiplier: 2)->Range(start: 1 << 10, limit: 1 << 24);
38
39void BM_atomic_wait_multi_thread_one_atomic_wait(benchmark::State& state) {
40 std::atomic<std::uint64_t> a;
41 auto notify_func = [&](std::stop_token st) {
42 while (!st.stop_requested()) {
43 a.fetch_add(i: 1, m: std::memory_order_relaxed);
44 a.notify_all();
45 }
46 };
47
48 std::uint64_t total_loop_test_param = state.range(pos: 0);
49 constexpr auto num_waiting_threads = 15;
50 std::vector<std::jthread> wait_threads;
51 wait_threads.reserve(num_waiting_threads);
52
53 auto notify_thread = support::make_test_jthread(notify_func);
54
55 std::atomic<std::uint64_t> start_flag = 0;
56 std::atomic<std::uint64_t> done_count = 0;
57 auto wait_func = [&a, &start_flag, &done_count, total_loop_test_param](std::stop_token st) {
58 auto old_start = 0;
59 while (!st.stop_requested()) {
60 start_flag.wait(old_start);
61 old_start = start_flag.load();
62 for (std::uint64_t i = 0; i < total_loop_test_param; ++i) {
63 auto old = a.load(m: std::memory_order_relaxed);
64 a.wait(old);
65 }
66 done_count.fetch_add(i: 1);
67 }
68 };
69
70 for (size_t i = 0; i < num_waiting_threads; ++i) {
71 wait_threads.emplace_back(support::make_test_jthread(wait_func));
72 }
73
74 for (auto _ : state) {
75 done_count = 0;
76 start_flag.fetch_add(i: 1);
77 start_flag.notify_all();
78 while (done_count < num_waiting_threads) {
79 std::this_thread::yield();
80 }
81 }
82 for (auto& t : wait_threads) {
83 t.request_stop();
84 }
85 start_flag.fetch_add(i: 1);
86 start_flag.notify_all();
87 for (auto& t : wait_threads) {
88 t.join();
89 }
90}
91BENCHMARK(BM_atomic_wait_multi_thread_one_atomic_wait)->RangeMultiplier(multiplier: 2)->Range(start: 1 << 10, limit: 1 << 20);
92
93void BM_atomic_wait_multi_thread_wait_different_atomics(benchmark::State& state) {
94 const std::uint64_t total_loop_test_param = state.range(pos: 0);
95 constexpr std::uint64_t num_atomics = 7;
96 std::vector<std::atomic<std::uint64_t>> atomics(num_atomics);
97
98 auto notify_func = [&](std::stop_token st, size_t idx) {
99 while (!st.stop_requested()) {
100 atomics[idx].fetch_add(i: 1, m: std::memory_order_relaxed);
101 atomics[idx].notify_all();
102 }
103 };
104
105 std::atomic<std::uint64_t> start_flag = 0;
106 std::atomic<std::uint64_t> done_count = 0;
107
108 auto wait_func = [&, total_loop_test_param](std::stop_token st, size_t idx) {
109 auto old_start = 0;
110 while (!st.stop_requested()) {
111 start_flag.wait(old_start);
112 old_start = start_flag.load();
113 for (std::uint64_t i = 0; i < total_loop_test_param; ++i) {
114 auto old = atomics[idx].load(m: std::memory_order_relaxed);
115 atomics[idx].wait(old);
116 }
117 done_count.fetch_add(i: 1);
118 }
119 };
120
121 std::vector<std::jthread> notify_threads;
122 notify_threads.reserve(num_atomics);
123
124 std::vector<std::jthread> wait_threads;
125 wait_threads.reserve(num_atomics);
126
127 for (size_t i = 0; i < num_atomics; ++i) {
128 notify_threads.emplace_back(support::make_test_jthread(notify_func, i));
129 }
130
131 for (size_t i = 0; i < num_atomics; ++i) {
132 wait_threads.emplace_back(support::make_test_jthread(wait_func, i));
133 }
134
135 for (auto _ : state) {
136 done_count = 0;
137 start_flag.fetch_add(i: 1);
138 start_flag.notify_all();
139 while (done_count < num_atomics) {
140 std::this_thread::yield();
141 }
142 }
143 for (auto& t : wait_threads) {
144 t.request_stop();
145 }
146 start_flag.fetch_add(i: 1);
147 start_flag.notify_all();
148 for (auto& t : wait_threads) {
149 t.join();
150 }
151}
152BENCHMARK(BM_atomic_wait_multi_thread_wait_different_atomics)->RangeMultiplier(multiplier: 2)->Range(start: 1 << 10, limit: 1 << 20);
153
154BENCHMARK_MAIN();
155

source code of libcxx/benchmarks/atomic_wait.bench.cpp