diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index 82c51ba73e41e..41ba8c57abdd0 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 different algorithm that has different 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;
+}