[libcxx-commits] [libcxx] [libc++] Add benchmarks for std::binary_search and std::equal_range (PR #207268)
Louis Dionne via libcxx-commits
libcxx-commits at lists.llvm.org
Tue Jul 14 05:48:54 PDT 2026
https://github.com/ldionne updated https://github.com/llvm/llvm-project/pull/207268
>From 0b96a876d2f9d81c139d6695f18184f5c0c75fd1 Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne.2 at gmail.com>
Date: Thu, 2 Jul 2026 13:50:05 -0400
Subject: [PATCH 1/3] [libc++] Add benchmarks for std::binary_search and
std::equal_range
The found and not-found paths are measured as separate benchmarks. For
equal_range we additionally cover a unique match, a large equal range,
and an absent key.
As a drive-by, add a predicate variation to the existing lower_bound and
upper_bound benchmarks.
---
.../nonmodifying/lower_upper_bound.bench.cpp | 129 +++++++++--------
.../sorting/binary_search.bench.cpp | 126 ++++++++++++++++
.../algorithms/sorting/equal_range.bench.cpp | 137 ++++++++++++++++++
3 files changed, 332 insertions(+), 60 deletions(-)
create mode 100644 libcxx/test/benchmarks/algorithms/sorting/binary_search.bench.cpp
create mode 100644 libcxx/test/benchmarks/algorithms/sorting/equal_range.bench.cpp
diff --git a/libcxx/test/benchmarks/algorithms/nonmodifying/lower_upper_bound.bench.cpp b/libcxx/test/benchmarks/algorithms/nonmodifying/lower_upper_bound.bench.cpp
index 16ef348539776..8005cea67e0cd 100644
--- a/libcxx/test/benchmarks/algorithms/nonmodifying/lower_upper_bound.bench.cpp
+++ b/libcxx/test/benchmarks/algorithms/nonmodifying/lower_upper_bound.bench.cpp
@@ -6,13 +6,13 @@
//
//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: c++03, c++11, c++14, c++17
#include <algorithm>
+#include <cstddef>
#include <deque>
#include <forward_list>
#include <list>
-#include <numeric>
#include <random>
#include <vector>
@@ -20,64 +20,73 @@
#include "../../GenerateInput.h"
int main(int argc, char** argv) {
- {
- auto bm = []<class Container>(benchmark::State& state) static {
- std::mt19937_64 rng{123456};
-
- using value_type = typename Container::value_type;
-
- std::vector<value_type> vec;
- for (int64_t i = 0; i != state.range(); ++i)
- vec.emplace_back(Generate<typename Container::value_type>::random());
- std::sort(vec.begin(), vec.end());
-
- Container c(vec.begin(), vec.end());
-
- for (auto _ : state) {
- auto result = std::lower_bound(c.begin(), c.end(), vec[rng() % vec.size()]);
- benchmark::DoNotOptimize(result);
- benchmark::DoNotOptimize(vec);
- }
- };
-
- auto register_benchmark = [&]<class Container>(std::type_identity<Container>, std::string name) {
- benchmark::RegisterBenchmark(name, bm.template operator()<Container>)->Arg(8)->Arg(100)->Arg(8192);
- };
-
- register_benchmark(std::type_identity<std::vector<int>>{}, "std::lower_bound(std::vector<int>)");
- register_benchmark(std::type_identity<std::deque<int>>{}, "std::lower_bound(std::deque<int>)");
- register_benchmark(std::type_identity<std::list<int>>{}, "std::lower_bound(std::list<int>)");
- register_benchmark(std::type_identity<std::forward_list<int>>{}, "std::lower_bound(std::forward_list<int>)");
- }
- {
- auto bm = []<class Container>(benchmark::State& state) static {
- std::mt19937_64 rng{123456};
-
- using value_type = typename Container::value_type;
-
- std::vector<value_type> vec;
- for (int64_t i = 0; i != state.range(); ++i)
- vec.emplace_back(Generate<typename Container::value_type>::random());
- std::sort(vec.begin(), vec.end());
-
- Container c(vec.begin(), vec.end());
-
- for (auto _ : state) {
- auto result = std::upper_bound(c.begin(), c.end(), vec[rng() % vec.size()]);
- benchmark::DoNotOptimize(result);
- benchmark::DoNotOptimize(vec);
- }
- };
-
- auto register_benchmark = [&]<class Container>(std::type_identity<Container>, std::string name) {
- benchmark::RegisterBenchmark(name, bm.template operator()<Container>)->Arg(8)->Arg(100)->Arg(8192);
- };
-
- register_benchmark(std::type_identity<std::vector<int>>{}, "std::upper_bound(std::vector<int>)");
- register_benchmark(std::type_identity<std::deque<int>>{}, "std::upper_bound(std::deque<int>)");
- register_benchmark(std::type_identity<std::list<int>>{}, "std::upper_bound(std::list<int>)");
- register_benchmark(std::type_identity<std::forward_list<int>>{}, "std::upper_bound(std::forward_list<int>)");
- }
+ auto std_lower_bound = [](auto first, auto last, auto const& value) { return std::lower_bound(first, last, value); };
+ auto std_lower_bound_pred = [](auto first, auto last, auto const& value) {
+ return std::lower_bound(first, last, value, [](auto x, auto y) {
+ benchmark::DoNotOptimize(x);
+ benchmark::DoNotOptimize(y);
+ return x < y;
+ });
+ };
+ auto std_upper_bound = [](auto first, auto last, auto const& value) { return std::upper_bound(first, last, value); };
+ auto std_upper_bound_pred = [](auto first, auto last, auto const& value) {
+ return std::upper_bound(first, last, value, [](auto x, auto y) {
+ benchmark::DoNotOptimize(x);
+ benchmark::DoNotOptimize(y);
+ return x < y;
+ });
+ };
+
+ // Benchmark {lower_bound,upper_bound} on a sorted sequence, looking up a random element that
+ // is present in the sequence.
+ auto bm = []<class Container>(std::string name, auto lookup) {
+ benchmark::RegisterBenchmark(
+ name,
+ [lookup](auto& st) {
+ using ValueType = typename Container::value_type;
+ std::size_t const size = st.range(0);
+
+ // Random sorted data
+ std::vector<ValueType> data(size);
+ std::generate_n(data.begin(), size, &Generate<ValueType>::random);
+ std::sort(data.begin(), data.end());
+
+ // Precompute a bunch of random keys.
+ std::vector<ValueType> keys(data);
+ std::shuffle(keys.begin(), keys.end(), getRandomEngine());
+
+ Container c(data.begin(), data.end());
+ std::size_t pos = 0;
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ auto result = lookup(c.begin(), c.end(), keys[pos]);
+ benchmark::DoNotOptimize(result);
+ if (++pos == keys.size())
+ pos = 0;
+ }
+ })
+ ->Arg(8)
+ ->Arg(100)
+ ->Arg(8192);
+ };
+
+ bm.operator()<std::vector<int>>("std::lower_bound(std::vector<int>)", std_lower_bound);
+ bm.operator()<std::deque<int>>("std::lower_bound(std::deque<int>)", std_lower_bound);
+ bm.operator()<std::list<int>>("std::lower_bound(std::list<int>)", std_lower_bound);
+ bm.operator()<std::forward_list<int>>("std::lower_bound(std::forward_list<int>)", std_lower_bound);
+ bm.operator()<std::vector<int>>("std::lower_bound(std::vector<int>, pred)", std_lower_bound_pred);
+ bm.operator()<std::deque<int>>("std::lower_bound(std::deque<int>, pred)", std_lower_bound_pred);
+ bm.operator()<std::list<int>>("std::lower_bound(std::list<int>, pred)", std_lower_bound_pred);
+ bm.operator()<std::forward_list<int>>("std::lower_bound(std::forward_list<int>, pred)", std_lower_bound_pred);
+
+ bm.operator()<std::vector<int>>("std::upper_bound(std::vector<int>)", std_upper_bound);
+ bm.operator()<std::deque<int>>("std::upper_bound(std::deque<int>)", std_upper_bound);
+ bm.operator()<std::list<int>>("std::upper_bound(std::list<int>)", std_upper_bound);
+ bm.operator()<std::forward_list<int>>("std::upper_bound(std::forward_list<int>)", std_upper_bound);
+ bm.operator()<std::vector<int>>("std::upper_bound(std::vector<int>, pred)", std_upper_bound_pred);
+ bm.operator()<std::deque<int>>("std::upper_bound(std::deque<int>, pred)", std_upper_bound_pred);
+ bm.operator()<std::list<int>>("std::upper_bound(std::list<int>, pred)", std_upper_bound_pred);
+ bm.operator()<std::forward_list<int>>("std::upper_bound(std::forward_list<int>, pred)", std_upper_bound_pred);
benchmark::Initialize(&argc, argv);
benchmark::RunSpecifiedBenchmarks();
diff --git a/libcxx/test/benchmarks/algorithms/sorting/binary_search.bench.cpp b/libcxx/test/benchmarks/algorithms/sorting/binary_search.bench.cpp
new file mode 100644
index 0000000000000..1ceeab794dfd8
--- /dev/null
+++ b/libcxx/test/benchmarks/algorithms/sorting/binary_search.bench.cpp
@@ -0,0 +1,126 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 <cstddef>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <random>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+#include "../../GenerateInput.h"
+
+int main(int argc, char** argv) {
+ auto std_binary_search = [](auto first, auto last, auto const& value) {
+ return std::binary_search(first, last, value);
+ };
+ auto std_binary_search_pred = [](auto first, auto last, auto const& value) {
+ return std::binary_search(first, last, value, [](auto x, auto y) {
+ benchmark::DoNotOptimize(x);
+ benchmark::DoNotOptimize(y);
+ return x < y;
+ });
+ };
+
+ // Benchmark binary_search looking up a random key that is present in the sequence.
+ {
+ auto bm = []<class Container>(std::string name, auto binary_search) {
+ benchmark::RegisterBenchmark(
+ name,
+ [binary_search](auto& st) {
+ using ValueType = typename Container::value_type;
+ std::size_t const size = st.range(0);
+
+ // Random sorted data
+ std::vector<ValueType> data(size);
+ std::generate_n(data.begin(), size, &Generate<ValueType>::random);
+ std::sort(data.begin(), data.end());
+
+ // Precompute a bunch of random keys.
+ std::vector<ValueType> keys(data);
+ std::shuffle(keys.begin(), keys.end(), getRandomEngine());
+
+ Container c(data.begin(), data.end());
+ std::size_t pos = 0;
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ bool result = binary_search(c.begin(), c.end(), keys[pos]);
+ benchmark::DoNotOptimize(result);
+ if (++pos == keys.size())
+ pos = 0;
+ }
+ })
+ ->Arg(8)
+ ->Arg(100)
+ ->Arg(8192);
+ };
+ // clang-format off
+ bm.operator()<std::vector<int>>("std::binary_search(vector<int>) (present)", std_binary_search);
+ bm.operator()<std::deque<int>>("std::binary_search(deque<int>) (present)", std_binary_search);
+ bm.operator()<std::list<int>>("std::binary_search(list<int>) (present)", std_binary_search);
+ bm.operator()<std::forward_list<int>>("std::binary_search(forward_list<int>) (present)", std_binary_search);
+
+ bm.operator()<std::vector<int>>("std::binary_search(vector<int>, pred) (present)", std_binary_search_pred);
+ bm.operator()<std::deque<int>>("std::binary_search(deque<int>, pred) (present)", std_binary_search_pred);
+ bm.operator()<std::list<int>>("std::binary_search(list<int>, pred) (present)", std_binary_search_pred);
+ bm.operator()<std::forward_list<int>>("std::binary_search(forward_list<int>, pred) (present)", std_binary_search_pred);
+ // clang-format on
+ }
+
+ // Benchmark binary_search looking up a key that is absent from the sequence.
+ {
+ auto bm = []<class Container>(std::string name, auto binary_search) {
+ benchmark::RegisterBenchmark(
+ name,
+ [binary_search](auto& st) {
+ using ValueType = typename Container::value_type;
+ std::size_t const size = st.range(0);
+
+ // Random sorted data
+ std::vector<ValueType> data(size);
+ std::generate_n(data.begin(), size, &Generate<ValueType>::random);
+ std::sort(data.begin(), data.end());
+
+ // Find a key that isn't in the sequence
+ ValueType absent = Generate<ValueType>::random();
+ while (std::find(data.begin(), data.end(), absent) != data.end())
+ absent = Generate<ValueType>::random();
+
+ Container c(data.begin(), data.end());
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ bool result = binary_search(c.begin(), c.end(), absent);
+ benchmark::DoNotOptimize(result);
+ }
+ })
+ ->Arg(8)
+ ->Arg(100)
+ ->Arg(8192);
+ };
+ // clang-format off
+ bm.operator()<std::vector<int>>("std::binary_search(vector<int>) (absent)", std_binary_search);
+ bm.operator()<std::deque<int>>("std::binary_search(deque<int>) (absent)", std_binary_search);
+ bm.operator()<std::list<int>>("std::binary_search(list<int>) (absent)", std_binary_search);
+ bm.operator()<std::forward_list<int>>("std::binary_search(forward_list<int>) (absent)", std_binary_search);
+
+ bm.operator()<std::vector<int>>("std::binary_search(vector<int>, pred) (absent)", std_binary_search_pred);
+ bm.operator()<std::deque<int>>("std::binary_search(deque<int>, pred) (absent)", std_binary_search_pred);
+ bm.operator()<std::list<int>>("std::binary_search(list<int>, pred) (absent)", std_binary_search_pred);
+ bm.operator()<std::forward_list<int>>("std::binary_search(forward_list<int>, pred) (absent)", std_binary_search_pred);
+ // clang-format on
+ }
+
+ benchmark::Initialize(&argc, argv);
+ benchmark::RunSpecifiedBenchmarks();
+ benchmark::Shutdown();
+ return 0;
+}
diff --git a/libcxx/test/benchmarks/algorithms/sorting/equal_range.bench.cpp b/libcxx/test/benchmarks/algorithms/sorting/equal_range.bench.cpp
new file mode 100644
index 0000000000000..c984554b839ad
--- /dev/null
+++ b/libcxx/test/benchmarks/algorithms/sorting/equal_range.bench.cpp
@@ -0,0 +1,137 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 <cstddef>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <numeric>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+
+int main(int argc, char** argv) {
+ auto std_equal_range = [](auto first, auto last, auto const& value) { return std::equal_range(first, last, value); };
+ auto std_equal_range_pred = [](auto first, auto last, auto const& value) {
+ return std::equal_range(first, last, value, [](auto x, auto y) {
+ benchmark::DoNotOptimize(x);
+ benchmark::DoNotOptimize(y);
+ return x < y;
+ });
+ };
+
+ // The range we find is a single element.
+ {
+ auto bm = []<class Container>(std::string name, auto equal_range) {
+ benchmark::RegisterBenchmark(
+ name,
+ [equal_range](auto& st) {
+ std::size_t const size = st.range(0);
+ std::vector<int> data(size);
+ std::iota(data.begin(), data.end(), 0);
+ int const key = static_cast<int>(size / 2);
+
+ Container c(data.begin(), data.end());
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ auto result = equal_range(c.begin(), c.end(), key);
+ benchmark::DoNotOptimize(result);
+ }
+ })
+ ->Arg(8)
+ ->Arg(100)
+ ->Arg(8192);
+ };
+ bm.operator()<std::vector<int>>("std::equal_range(vector<int>) (unique)", std_equal_range);
+ bm.operator()<std::deque<int>>("std::equal_range(deque<int>) (unique)", std_equal_range);
+ bm.operator()<std::list<int>>("std::equal_range(list<int>) (unique)", std_equal_range);
+ bm.operator()<std::forward_list<int>>("std::equal_range(forward_list<int>) (unique)", std_equal_range);
+ bm.operator()<std::vector<int>>("std::equal_range(vector<int>, pred) (unique)", std_equal_range_pred);
+ bm.operator()<std::deque<int>>("std::equal_range(deque<int>, pred) (unique)", std_equal_range_pred);
+ bm.operator()<std::list<int>>("std::equal_range(list<int>, pred) (unique)", std_equal_range_pred);
+ bm.operator()<std::forward_list<int>>("std::equal_range(forward_list<int>, pred) (unique)", std_equal_range_pred);
+ }
+
+ // The range we find is a large part of the entire range.
+ // Data looks like [0, 1, 2, 2, 2, 2, 2, 7, 8, 9], we match the 2's.
+ {
+ auto bm = []<class Container>(std::string name, auto equal_range) {
+ benchmark::RegisterBenchmark(
+ name,
+ [equal_range](auto& st) {
+ std::size_t const size = st.range(0);
+ std::size_t const subrange_size = size / 2;
+ std::size_t const left_flank = (size - subrange_size) / 2;
+ std::vector<int> data(size);
+ std::iota(data.begin(), data.end(), 0); // [0, 1, 2, 3, ..., 8, 9]
+ int const key = data[left_flank];
+ std::fill_n(data.begin() + left_flank, subrange_size,
+ key); // [0, 1, 2, 3, 3, 3, 3, ..., 8, 9]
+
+ Container c(data.begin(), data.end());
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ auto result = equal_range(c.begin(), c.end(), key);
+ benchmark::DoNotOptimize(result);
+ }
+ })
+ ->Arg(8)
+ ->Arg(100)
+ ->Arg(8192);
+ };
+ bm.operator()<std::vector<int>>("std::equal_range(vector<int>) (large range)", std_equal_range);
+ bm.operator()<std::deque<int>>("std::equal_range(deque<int>) (large range)", std_equal_range);
+ bm.operator()<std::list<int>>("std::equal_range(list<int>) (large range)", std_equal_range);
+ bm.operator()<std::forward_list<int>>("std::equal_range(forward_list<int>) (large range)", std_equal_range);
+ bm.operator()<std::vector<int>>("std::equal_range(vector<int>, pred) (large range)", std_equal_range_pred);
+ bm.operator()<std::deque<int>>("std::equal_range(deque<int>, pred) (large range)", std_equal_range_pred);
+ bm.operator()<std::list<int>>("std::equal_range(list<int>, pred) (large range)", std_equal_range_pred);
+ bm.operator()<std::forward_list<int>>(
+ "std::equal_range(forward_list<int>, pred) (large range)", std_equal_range_pred);
+ }
+
+ // The searched-for value is not present, so the found range is empty.
+ {
+ auto bm = []<class Container>(std::string name, auto equal_range) {
+ benchmark::RegisterBenchmark(
+ name,
+ [equal_range](auto& st) {
+ std::size_t const size = st.range(0);
+ std::vector<int> data(size);
+ std::iota(data.begin(), data.end(), 0);
+ int const key = static_cast<int>(size); // one past the last element
+
+ Container c(data.begin(), data.end());
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ auto result = equal_range(c.begin(), c.end(), key);
+ benchmark::DoNotOptimize(result);
+ }
+ })
+ ->Arg(8)
+ ->Arg(100)
+ ->Arg(8192);
+ };
+ bm.operator()<std::vector<int>>("std::equal_range(vector<int>) (absent)", std_equal_range);
+ bm.operator()<std::deque<int>>("std::equal_range(deque<int>) (absent)", std_equal_range);
+ bm.operator()<std::list<int>>("std::equal_range(list<int>) (absent)", std_equal_range);
+ bm.operator()<std::forward_list<int>>("std::equal_range(forward_list<int>) (absent)", std_equal_range);
+ bm.operator()<std::vector<int>>("std::equal_range(vector<int>, pred) (absent)", std_equal_range_pred);
+ bm.operator()<std::deque<int>>("std::equal_range(deque<int>, pred) (absent)", std_equal_range_pred);
+ bm.operator()<std::list<int>>("std::equal_range(list<int>, pred) (absent)", std_equal_range_pred);
+ bm.operator()<std::forward_list<int>>("std::equal_range(forward_list<int>, pred) (absent)", std_equal_range_pred);
+ }
+
+ benchmark::Initialize(&argc, argv);
+ benchmark::RunSpecifiedBenchmarks();
+ benchmark::Shutdown();
+ return 0;
+}
>From 814c0fe3d71f26cb9edac58738b95853d82e6e5d Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne.2 at gmail.com>
Date: Thu, 2 Jul 2026 16:18:26 -0400
Subject: [PATCH 2/3] Remove unused includes
---
.../test/benchmarks/algorithms/sorting/binary_search.bench.cpp | 1 -
.../benchmarks/algorithms/sorting/lower_upper_bound.bench.cpp | 1 -
2 files changed, 2 deletions(-)
diff --git a/libcxx/test/benchmarks/algorithms/sorting/binary_search.bench.cpp b/libcxx/test/benchmarks/algorithms/sorting/binary_search.bench.cpp
index 1ceeab794dfd8..101ffc418925d 100644
--- a/libcxx/test/benchmarks/algorithms/sorting/binary_search.bench.cpp
+++ b/libcxx/test/benchmarks/algorithms/sorting/binary_search.bench.cpp
@@ -13,7 +13,6 @@
#include <deque>
#include <forward_list>
#include <list>
-#include <random>
#include <vector>
#include "benchmark/benchmark.h"
diff --git a/libcxx/test/benchmarks/algorithms/sorting/lower_upper_bound.bench.cpp b/libcxx/test/benchmarks/algorithms/sorting/lower_upper_bound.bench.cpp
index 8005cea67e0cd..fbba276796d8a 100644
--- a/libcxx/test/benchmarks/algorithms/sorting/lower_upper_bound.bench.cpp
+++ b/libcxx/test/benchmarks/algorithms/sorting/lower_upper_bound.bench.cpp
@@ -13,7 +13,6 @@
#include <deque>
#include <forward_list>
#include <list>
-#include <random>
#include <vector>
#include "benchmark/benchmark.h"
>From 70f71300874780976e18f134d6cd0279db4b847a Mon Sep 17 00:00:00 2001
From: Louis Dionne <ldionne.2 at gmail.com>
Date: Tue, 14 Jul 2026 08:48:43 -0400
Subject: [PATCH 3/3] Remove DoNotOptimize
---
.../algorithms/sorting/binary_search.bench.cpp | 6 +-----
.../algorithms/sorting/equal_range.bench.cpp | 6 +-----
.../algorithms/sorting/lower_upper_bound.bench.cpp | 12 ++----------
3 files changed, 4 insertions(+), 20 deletions(-)
diff --git a/libcxx/test/benchmarks/algorithms/sorting/binary_search.bench.cpp b/libcxx/test/benchmarks/algorithms/sorting/binary_search.bench.cpp
index 101ffc418925d..1781fb68526e5 100644
--- a/libcxx/test/benchmarks/algorithms/sorting/binary_search.bench.cpp
+++ b/libcxx/test/benchmarks/algorithms/sorting/binary_search.bench.cpp
@@ -23,11 +23,7 @@ int main(int argc, char** argv) {
return std::binary_search(first, last, value);
};
auto std_binary_search_pred = [](auto first, auto last, auto const& value) {
- return std::binary_search(first, last, value, [](auto x, auto y) {
- benchmark::DoNotOptimize(x);
- benchmark::DoNotOptimize(y);
- return x < y;
- });
+ return std::binary_search(first, last, value, [](auto x, auto y) { return x < y; });
};
// Benchmark binary_search looking up a random key that is present in the sequence.
diff --git a/libcxx/test/benchmarks/algorithms/sorting/equal_range.bench.cpp b/libcxx/test/benchmarks/algorithms/sorting/equal_range.bench.cpp
index c984554b839ad..b29834d669cef 100644
--- a/libcxx/test/benchmarks/algorithms/sorting/equal_range.bench.cpp
+++ b/libcxx/test/benchmarks/algorithms/sorting/equal_range.bench.cpp
@@ -21,11 +21,7 @@
int main(int argc, char** argv) {
auto std_equal_range = [](auto first, auto last, auto const& value) { return std::equal_range(first, last, value); };
auto std_equal_range_pred = [](auto first, auto last, auto const& value) {
- return std::equal_range(first, last, value, [](auto x, auto y) {
- benchmark::DoNotOptimize(x);
- benchmark::DoNotOptimize(y);
- return x < y;
- });
+ return std::equal_range(first, last, value, [](auto x, auto y) { return x < y; });
};
// The range we find is a single element.
diff --git a/libcxx/test/benchmarks/algorithms/sorting/lower_upper_bound.bench.cpp b/libcxx/test/benchmarks/algorithms/sorting/lower_upper_bound.bench.cpp
index fbba276796d8a..6877184b8cc0c 100644
--- a/libcxx/test/benchmarks/algorithms/sorting/lower_upper_bound.bench.cpp
+++ b/libcxx/test/benchmarks/algorithms/sorting/lower_upper_bound.bench.cpp
@@ -21,19 +21,11 @@
int main(int argc, char** argv) {
auto std_lower_bound = [](auto first, auto last, auto const& value) { return std::lower_bound(first, last, value); };
auto std_lower_bound_pred = [](auto first, auto last, auto const& value) {
- return std::lower_bound(first, last, value, [](auto x, auto y) {
- benchmark::DoNotOptimize(x);
- benchmark::DoNotOptimize(y);
- return x < y;
- });
+ return std::lower_bound(first, last, value, [](auto x, auto y) { return x < y; });
};
auto std_upper_bound = [](auto first, auto last, auto const& value) { return std::upper_bound(first, last, value); };
auto std_upper_bound_pred = [](auto first, auto last, auto const& value) {
- return std::upper_bound(first, last, value, [](auto x, auto y) {
- benchmark::DoNotOptimize(x);
- benchmark::DoNotOptimize(y);
- return x < y;
- });
+ return std::upper_bound(first, last, value, [](auto x, auto y) { return x < y; });
};
// Benchmark {lower_bound,upper_bound} on a sorted sequence, looking up a random element that
More information about the libcxx-commits
mailing list