[libcxx-commits] [libcxx] 4107544 - [libc++] Add benchmarks for partitioning algorithms (#127324)
via libcxx-commits
libcxx-commits at lists.llvm.org
Mon Mar 24 09:24:47 PDT 2025
Author: Louis Dionne
Date: 2025-03-24T12:24:43-04:00
New Revision: 410754410fbafa9c642e3ab05d0cad1eeb456432
URL: https://github.com/llvm/llvm-project/commit/410754410fbafa9c642e3ab05d0cad1eeb456432
DIFF: https://github.com/llvm/llvm-project/commit/410754410fbafa9c642e3ab05d0cad1eeb456432.diff
LOG: [libc++] Add benchmarks for partitioning algorithms (#127324)
This patch adds benchmarks for std::partition, is_partitioned, etc and
their ranges:: variants.
Added:
libcxx/test/benchmarks/algorithms/partitions/is_partitioned.bench.cpp
libcxx/test/benchmarks/algorithms/partitions/partition.bench.cpp
libcxx/test/benchmarks/algorithms/partitions/partition_copy.bench.cpp
libcxx/test/benchmarks/algorithms/partitions/partition_point.bench.cpp
libcxx/test/benchmarks/algorithms/partitions/stable_partition.bench.cpp
Modified:
libcxx/include/module.modulemap
Removed:
libcxx/test/benchmarks/algorithms/algorithms.partition_point.bench.cpp
################################################################################
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index 1809fe5c7f0f7..1d1631eb213ed 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -687,6 +687,7 @@ module std [system] {
}
module ranges_partition {
header "__algorithm/ranges_partition.h"
+ export std.ranges.subrange // return type
}
module ranges_pop_heap {
header "__algorithm/ranges_pop_heap.h"
@@ -786,6 +787,7 @@ module std [system] {
}
module ranges_stable_partition {
header "__algorithm/ranges_stable_partition.h"
+ export std.ranges.subrange // return type
}
module ranges_stable_sort {
header "__algorithm/ranges_stable_sort.h"
diff --git a/libcxx/test/benchmarks/algorithms/algorithms.partition_point.bench.cpp b/libcxx/test/benchmarks/algorithms/algorithms.partition_point.bench.cpp
deleted file mode 100644
index e0bd7e36f78ad..0000000000000
--- a/libcxx/test/benchmarks/algorithms/algorithms.partition_point.bench.cpp
+++ /dev/null
@@ -1,131 +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 <array>
-#include <cassert>
-#include <cstdint>
-#include <tuple>
-#include <vector>
-
-#include "benchmark/benchmark.h"
-
-#include "../CartesianBenchmarks.h"
-#include "../GenerateInput.h"
-
-namespace {
-
-template <typename I, typename N>
-std::array<I, 10> every_10th_percentile_N(I first, N n) {
- N step = n / 10;
- std::array<I, 10> res;
-
- for (size_t i = 0; i < 10; ++i) {
- res[i] = first;
- std::advance(first, step);
- }
-
- return res;
-}
-
-template <class IntT>
-struct TestIntBase {
- static std::vector<IntT> generateInput(size_t size) {
- std::vector<IntT> Res(size);
- std::generate(Res.begin(), Res.end(), [] { return getRandomInteger<IntT>(0, std::numeric_limits<IntT>::max()); });
- return Res;
- }
-};
-
-struct TestInt32 : TestIntBase<std::int32_t> {
- static constexpr const char* Name = "TestInt32";
-};
-
-struct TestInt64 : TestIntBase<std::int64_t> {
- static constexpr const char* Name = "TestInt64";
-};
-
-struct TestUint32 : TestIntBase<std::uint32_t> {
- static constexpr const char* Name = "TestUint32";
-};
-
-struct TestMediumString {
- static constexpr const char* Name = "TestMediumString";
- static constexpr size_t StringSize = 32;
-
- static std::vector<std::string> generateInput(size_t size) {
- std::vector<std::string> Res(size);
- std::generate(Res.begin(), Res.end(), [] { return getRandomString(StringSize); });
- return Res;
- }
-};
-
-using AllTestTypes = std::tuple<TestInt32, TestInt64, TestUint32, TestMediumString>;
-
-struct LowerBoundAlg {
- template <class I, class V>
- I operator()(I first, I last, const V& value) const {
- return std::lower_bound(first, last, value);
- }
-
- static constexpr const char* Name = "LowerBoundAlg";
-};
-
-struct UpperBoundAlg {
- template <class I, class V>
- I operator()(I first, I last, const V& value) const {
- return std::upper_bound(first, last, value);
- }
-
- static constexpr const char* Name = "UpperBoundAlg";
-};
-
-struct EqualRangeAlg {
- template <class I, class V>
- std::pair<I, I> operator()(I first, I last, const V& value) const {
- return std::equal_range(first, last, value);
- }
-
- static constexpr const char* Name = "EqualRangeAlg";
-};
-
-using AllAlgs = std::tuple<LowerBoundAlg, UpperBoundAlg, EqualRangeAlg>;
-
-template <class Alg, class TestType>
-struct PartitionPointBench {
- size_t Quantity;
-
- std::string name() const {
- return std::string("PartitionPointBench_") + Alg::Name + "_" + TestType::Name + '/' + std::to_string(Quantity);
- }
-
- void run(benchmark::State& state) const {
- auto Data = TestType::generateInput(Quantity);
- std::sort(Data.begin(), Data.end());
- auto Every10Percentile = every_10th_percentile_N(Data.begin(), Data.size());
-
- for (auto _ : state) {
- for (auto Test : Every10Percentile)
- benchmark::DoNotOptimize(Alg{}(Data.begin(), Data.end(), *Test));
- }
- }
-};
-
-} // namespace
-
-int main(int argc, char** argv) {
- benchmark::Initialize(&argc, argv);
- if (benchmark::ReportUnrecognizedArguments(argc, argv))
- return 1;
-
- const std::vector<size_t> Quantities = {1 << 8, 1 << 10, 1 << 20};
- makeCartesianProductBenchmark<PartitionPointBench, AllAlgs, AllTestTypes>(Quantities);
- benchmark::RunSpecifiedBenchmarks();
-}
diff --git a/libcxx/test/benchmarks/algorithms/partitions/is_partitioned.bench.cpp b/libcxx/test/benchmarks/algorithms/partitions/is_partitioned.bench.cpp
new file mode 100644
index 0000000000000..fa9873b8db1aa
--- /dev/null
+++ b/libcxx/test/benchmarks/algorithms/partitions/is_partitioned.bench.cpp
@@ -0,0 +1,96 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 <cassert>
+#include <cstddef>
+#include <deque>
+#include <iterator>
+#include <list>
+#include <string>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+#include "../../GenerateInput.h"
+
+auto compute_median(auto first, auto last) {
+ std::vector v(first, last);
+ auto middle = v.begin() + v.size() / 2;
+ std::nth_element(v.begin(), middle, v.end());
+ return *middle;
+}
+
+int main(int argc, char** argv) {
+ auto std_is_partitioned = [](auto first, auto last, auto pred) { return std::is_partitioned(first, last, pred); };
+
+ auto bm = []<class Container, bool Partitioned>(std::string name, auto is_partitioned) {
+ benchmark::RegisterBenchmark(
+ name,
+ [is_partitioned](auto& st) {
+ std::size_t const size = st.range(0);
+ using ValueType = typename Container::value_type;
+ Container c;
+ std::generate_n(std::back_inserter(c), size, [] { return Generate<ValueType>::random(); });
+
+ // Partition the container in two equally-sized halves, ensuring the median
+ // value appears in the left half. Note that the median value isn't located
+ // in the middle -- this isn't std::nth_element.
+ ValueType median = compute_median(c.begin(), c.end());
+ auto pred = [median](auto const& element) { return element <= median; };
+ std::partition(c.begin(), c.end(), pred);
+ assert(std::is_partitioned(c.begin(), c.end(), pred));
+
+ if constexpr (!Partitioned) {
+ // De-partition the container by swapping the element containing the median
+ // value with the last one.
+ auto median_it = std::find(c.begin(), c.end(), median);
+ auto last_it = std::next(c.begin(), c.size() - 1);
+ std::iter_swap(median_it, last_it);
+ assert(!std::is_partitioned(c.begin(), c.end(), pred));
+ }
+
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ auto result = is_partitioned(c.begin(), c.end(), pred);
+ benchmark::DoNotOptimize(result);
+ }
+ })
+ ->Arg(32)
+ ->Arg(50) // non power-of-two
+ ->Arg(1024)
+ ->Arg(8192);
+ };
+
+ // std::is_partitioned
+ bm.operator()<std::vector<int>, true>("std::is_partitioned(vector<int>) (partitioned)", std_is_partitioned);
+ bm.operator()<std::vector<int>, false>("std::is_partitioned(vector<int>) (unpartitioned)", std_is_partitioned);
+
+ bm.operator()<std::deque<int>, true>("std::is_partitioned(deque<int>) (partitioned)", std_is_partitioned);
+ bm.operator()<std::deque<int>, false>("std::is_partitioned(deque<int>) (unpartitioned)", std_is_partitioned);
+
+ bm.operator()<std::list<int>, true>("std::is_partitioned(list<int>) (partitioned)", std_is_partitioned);
+ bm.operator()<std::list<int>, false>("std::is_partitioned(list<int>) (unpartitioned)", std_is_partitioned);
+
+ // ranges::is_partitioned
+ bm.operator()<std::vector<int>, true>("rng::is_partitioned(vector<int>) (partitioned)", std::ranges::is_partitioned);
+ bm.operator()<std::vector<int>, false>(
+ "rng::is_partitioned(vector<int>) (unpartitioned)", std::ranges::is_partitioned);
+
+ bm.operator()<std::deque<int>, true>("rng::is_partitioned(deque<int>) (partitioned)", std::ranges::is_partitioned);
+ bm.operator()<std::deque<int>, false>("rng::is_partitioned(deque<int>) (unpartitioned)", std::ranges::is_partitioned);
+
+ bm.operator()<std::list<int>, true>("rng::is_partitioned(list<int>) (partitioned)", std::ranges::is_partitioned);
+ bm.operator()<std::list<int>, false>("rng::is_partitioned(list<int>) (unpartitioned)", std::ranges::is_partitioned);
+
+ benchmark::Initialize(&argc, argv);
+ benchmark::RunSpecifiedBenchmarks();
+ benchmark::Shutdown();
+ return 0;
+}
diff --git a/libcxx/test/benchmarks/algorithms/partitions/partition.bench.cpp b/libcxx/test/benchmarks/algorithms/partitions/partition.bench.cpp
new file mode 100644
index 0000000000000..2c69966a62091
--- /dev/null
+++ b/libcxx/test/benchmarks/algorithms/partitions/partition.bench.cpp
@@ -0,0 +1,133 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 <cassert>
+#include <cstddef>
+#include <deque>
+#include <iterator>
+#include <list>
+#include <string>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+#include "../../GenerateInput.h"
+
+auto compute_median(auto first, auto last) {
+ std::vector v(first, last);
+ auto middle = v.begin() + v.size() / 2;
+ std::nth_element(v.begin(), middle, v.end());
+ return *middle;
+}
+
+int main(int argc, char** argv) {
+ auto std_partition = [](auto first, auto last, auto pred) { return std::partition(first, last, pred); };
+
+ // Benchmark {std,ranges}::partition on a fully unpartitionned sequence, i.e. a lot of elements
+ // have to be moved around in order to partition the range.
+ {
+ auto bm = []<class Container>(std::string name, auto partition) {
+ benchmark::RegisterBenchmark(
+ name,
+ [partition](auto& st) {
+ std::size_t const size = st.range(0);
+ using ValueType = typename Container::value_type;
+ Container c;
+ std::generate_n(std::back_inserter(c), size, [] { return Generate<ValueType>::random(); });
+
+ ValueType median = compute_median(c.begin(), c.end());
+ auto pred1 = [median](auto const& element) { return element < median; };
+ auto pred2 = [median](auto const& element) { return element > median; };
+ bool toggle = false;
+
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ // By toggling the predicate, we have to move almost all elements in the sequence
+ // to restore the partition.
+ if (toggle) {
+ auto result = partition(c.begin(), c.end(), pred1);
+ benchmark::DoNotOptimize(result);
+ } else {
+ auto result = partition(c.begin(), c.end(), pred2);
+ benchmark::DoNotOptimize(result);
+ }
+ toggle = !toggle;
+ }
+ })
+ ->Arg(32)
+ ->Arg(50) // non power-of-two
+ ->Arg(1024)
+ ->Arg(8192);
+ };
+
+ // std::partition
+ bm.operator()<std::vector<int>>("std::partition(vector<int>) (dense)", std_partition);
+ bm.operator()<std::deque<int>>("std::partition(deque<int>) (dense)", std_partition);
+ bm.operator()<std::list<int>>("std::partition(list<int>) (dense)", std_partition);
+
+ // ranges::partition
+ bm.operator()<std::vector<int>>("rng::partition(vector<int>) (dense)", std::ranges::partition);
+ bm.operator()<std::deque<int>>("rng::partition(deque<int>) (dense)", std::ranges::partition);
+ bm.operator()<std::list<int>>("rng::partition(list<int>) (dense)", std::ranges::partition);
+ }
+
+ // Benchmark {std,ranges}::partition on a mostly partitioned sequence, i.e. only 10% of the elements
+ // have to be moved around in order to partition the range.
+ {
+ auto bm = []<class Container>(std::string name, auto partition) {
+ benchmark::RegisterBenchmark(
+ name,
+ [partition](auto& st) {
+ std::size_t const size = st.range(0);
+ using ValueType = typename Container::value_type;
+ Container c;
+ std::generate_n(std::back_inserter(c), size, [] { return Generate<ValueType>::random(); });
+ ValueType median = compute_median(c.begin(), c.end());
+ auto pred = [median](auto const& element) { return element < median; };
+ std::partition(c.begin(), c.end(), pred);
+
+ // Between iterations, we swap 5% of the elements to the left of the median with 5% of the elements
+ // to the right of the median. This ensures that the range is slightly unpartitioned.
+ auto median_it = std::partition_point(c.begin(), c.end(), pred);
+ auto low = std::next(c.begin(), std::distance(c.begin(), median_it) - (size / 20));
+ auto high = std::next(median_it, size / 20);
+ auto shuffle = [&] { std::swap_ranges(low, median_it, high); };
+ shuffle();
+ assert(!std::is_partitioned(c.begin(), c.end(), pred));
+
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ auto result = partition(c.begin(), c.end(), pred);
+ benchmark::DoNotOptimize(result);
+ shuffle();
+ }
+ })
+ ->Arg(32)
+ ->Arg(50) // non power-of-two
+ ->Arg(1024)
+ ->Arg(8192);
+ };
+
+ // std::partition
+ bm.operator()<std::vector<int>>("std::partition(vector<int>) (sparse)", std_partition);
+ bm.operator()<std::deque<int>>("std::partition(deque<int>) (sparse)", std_partition);
+ bm.operator()<std::list<int>>("std::partition(list<int>) (sparse)", std_partition);
+
+ // ranges::partition
+ bm.operator()<std::vector<int>>("rng::partition(vector<int>) (sparse)", std::ranges::partition);
+ bm.operator()<std::deque<int>>("rng::partition(deque<int>) (sparse)", std::ranges::partition);
+ bm.operator()<std::list<int>>("rng::partition(list<int>) (sparse)", std::ranges::partition);
+ }
+
+ benchmark::Initialize(&argc, argv);
+ benchmark::RunSpecifiedBenchmarks();
+ benchmark::Shutdown();
+ return 0;
+}
diff --git a/libcxx/test/benchmarks/algorithms/partitions/partition_copy.bench.cpp b/libcxx/test/benchmarks/algorithms/partitions/partition_copy.bench.cpp
new file mode 100644
index 0000000000000..68cac0ffa23b4
--- /dev/null
+++ b/libcxx/test/benchmarks/algorithms/partitions/partition_copy.bench.cpp
@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 <iterator>
+#include <list>
+#include <string>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+#include "../../GenerateInput.h"
+
+auto compute_median(auto first, auto last) {
+ std::vector v(first, last);
+ auto middle = v.begin() + v.size() / 2;
+ std::nth_element(v.begin(), middle, v.end());
+ return *middle;
+}
+
+int main(int argc, char** argv) {
+ auto std_partition_copy = [](auto first, auto last, auto out_yes, auto out_no, auto pred) {
+ return std::partition_copy(first, last, out_yes, out_no, pred);
+ };
+
+ auto bm = []<class Container>(std::string name, auto partition_copy) {
+ benchmark::RegisterBenchmark(
+ name,
+ [partition_copy](auto& st) {
+ std::size_t const size = st.range(0);
+ using ValueType = typename Container::value_type;
+ Container c;
+ std::generate_n(std::back_inserter(c), size, [] { return Generate<ValueType>::random(); });
+
+ std::vector<ValueType> yes(size);
+ std::vector<ValueType> no(size);
+ ValueType median = compute_median(c.begin(), c.end());
+ auto pred = [median](auto const& element) { return element < median; };
+
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ benchmark::DoNotOptimize(yes);
+ benchmark::DoNotOptimize(no);
+ auto result = partition_copy(c.begin(), c.end(), yes.begin(), no.begin(), pred);
+ benchmark::DoNotOptimize(result);
+ }
+ })
+ ->Arg(32)
+ ->Arg(50) // non power-of-two
+ ->Arg(1024)
+ ->Arg(8192);
+ };
+
+ // std::partition_copy
+ bm.operator()<std::vector<int>>("std::partition_copy(vector<int>)", std_partition_copy);
+ bm.operator()<std::deque<int>>("std::partition_copy(deque<int>)", std_partition_copy);
+ bm.operator()<std::list<int>>("std::partition_copy(list<int>)", std_partition_copy);
+
+ // ranges::partition_copy
+ bm.operator()<std::vector<int>>("rng::partition_copy(vector<int>)", std::ranges::partition_copy);
+ bm.operator()<std::deque<int>>("rng::partition_copy(deque<int>)", std::ranges::partition_copy);
+ bm.operator()<std::list<int>>("rng::partition_copy(list<int>)", std::ranges::partition_copy);
+
+ benchmark::Initialize(&argc, argv);
+ benchmark::RunSpecifiedBenchmarks();
+ benchmark::Shutdown();
+ return 0;
+}
diff --git a/libcxx/test/benchmarks/algorithms/partitions/partition_point.bench.cpp b/libcxx/test/benchmarks/algorithms/partitions/partition_point.bench.cpp
new file mode 100644
index 0000000000000..2b98d16935cf8
--- /dev/null
+++ b/libcxx/test/benchmarks/algorithms/partitions/partition_point.bench.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 <iterator>
+#include <list>
+#include <string>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+#include "../../GenerateInput.h"
+
+auto compute_median(auto first, auto last) {
+ std::vector v(first, last);
+ auto middle = v.begin() + v.size() / 2;
+ std::nth_element(v.begin(), middle, v.end());
+ return *middle;
+}
+
+int main(int argc, char** argv) {
+ auto std_partition_point = [](auto first, auto last, auto pred) { return std::partition_point(first, last, pred); };
+
+ auto bm = []<class Container>(std::string name, auto partition_point) {
+ benchmark::RegisterBenchmark(
+ name,
+ [partition_point](auto& st) {
+ std::size_t const size = st.range(0);
+ using ValueType = typename Container::value_type;
+ Container c;
+ std::generate_n(std::back_inserter(c), size, [] { return Generate<ValueType>::random(); });
+
+ // Partition the container in two equally-sized halves. Based on experimentation, the running
+ // time of the algorithm doesn't change much depending on the size of the halves.
+ ValueType median = compute_median(c.begin(), c.end());
+ auto pred = [median](auto const& element) { return element < median; };
+ std::partition(c.begin(), c.end(), pred);
+ assert(std::is_partitioned(c.begin(), c.end(), pred));
+
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ auto result = partition_point(c.begin(), c.end(), pred);
+ benchmark::DoNotOptimize(result);
+ }
+ })
+ ->Arg(32)
+ ->Arg(50) // non power-of-two
+ ->Arg(1024)
+ ->Arg(8192);
+ };
+
+ // std::partition_point
+ bm.operator()<std::vector<int>>("std::partition_point(vector<int>)", std_partition_point);
+ bm.operator()<std::deque<int>>("std::partition_point(deque<int>)", std_partition_point);
+ bm.operator()<std::list<int>>("std::partition_point(list<int>)", std_partition_point);
+
+ // ranges::partition_point
+ bm.operator()<std::vector<int>>("rng::partition_point(vector<int>)", std::ranges::partition_point);
+ bm.operator()<std::deque<int>>("rng::partition_point(deque<int>)", std::ranges::partition_point);
+ bm.operator()<std::list<int>>("rng::partition_point(list<int>)", std::ranges::partition_point);
+
+ benchmark::Initialize(&argc, argv);
+ benchmark::RunSpecifiedBenchmarks();
+ benchmark::Shutdown();
+ return 0;
+}
diff --git a/libcxx/test/benchmarks/algorithms/partitions/stable_partition.bench.cpp b/libcxx/test/benchmarks/algorithms/partitions/stable_partition.bench.cpp
new file mode 100644
index 0000000000000..622a30506a46f
--- /dev/null
+++ b/libcxx/test/benchmarks/algorithms/partitions/stable_partition.bench.cpp
@@ -0,0 +1,183 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 <iterator>
+#include <list>
+#include <string>
+#include <vector>
+
+#include "count_new.h"
+#include "benchmark/benchmark.h"
+#include "../../GenerateInput.h"
+
+auto compute_median(auto first, auto last) {
+ std::vector v(first, last);
+ auto middle = v.begin() + v.size() / 2;
+ std::nth_element(v.begin(), middle, v.end());
+ return *middle;
+}
+
+int main(int argc, char** argv) {
+ auto std_stable_partition = [](auto first, auto last, auto pred) { return std::stable_partition(first, last, pred); };
+
+ // Benchmark {std,ranges}::stable_partition on a fully unpartitionned sequence, i.e. a lot of elements
+ // have to be moved around in order to partition the range.
+ {
+ auto bm = []<class Container>(std::string name, auto stable_partition) {
+ benchmark::RegisterBenchmark(
+ name,
+ [stable_partition](auto& st) {
+ std::size_t const size = st.range(0);
+ using ValueType = typename Container::value_type;
+ Container c;
+ std::generate_n(std::back_inserter(c), size, [] { return Generate<ValueType>::random(); });
+
+ ValueType median = compute_median(c.begin(), c.end());
+ auto pred1 = [median](auto const& element) { return element < median; };
+ auto pred2 = [median](auto const& element) { return element > median; };
+ bool toggle = false;
+
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ // By toggling the predicate, we have to move almost all elements in the sequence
+ // to restore the partition.
+ if (toggle) {
+ auto result = stable_partition(c.begin(), c.end(), pred1);
+ benchmark::DoNotOptimize(result);
+ } else {
+ auto result = stable_partition(c.begin(), c.end(), pred2);
+ benchmark::DoNotOptimize(result);
+ }
+ toggle = !toggle;
+ }
+ })
+ ->Arg(32)
+ ->Arg(50) // non power-of-two
+ ->Arg(1024)
+ ->Arg(8192);
+ };
+
+ // std::stable_partition
+ bm.operator()<std::vector<int>>("std::stable_partition(vector<int>) (dense)", std_stable_partition);
+ bm.operator()<std::deque<int>>("std::stable_partition(deque<int>) (dense)", std_stable_partition);
+ bm.operator()<std::list<int>>("std::stable_partition(list<int>) (dense)", std_stable_partition);
+
+ // ranges::stable_partition
+ bm.operator()<std::vector<int>>("rng::stable_partition(vector<int>) (dense)", std::ranges::stable_partition);
+ bm.operator()<std::deque<int>>("rng::stable_partition(deque<int>) (dense)", std::ranges::stable_partition);
+ bm.operator()<std::list<int>>("rng::stable_partition(list<int>) (dense)", std::ranges::stable_partition);
+ }
+
+ // Benchmark {std,ranges}::stable_partition on a mostly partitioned sequence, i.e. only 10% of the elements
+ // have to be moved around in order to partition the range.
+ {
+ auto bm = []<class Container>(std::string name, auto stable_partition) {
+ benchmark::RegisterBenchmark(
+ name,
+ [stable_partition](auto& st) {
+ std::size_t const size = st.range(0);
+ using ValueType = typename Container::value_type;
+ Container c;
+ std::generate_n(std::back_inserter(c), size, [] { return Generate<ValueType>::random(); });
+ ValueType median = compute_median(c.begin(), c.end());
+ auto pred = [median](auto const& element) { return element < median; };
+ std::partition(c.begin(), c.end(), pred);
+
+ // Between iterations, we swap 5% of the elements to the left of the median with 5% of the elements
+ // to the right of the median. This ensures that the range is slightly unpartitioned.
+ auto median_it = std::partition_point(c.begin(), c.end(), pred);
+ auto low = std::next(c.begin(), std::distance(c.begin(), median_it) - (size / 20));
+ auto high = std::next(median_it, size / 20);
+ auto shuffle = [&] { std::swap_ranges(low, median_it, high); };
+ shuffle();
+ assert(!std::is_partitioned(c.begin(), c.end(), pred));
+
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ auto result = stable_partition(c.begin(), c.end(), pred);
+ benchmark::DoNotOptimize(result);
+ shuffle();
+ }
+ })
+ ->Arg(32)
+ ->Arg(50) // non power-of-two
+ ->Arg(1024)
+ ->Arg(8192);
+ };
+
+ // std::stable_partition
+ bm.operator()<std::vector<int>>("std::stable_partition(vector<int>) (sparse)", std_stable_partition);
+ bm.operator()<std::deque<int>>("std::stable_partition(deque<int>) (sparse)", std_stable_partition);
+ bm.operator()<std::list<int>>("std::stable_partition(list<int>) (sparse)", std_stable_partition);
+
+ // ranges::stable_partition
+ bm.operator()<std::vector<int>>("rng::stable_partition(vector<int>) (sparse)", std::ranges::stable_partition);
+ bm.operator()<std::deque<int>>("rng::stable_partition(deque<int>) (sparse)", std::ranges::stable_partition);
+ bm.operator()<std::list<int>>("rng::stable_partition(list<int>) (sparse)", std::ranges::stable_partition);
+ }
+
+ // Benchmark {std,ranges}::stable_partition when memory allocation fails. The algorithm must fall back to
+ // a
diff erent algorithm that has
diff erent complexity guarantees.
+ {
+ auto bm = []<class Container>(std::string name, auto stable_partition) {
+ benchmark::RegisterBenchmark(
+ name,
+ [stable_partition](auto& st) {
+ std::size_t const size = st.range(0);
+ using ValueType = typename Container::value_type;
+ Container c;
+ std::generate_n(std::back_inserter(c), size, [] { return Generate<ValueType>::random(); });
+
+ ValueType median = compute_median(c.begin(), c.end());
+ auto pred1 = [median](auto const& element) { return element < median; };
+ auto pred2 = [median](auto const& element) { return element > median; };
+ bool toggle = false;
+
+ for ([[maybe_unused]] auto _ : st) {
+ benchmark::DoNotOptimize(c);
+ // Disable the ability to allocate memory inside this block
+ globalMemCounter.reset();
+ globalMemCounter.throw_after = 0;
+
+ if (toggle) {
+ auto result = stable_partition(c.begin(), c.end(), pred1);
+ benchmark::DoNotOptimize(result);
+ } else {
+ auto result = stable_partition(c.begin(), c.end(), pred2);
+ benchmark::DoNotOptimize(result);
+ }
+ toggle = !toggle;
+ }
+ })
+ ->Arg(32)
+ ->Arg(50) // non power-of-two
+ ->Arg(1024)
+ ->Arg(8192);
+ };
+
+ // std::stable_partition
+ bm.operator()<std::vector<int>>("std::stable_partition(vector<int>) (alloc fails)", std_stable_partition);
+ bm.operator()<std::deque<int>>("std::stable_partition(deque<int>) (alloc fails)", std_stable_partition);
+ bm.operator()<std::list<int>>("std::stable_partition(list<int>) (alloc fails)", std_stable_partition);
+
+ // ranges::stable_partition
+ bm.operator()<std::vector<int>>("rng::stable_partition(vector<int>) (alloc fails)", std::ranges::stable_partition);
+ bm.operator()<std::deque<int>>("rng::stable_partition(deque<int>) (alloc fails)", std::ranges::stable_partition);
+ bm.operator()<std::list<int>>("rng::stable_partition(list<int>) (alloc fails)", std::ranges::stable_partition);
+ }
+
+ benchmark::Initialize(&argc, argv);
+ benchmark::RunSpecifiedBenchmarks();
+ benchmark::Shutdown();
+ return 0;
+}
More information about the libcxx-commits
mailing list