[libcxx-commits] [libcxx] [libc++] Fold deque iterator benchmarks into algorithm benchmarks (PR #212279)
via libcxx-commits
libcxx-commits at lists.llvm.org
Mon Jul 27 08:47:09 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-libcxx
Author: Louis Dionne (ldionne)
<details>
<summary>Changes</summary>
The deque::iterator benchmarks were not truly about deque::iterator, but about specialized algorithm implementations we have for segmented iterators. This patch handles them as such, like we do for other specialized algorithms like vector<bool>.
---
Full diff: https://github.com/llvm/llvm-project/pull/212279.diff
5 Files Affected:
- (modified) libcxx/test/benchmarks/algorithms/modifying/copy.bench.cpp (+9-7)
- (modified) libcxx/test/benchmarks/algorithms/modifying/copy_backward.bench.cpp (+11-7)
- (modified) libcxx/test/benchmarks/algorithms/modifying/move.bench.cpp (+14-12)
- (modified) libcxx/test/benchmarks/algorithms/modifying/move_backward.bench.cpp (+16-12)
- (removed) libcxx/test/benchmarks/containers/deque_iterator.bench.cpp (-234)
``````````diff
diff --git a/libcxx/test/benchmarks/algorithms/modifying/copy.bench.cpp b/libcxx/test/benchmarks/algorithms/modifying/copy.bench.cpp
index 9c690eac6419e..853c46bb357ae 100644
--- a/libcxx/test/benchmarks/algorithms/modifying/copy.bench.cpp
+++ b/libcxx/test/benchmarks/algorithms/modifying/copy.bench.cpp
@@ -25,14 +25,14 @@ int main(int argc, char** argv) {
// {std,ranges}::copy(normal container)
{
- auto bm = []<class Container>(std::string name, auto copy) {
+ auto bm = []<class InputContainer, class OutputContainer>(std::string name, auto copy) {
benchmark::RegisterBenchmark(name, [copy](auto& st) {
std::size_t const n = st.range(0);
- using ValueType = typename Container::value_type;
- Container c;
+ using ValueType = typename InputContainer::value_type;
+ InputContainer c;
std::generate_n(std::back_inserter(c), n, [] { return Generate<ValueType>::random(); });
- std::vector<ValueType> out(n);
+ OutputContainer out(n);
for ([[maybe_unused]] auto _ : st) {
benchmark::DoNotOptimize(c);
@@ -42,9 +42,11 @@ int main(int argc, char** argv) {
}
})->Range(8, 1 << 20);
};
- bm.operator()<std::vector<int>>("std::copy(vector<int>)", std_copy);
- bm.operator()<std::deque<int>>("std::copy(deque<int>)", std_copy);
- bm.operator()<std::list<int>>("std::copy(list<int>)", std_copy);
+ bm.operator()<std::vector<int>, std::vector<int>>("std::copy(vector<int>) -> std::vector<int>", std_copy);
+ bm.operator()<std::vector<int>, std::deque<int>>("std::copy(vector<int>) -> std::deque<int>", std_copy);
+ bm.operator()<std::deque<int>, std::vector<int>>("std::copy(deque<int>) -> std::vector<int>", std_copy);
+ bm.operator()<std::deque<int>, std::deque<int>>("std::copy(deque<int>) -> std::deque<int>", std_copy);
+ bm.operator()<std::list<int>, std::vector<int>>("std::copy(list<int>) -> std::vector<int>", std_copy);
}
// {std,ranges}::copy(vector<bool>)
diff --git a/libcxx/test/benchmarks/algorithms/modifying/copy_backward.bench.cpp b/libcxx/test/benchmarks/algorithms/modifying/copy_backward.bench.cpp
index 6a601f757a35a..d54dea92cd8a8 100644
--- a/libcxx/test/benchmarks/algorithms/modifying/copy_backward.bench.cpp
+++ b/libcxx/test/benchmarks/algorithms/modifying/copy_backward.bench.cpp
@@ -25,14 +25,14 @@ int main(int argc, char** argv) {
// {std,ranges}::copy_n(normal container)
{
- auto bm = []<class Container>(std::string name, auto copy_backward) {
+ auto bm = []<class InputContainer, class OutputContainer>(std::string name, auto copy_backward) {
benchmark::RegisterBenchmark(name, [copy_backward](auto& st) {
std::size_t const n = st.range(0);
- using ValueType = typename Container::value_type;
- Container c;
+ using ValueType = typename InputContainer::value_type;
+ InputContainer c;
std::generate_n(std::back_inserter(c), n, [] { return Generate<ValueType>::random(); });
- std::vector<ValueType> out(n);
+ OutputContainer out(n);
for ([[maybe_unused]] auto _ : st) {
benchmark::DoNotOptimize(c);
@@ -42,9 +42,13 @@ int main(int argc, char** argv) {
}
})->Range(8, 1 << 20);
};
- bm.operator()<std::vector<int>>("std::copy_backward(vector<int>)", std_copy_backward);
- bm.operator()<std::deque<int>>("std::copy_backward(deque<int>)", std_copy_backward);
- bm.operator()<std::list<int>>("std::copy_backward(list<int>)", std_copy_backward);
+ // clang-format off
+ bm.operator()<std::vector<int>, std::vector<int>>("std::copy_backward(vector<int>) -> std::vector<int>", std_copy_backward);
+ bm.operator()<std::vector<int>, std::deque<int>>("std::copy_backward(vector<int>) -> std::deque<int>", std_copy_backward);
+ bm.operator()<std::deque<int>, std::vector<int>>("std::copy_backward(deque<int>) -> std::vector<int>", std_copy_backward);
+ bm.operator()<std::deque<int>, std::deque<int>>("std::copy_backward(deque<int>) -> std::deque<int>", std_copy_backward);
+ bm.operator()<std::list<int>, std::vector<int>>("std::copy_backward(list<int>) -> std::vector<int>", std_copy_backward);
+ // clang-format on
}
// {std,ranges}::copy_n(vector<bool>)
diff --git a/libcxx/test/benchmarks/algorithms/modifying/move.bench.cpp b/libcxx/test/benchmarks/algorithms/modifying/move.bench.cpp
index afef3609b0fc5..e509c9a976fe2 100644
--- a/libcxx/test/benchmarks/algorithms/modifying/move.bench.cpp
+++ b/libcxx/test/benchmarks/algorithms/modifying/move.bench.cpp
@@ -14,6 +14,7 @@
#include <iterator>
#include <list>
#include <string>
+#include <type_traits>
#include <vector>
#include "benchmark/benchmark.h"
@@ -25,28 +26,29 @@ int main(int argc, char** argv) {
// {std,ranges}::move(normal container)
{
- auto bm = []<class Container>(std::string name, auto move) {
+ auto bm = []<class InputContainer, class OutputContainer>(std::string name, auto move) {
benchmark::RegisterBenchmark(name, [move](auto& st) {
std::size_t const size = st.range(0);
- using ValueType = typename Container::value_type;
- Container c1(size);
- Container c2(size);
- std::generate_n(c1.begin(), size, [] { return Generate<ValueType>::random(); });
+ using ValueType = typename InputContainer::value_type;
+ InputContainer in;
+ std::generate_n(std::back_inserter(in), size, [] { return Generate<ValueType>::random(); });
+
+ OutputContainer out(size);
- Container* in = &c1;
- Container* out = &c2;
for ([[maybe_unused]] auto _ : st) {
benchmark::DoNotOptimize(in);
benchmark::DoNotOptimize(out);
- auto result = move(in->begin(), in->end(), out->begin());
+ static_assert(std::is_trivially_move_assignable_v<ValueType>, "avoid double moves");
+ auto result = move(in.begin(), in.end(), out.begin());
benchmark::DoNotOptimize(result);
- std::swap(in, out);
}
})->Range(8, 1 << 20);
};
- bm.operator()<std::vector<int>>("std::move(vector<int>)", std_move);
- bm.operator()<std::deque<int>>("std::move(deque<int>)", std_move);
- bm.operator()<std::list<int>>("std::move(list<int>)", std_move);
+ bm.operator()<std::vector<int>, std::vector<int>>("std::move(vector<int>) -> std::vector<int>", std_move);
+ bm.operator()<std::vector<int>, std::deque<int>>("std::move(vector<int>) -> std::deque<int>", std_move);
+ bm.operator()<std::deque<int>, std::vector<int>>("std::move(deque<int>) -> std::vector<int>", std_move);
+ bm.operator()<std::deque<int>, std::deque<int>>("std::move(deque<int>) -> std::deque<int>", std_move);
+ bm.operator()<std::list<int>, std::vector<int>>("std::move(list<int>) -> std::vector<int>", std_move);
}
// {std,ranges}::move(vector<bool>)
diff --git a/libcxx/test/benchmarks/algorithms/modifying/move_backward.bench.cpp b/libcxx/test/benchmarks/algorithms/modifying/move_backward.bench.cpp
index b7677c7e42a78..51153bb548990 100644
--- a/libcxx/test/benchmarks/algorithms/modifying/move_backward.bench.cpp
+++ b/libcxx/test/benchmarks/algorithms/modifying/move_backward.bench.cpp
@@ -14,6 +14,7 @@
#include <iterator>
#include <list>
#include <string>
+#include <type_traits>
#include <vector>
#include "benchmark/benchmark.h"
@@ -25,28 +26,31 @@ int main(int argc, char** argv) {
// {std,ranges}::move_backward(normal container)
{
- auto bm = []<class Container>(std::string name, auto move_backward) {
+ auto bm = []<class InputContainer, class OutputContainer>(std::string name, auto move_backward) {
benchmark::RegisterBenchmark(name, [move_backward](auto& st) {
std::size_t const size = st.range(0);
- using ValueType = typename Container::value_type;
- Container c1(size);
- Container c2(size);
- std::generate_n(c1.begin(), size, [] { return Generate<ValueType>::random(); });
+ using ValueType = typename InputContainer::value_type;
+ InputContainer in;
+ std::generate_n(std::back_inserter(in), size, [] { return Generate<ValueType>::random(); });
+
+ OutputContainer out(size);
- Container* in = &c1;
- Container* out = &c2;
for ([[maybe_unused]] auto _ : st) {
benchmark::DoNotOptimize(in);
benchmark::DoNotOptimize(out);
- auto result = move_backward(in->begin(), in->end(), out->end());
+ static_assert(std::is_trivially_move_assignable_v<ValueType>, "avoid double moves");
+ auto result = move_backward(in.begin(), in.end(), out.end());
benchmark::DoNotOptimize(result);
- std::swap(in, out);
}
})->Range(8, 1 << 20);
};
- bm.operator()<std::vector<int>>("std::move_backward(vector<int>)", std_move_backward);
- bm.operator()<std::deque<int>>("std::move_backward(deque<int>)", std_move_backward);
- bm.operator()<std::list<int>>("std::move_backward(list<int>)", std_move_backward);
+ // clang-format off
+ bm.operator()<std::vector<int>, std::vector<int>>("std::move_backward(vector<int>) -> std::vector<int>", std_move_backward);
+ bm.operator()<std::vector<int>, std::deque<int>>("std::move_backward(vector<int>) -> std::deque<int>", std_move_backward);
+ bm.operator()<std::deque<int>, std::vector<int>>("std::move_backward(deque<int>) -> std::vector<int>", std_move_backward);
+ bm.operator()<std::deque<int>, std::deque<int>>("std::move_backward(deque<int>) -> std::deque<int>", std_move_backward);
+ bm.operator()<std::list<int>, std::vector<int>>("std::move_backward(list<int>) -> std::vector<int>", std_move_backward);
+ // clang-format on
}
// {std,ranges}::move_backward(vector<bool>)
diff --git a/libcxx/test/benchmarks/containers/deque_iterator.bench.cpp b/libcxx/test/benchmarks/containers/deque_iterator.bench.cpp
deleted file mode 100644
index 8d46a8ac0629d..0000000000000
--- a/libcxx/test/benchmarks/containers/deque_iterator.bench.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-#include <algorithm>
-#include <deque>
-
-#include "benchmark/benchmark.h"
-
-namespace {
-void run_sizes(benchmark::Benchmark* benchmark) {
- benchmark->Arg(0)
- ->Arg(1)
- ->Arg(2)
- ->Arg(64)
- ->Arg(512)
- ->Arg(1024)
- ->Arg(4000)
- ->Arg(4096)
- ->Arg(5500)
- ->Arg(64000)
- ->Arg(65536)
- ->Arg(70000);
-}
-
-template <class FromContainer, class ToContainer, class Func>
-void benchmark_containers(benchmark::State& state, FromContainer& d, ToContainer& v, Func&& func) {
- for (auto _ : state) {
- benchmark::DoNotOptimize(v);
- benchmark::DoNotOptimize(d);
- func(d.begin(), d.end(), v.begin());
- }
-}
-
-template <class Func>
-void benchmark_deque_vector(benchmark::State& state, Func&& func) {
- auto size = state.range(0);
- std::deque<int> d;
- d.resize(size);
- std::ranges::fill(d, 10);
- std::vector<int> v;
- v.resize(size);
- benchmark_containers(state, d, v, func);
-}
-
-template <class Func>
-void benchmark_deque_deque(benchmark::State& state, Func&& func) {
- auto size = state.range(0);
- std::deque<int> d;
- d.resize(size);
- std::ranges::fill(d, 10);
- std::deque<int> v;
- v.resize(size);
- benchmark_containers(state, d, v, func);
-}
-
-template <class Func>
-void benchmark_vector_deque(benchmark::State& state, Func&& func) {
- auto size = state.range(0);
- std::vector<int> d;
- d.resize(size);
- std::ranges::fill(d, 10);
- std::deque<int> v;
- v.resize(size);
- benchmark_containers(state, d, v, func);
-}
-
-template <class FromContainer, class ToContainer, class Func>
-void benchmark_containers_backward(benchmark::State& state, FromContainer& d, ToContainer& v, Func&& func) {
- for (auto _ : state) {
- benchmark::DoNotOptimize(v);
- benchmark::DoNotOptimize(d);
- func(d.begin(), d.end(), v.end());
- }
-}
-
-template <class Func>
-void benchmark_deque_vector_backward(benchmark::State& state, Func&& func) {
- auto size = state.range(0);
- std::deque<int> d;
- d.resize(size);
- std::ranges::fill(d, 10);
- std::vector<int> v;
- v.resize(size);
- benchmark_containers_backward(state, d, v, func);
-}
-
-template <class Func>
-void benchmark_deque_deque_backward(benchmark::State& state, Func&& func) {
- auto size = state.range(0);
- std::deque<int> d;
- d.resize(size);
- std::ranges::fill(d, 10);
- std::deque<int> v;
- v.resize(size);
- benchmark_containers_backward(state, d, v, func);
-}
-
-template <class Func>
-void benchmark_vector_deque_backward(benchmark::State& state, Func&& func) {
- auto size = state.range(0);
- std::vector<int> d;
- d.resize(size);
- std::ranges::fill(d, 10);
- std::deque<int> v;
- v.resize(size);
- benchmark_containers_backward(state, d, v, func);
-}
-
-struct CopyFunctor {
- template <class... Args>
- auto operator()(Args... args) const {
- std::copy(std::forward<Args>(args)...);
- }
-} copy;
-
-struct MoveFunctor {
- template <class... Args>
- auto operator()(Args... args) const {
- std::move(std::forward<Args>(args)...);
- }
-} move;
-
-struct CopyBackwardFunctor {
- template <class... Args>
- auto operator()(Args... args) const {
- std::copy_backward(std::forward<Args>(args)...);
- }
-} copy_backward;
-
-struct MoveBackwardFunctor {
- template <class... Args>
- auto operator()(Args... args) const {
- std::move_backward(std::forward<Args>(args)...);
- }
-} move_backward;
-
-// copy
-void BM_deque_vector_copy(benchmark::State& state) { benchmark_deque_vector(state, copy); }
-BENCHMARK(BM_deque_vector_copy)->Apply(run_sizes);
-
-void BM_deque_vector_ranges_copy(benchmark::State& state) { benchmark_deque_vector(state, std::ranges::copy); }
-BENCHMARK(BM_deque_vector_ranges_copy)->Apply(run_sizes);
-
-void BM_deque_deque_copy(benchmark::State& state) { benchmark_deque_deque(state, copy); }
-BENCHMARK(BM_deque_deque_copy)->Apply(run_sizes);
-
-void BM_deque_deque_ranges_copy(benchmark::State& state) { benchmark_deque_deque(state, std::ranges::copy); }
-BENCHMARK(BM_deque_deque_ranges_copy)->Apply(run_sizes);
-
-void BM_vector_deque_copy(benchmark::State& state) { benchmark_vector_deque(state, copy); }
-BENCHMARK(BM_vector_deque_copy)->Apply(run_sizes);
-
-void BM_vector_deque_ranges_copy(benchmark::State& state) { benchmark_vector_deque(state, std::ranges::copy); }
-BENCHMARK(BM_vector_deque_ranges_copy)->Apply(run_sizes);
-
-// move
-void BM_deque_vector_move(benchmark::State& state) { benchmark_deque_vector(state, move); }
-BENCHMARK(BM_deque_vector_move)->Apply(run_sizes);
-
-void BM_deque_vector_ranges_move(benchmark::State& state) { benchmark_deque_vector(state, std::ranges::move); }
-BENCHMARK(BM_deque_vector_ranges_move)->Apply(run_sizes);
-
-void BM_deque_deque_move(benchmark::State& state) { benchmark_deque_deque(state, move); }
-BENCHMARK(BM_deque_deque_move)->Apply(run_sizes);
-
-void BM_deque_deque_ranges_move(benchmark::State& state) { benchmark_deque_deque(state, std::ranges::move); }
-BENCHMARK(BM_deque_deque_ranges_move)->Apply(run_sizes);
-
-void BM_vector_deque_move(benchmark::State& state) { benchmark_vector_deque(state, move); }
-BENCHMARK(BM_vector_deque_move)->Apply(run_sizes);
-
-void BM_vector_deque_ranges_move(benchmark::State& state) { benchmark_vector_deque(state, std::ranges::move); }
-BENCHMARK(BM_vector_deque_ranges_move)->Apply(run_sizes);
-
-// copy_backward
-void BM_deque_vector_copy_backward(benchmark::State& state) { benchmark_deque_vector_backward(state, copy_backward); }
-BENCHMARK(BM_deque_vector_copy_backward)->Apply(run_sizes);
-
-void BM_deque_vector_ranges_copy_backward(benchmark::State& state) {
- benchmark_deque_vector_backward(state, std::ranges::copy_backward);
-}
-BENCHMARK(BM_deque_vector_ranges_copy_backward)->Apply(run_sizes);
-
-void BM_deque_deque_copy_backward(benchmark::State& state) { benchmark_deque_deque_backward(state, copy_backward); }
-BENCHMARK(BM_deque_deque_copy_backward)->Apply(run_sizes);
-
-void BM_deque_deque_ranges_copy_backward(benchmark::State& state) {
- benchmark_deque_deque_backward(state, std::ranges::copy_backward);
-}
-BENCHMARK(BM_deque_deque_ranges_copy_backward)->Apply(run_sizes);
-
-void BM_vector_deque_copy_backward(benchmark::State& state) { benchmark_vector_deque_backward(state, copy_backward); }
-BENCHMARK(BM_vector_deque_copy_backward)->Apply(run_sizes);
-
-void BM_vector_deque_ranges_copy_backward(benchmark::State& state) {
- benchmark_vector_deque_backward(state, std::ranges::copy_backward);
-}
-BENCHMARK(BM_vector_deque_ranges_copy_backward)->Apply(run_sizes);
-
-// move_backward
-void BM_deque_vector_move_backward(benchmark::State& state) { benchmark_deque_vector_backward(state, move_backward); }
-BENCHMARK(BM_deque_vector_move_backward)->Apply(run_sizes);
-
-void BM_deque_vector_ranges_move_backward(benchmark::State& state) {
- benchmark_deque_vector_backward(state, std::ranges::move_backward);
-}
-BENCHMARK(BM_deque_vector_ranges_move_backward)->Apply(run_sizes);
-
-void BM_deque_deque_move_backward(benchmark::State& state) { benchmark_deque_deque_backward(state, move_backward); }
-BENCHMARK(BM_deque_deque_move_backward)->Apply(run_sizes);
-
-void BM_deque_deque_ranges_move_backward(benchmark::State& state) {
- benchmark_deque_deque_backward(state, std::ranges::move_backward);
-}
-BENCHMARK(BM_deque_deque_ranges_move_backward)->Apply(run_sizes);
-
-void BM_vector_deque_move_backward(benchmark::State& state) { benchmark_vector_deque_backward(state, move_backward); }
-BENCHMARK(BM_vector_deque_move_backward)->Apply(run_sizes);
-
-void BM_vector_deque_ranges_move_backward(benchmark::State& state) {
- benchmark_vector_deque_backward(state, std::ranges::move_backward);
-}
-BENCHMARK(BM_vector_deque_ranges_move_backward)->Apply(run_sizes);
-
-} // namespace
-
-BENCHMARK_MAIN();
``````````
</details>
https://github.com/llvm/llvm-project/pull/212279
More information about the libcxx-commits
mailing list