1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// UNSUPPORTED: c++03, c++11, c++14, c++17
10
11#include <algorithm>
12#include <deque>
13
14#include "benchmark/benchmark.h"
15
16namespace {
17void run_sizes(auto benchmark) {
18 benchmark->Arg(0)
19 ->Arg(1)
20 ->Arg(2)
21 ->Arg(64)
22 ->Arg(512)
23 ->Arg(1024)
24 ->Arg(4000)
25 ->Arg(4096)
26 ->Arg(5500)
27 ->Arg(64000)
28 ->Arg(65536)
29 ->Arg(70000);
30}
31
32template <class FromContainer, class ToContainer, class Func>
33void benchmark_containers(benchmark::State& state, FromContainer& d, ToContainer& v, Func&& func) {
34 for (auto _ : state) {
35 benchmark::DoNotOptimize(v);
36 benchmark::DoNotOptimize(d);
37 func(d.begin(), d.end(), v.begin());
38 }
39}
40
41template <class Func>
42void benchmark_deque_vector(benchmark::State& state, Func&& func) {
43 auto size = state.range(pos: 0);
44 std::deque<int> d;
45 d.resize(new_size: size);
46 std::ranges::fill(d, 10);
47 std::vector<int> v;
48 v.resize(new_size: size);
49 benchmark_containers(state, d, v, func);
50}
51
52template <class Func>
53void benchmark_deque_deque(benchmark::State& state, Func&& func) {
54 auto size = state.range(pos: 0);
55 std::deque<int> d;
56 d.resize(new_size: size);
57 std::ranges::fill(d, 10);
58 std::deque<int> v;
59 v.resize(new_size: size);
60 benchmark_containers(state, d, v, func);
61}
62
63template <class Func>
64void benchmark_vector_deque(benchmark::State& state, Func&& func) {
65 auto size = state.range(pos: 0);
66 std::vector<int> d;
67 d.resize(new_size: size);
68 std::ranges::fill(d, 10);
69 std::deque<int> v;
70 v.resize(new_size: size);
71 benchmark_containers(state, d, v, func);
72}
73
74template <class FromContainer, class ToContainer, class Func>
75void benchmark_containers_backward(benchmark::State& state, FromContainer& d, ToContainer& v, Func&& func) {
76 for (auto _ : state) {
77 benchmark::DoNotOptimize(v);
78 benchmark::DoNotOptimize(d);
79 func(d.begin(), d.end(), v.end());
80 }
81}
82
83template <class Func>
84void benchmark_deque_vector_backward(benchmark::State& state, Func&& func) {
85 auto size = state.range(pos: 0);
86 std::deque<int> d;
87 d.resize(new_size: size);
88 std::ranges::fill(d, 10);
89 std::vector<int> v;
90 v.resize(new_size: size);
91 benchmark_containers_backward(state, d, v, func);
92}
93
94template <class Func>
95void benchmark_deque_deque_backward(benchmark::State& state, Func&& func) {
96 auto size = state.range(pos: 0);
97 std::deque<int> d;
98 d.resize(new_size: size);
99 std::ranges::fill(d, 10);
100 std::deque<int> v;
101 v.resize(new_size: size);
102 benchmark_containers_backward(state, d, v, func);
103}
104
105template <class Func>
106void benchmark_vector_deque_backward(benchmark::State& state, Func&& func) {
107 auto size = state.range(pos: 0);
108 std::vector<int> d;
109 d.resize(new_size: size);
110 std::ranges::fill(d, 10);
111 std::deque<int> v;
112 v.resize(new_size: size);
113 benchmark_containers_backward(state, d, v, func);
114}
115
116struct CopyFunctor {
117 template <class... Args>
118 auto operator()(Args... args) const {
119 std::copy(std::forward<Args>(args)...);
120 }
121} copy;
122
123struct MoveFunctor {
124 template <class... Args>
125 auto operator()(Args... args) const {
126 std::move(std::forward<Args>(args)...);
127 }
128} move;
129
130struct CopyBackwardFunctor {
131 template <class... Args>
132 auto operator()(Args... args) const {
133 std::copy_backward(std::forward<Args>(args)...);
134 }
135} copy_backward;
136
137struct MoveBackwardFunctor {
138 template <class... Args>
139 auto operator()(Args... args) const {
140 std::move_backward(std::forward<Args>(args)...);
141 }
142} move_backward;
143
144// copy
145void BM_deque_vector_copy(benchmark::State& state) { benchmark_deque_vector(state, func&: copy); }
146BENCHMARK(BM_deque_vector_copy)->Apply(func: run_sizes);
147
148void BM_deque_vector_ranges_copy(benchmark::State& state) { benchmark_deque_vector(state, std::ranges::copy); }
149BENCHMARK(BM_deque_vector_ranges_copy)->Apply(func: run_sizes);
150
151void BM_deque_deque_copy(benchmark::State& state) { benchmark_deque_deque(state, func&: copy); }
152BENCHMARK(BM_deque_deque_copy)->Apply(func: run_sizes);
153
154void BM_deque_deque_ranges_copy(benchmark::State& state) { benchmark_deque_deque(state, std::ranges::copy); }
155BENCHMARK(BM_deque_deque_ranges_copy)->Apply(func: run_sizes);
156
157void BM_vector_deque_copy(benchmark::State& state) { benchmark_vector_deque(state, func&: copy); }
158BENCHMARK(BM_vector_deque_copy)->Apply(func: run_sizes);
159
160void BM_vector_deque_ranges_copy(benchmark::State& state) { benchmark_vector_deque(state, std::ranges::copy); }
161BENCHMARK(BM_vector_deque_ranges_copy)->Apply(func: run_sizes);
162
163// move
164void BM_deque_vector_move(benchmark::State& state) { benchmark_deque_vector(state, func&: move); }
165BENCHMARK(BM_deque_vector_move)->Apply(func: run_sizes);
166
167void BM_deque_vector_ranges_move(benchmark::State& state) { benchmark_deque_vector(state, std::ranges::move); }
168BENCHMARK(BM_deque_vector_ranges_move)->Apply(func: run_sizes);
169
170void BM_deque_deque_move(benchmark::State& state) { benchmark_deque_deque(state, func&: move); }
171BENCHMARK(BM_deque_deque_move)->Apply(func: run_sizes);
172
173void BM_deque_deque_ranges_move(benchmark::State& state) { benchmark_deque_deque(state, std::ranges::move); }
174BENCHMARK(BM_deque_deque_ranges_move)->Apply(func: run_sizes);
175
176void BM_vector_deque_move(benchmark::State& state) { benchmark_vector_deque(state, func&: move); }
177BENCHMARK(BM_vector_deque_move)->Apply(func: run_sizes);
178
179void BM_vector_deque_ranges_move(benchmark::State& state) { benchmark_vector_deque(state, std::ranges::move); }
180BENCHMARK(BM_vector_deque_ranges_move)->Apply(func: run_sizes);
181
182// copy_backward
183void BM_deque_vector_copy_backward(benchmark::State& state) { benchmark_deque_vector_backward(state, func&: copy_backward); }
184BENCHMARK(BM_deque_vector_copy_backward)->Apply(func: run_sizes);
185
186void BM_deque_vector_ranges_copy_backward(benchmark::State& state) {
187 benchmark_deque_vector_backward(state, std::ranges::copy_backward);
188}
189BENCHMARK(BM_deque_vector_ranges_copy_backward)->Apply(func: run_sizes);
190
191void BM_deque_deque_copy_backward(benchmark::State& state) { benchmark_deque_deque_backward(state, func&: copy_backward); }
192BENCHMARK(BM_deque_deque_copy_backward)->Apply(func: run_sizes);
193
194void BM_deque_deque_ranges_copy_backward(benchmark::State& state) {
195 benchmark_deque_deque_backward(state, std::ranges::copy_backward);
196}
197BENCHMARK(BM_deque_deque_ranges_copy_backward)->Apply(func: run_sizes);
198
199void BM_vector_deque_copy_backward(benchmark::State& state) { benchmark_vector_deque_backward(state, func&: copy_backward); }
200BENCHMARK(BM_vector_deque_copy_backward)->Apply(func: run_sizes);
201
202void BM_vector_deque_ranges_copy_backward(benchmark::State& state) {
203 benchmark_vector_deque_backward(state, std::ranges::copy_backward);
204}
205BENCHMARK(BM_vector_deque_ranges_copy_backward)->Apply(func: run_sizes);
206
207// move_backward
208void BM_deque_vector_move_backward(benchmark::State& state) { benchmark_deque_vector_backward(state, func&: move_backward); }
209BENCHMARK(BM_deque_vector_move_backward)->Apply(func: run_sizes);
210
211void BM_deque_vector_ranges_move_backward(benchmark::State& state) {
212 benchmark_deque_vector_backward(state, std::ranges::move_backward);
213}
214BENCHMARK(BM_deque_vector_ranges_move_backward)->Apply(func: run_sizes);
215
216void BM_deque_deque_move_backward(benchmark::State& state) { benchmark_deque_deque_backward(state, func&: move_backward); }
217BENCHMARK(BM_deque_deque_move_backward)->Apply(func: run_sizes);
218
219void BM_deque_deque_ranges_move_backward(benchmark::State& state) {
220 benchmark_deque_deque_backward(state, std::ranges::move_backward);
221}
222BENCHMARK(BM_deque_deque_ranges_move_backward)->Apply(func: run_sizes);
223
224void BM_vector_deque_move_backward(benchmark::State& state) { benchmark_vector_deque_backward(state, func&: move_backward); }
225BENCHMARK(BM_vector_deque_move_backward)->Apply(func: run_sizes);
226
227void BM_vector_deque_ranges_move_backward(benchmark::State& state) {
228 benchmark_vector_deque_backward(state, std::ranges::move_backward);
229}
230BENCHMARK(BM_vector_deque_ranges_move_backward)->Apply(func: run_sizes);
231
232} // namespace
233
234BENCHMARK_MAIN();
235

source code of libcxx/test/benchmarks/containers/deque_iterator.bench.cpp