[libcxx-commits] [libcxx] 75737ca - [libc++] Add benchmark for `std::exception_ptr` (#164278)

[via libcxx-commits]

Author: Adrian Vogelsgesang
Date: 2025-10-27T15:32:12+01:00
New Revision: 75737ca3985280d11c8a1513d24e0e4cf730940b

URL: https://github.com/llvm/llvm-project/commit/75737ca3985280d11c8a1513d24e0e4cf730940b
DIFF: https://github.com/llvm/llvm-project/commit/75737ca3985280d11c8a1513d24e0e4cf730940b.diff

LOG: [libc++] Add benchmark for `std::exception_ptr` (#164278)

This commit adds benchmarks for `std::exception_ptr` to set a baseline
in preparation for follow-up optimizations.

Added: 
    

Modified: 
    libcxx/test/benchmarks/exception_ptr.bench.cpp

Removed: 
    


################################################################################
diff  --git a/libcxx/test/benchmarks/exception_ptr.bench.cpp b/libcxx/test/benchmarks/exception_ptr.bench.cpp
index 7791c510b1eb6..8ec7488ddf099 100644
--- a/libcxx/test/benchmarks/exception_ptr.bench.cpp
+++ b/libcxx/test/benchmarks/exception_ptr.bench.cpp
@@ -18,4 +18,116 @@ void bm_make_exception_ptr(benchmark::State& state) {
 }
 BENCHMARK(bm_make_exception_ptr)->ThreadRange(1, 8);
 
+void bm_exception_ptr_copy_ctor_nonnull(benchmark::State& state) {
+  std::exception_ptr excptr = std::make_exception_ptr(42);
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(std::exception_ptr(excptr));
+  }
+}
+BENCHMARK(bm_exception_ptr_copy_ctor_nonnull);
+
+void bm_exception_ptr_copy_ctor_null(benchmark::State& state) {
+  std::exception_ptr excptr = nullptr;
+  for (auto _ : state) {
+    std::exception_ptr excptr_copy(excptr);
+    // The compiler should be able to constant-fold the comparison
+    benchmark::DoNotOptimize(excptr_copy == nullptr);
+    benchmark::DoNotOptimize(excptr_copy);
+  }
+}
+BENCHMARK(bm_exception_ptr_copy_ctor_null);
+
+void bm_exception_ptr_move_ctor_nonnull(benchmark::State& state) {
+  std::exception_ptr excptr = std::make_exception_ptr(42);
+  for (auto _ : state) {
+    // Need to copy, such that the `excptr` is not moved from and
+    // empty after the first loop iteration.
+    std::exception_ptr excptr_copy(excptr);
+    benchmark::DoNotOptimize(std::exception_ptr(std::move(excptr_copy)));
+  }
+}
+BENCHMARK(bm_exception_ptr_move_ctor_nonnull);
+
+void bm_exception_ptr_move_ctor_null(benchmark::State& state) {
+  std::exception_ptr excptr = nullptr;
+  for (auto _ : state) {
+    std::exception_ptr new_excptr(std::move(excptr));
+    // The compiler should be able to constant-fold the comparison
+    benchmark::DoNotOptimize(new_excptr == nullptr);
+    benchmark::DoNotOptimize(new_excptr);
+  }
+}
+BENCHMARK(bm_exception_ptr_move_ctor_null);
+
+void bm_exception_ptr_copy_assign_nonnull(benchmark::State& state) {
+  std::exception_ptr excptr = std::make_exception_ptr(42);
+  for (auto _ : state) {
+    std::exception_ptr new_excptr;
+    new_excptr = excptr;
+    benchmark::DoNotOptimize(new_excptr);
+  }
+}
+BENCHMARK(bm_exception_ptr_copy_assign_nonnull);
+
+void bm_exception_ptr_copy_assign_null(benchmark::State& state) {
+  std::exception_ptr excptr = nullptr;
+  for (auto _ : state) {
+    std::exception_ptr new_excptr;
+    new_excptr = excptr;
+    // The compiler should be able to constant-fold the comparison
+    benchmark::DoNotOptimize(new_excptr == nullptr);
+    benchmark::DoNotOptimize(new_excptr);
+  }
+}
+BENCHMARK(bm_exception_ptr_copy_assign_null);
+
+void bm_exception_ptr_move_assign_nonnull(benchmark::State& state) {
+  std::exception_ptr excptr = std::make_exception_ptr(42);
+  for (auto _ : state) {
+    // Need to copy, such that the `excptr` is not moved from and
+    // empty after the first loop iteration.
+    std::exception_ptr excptr_copy(excptr);
+    std::exception_ptr new_excptr;
+    new_excptr = std::move(excptr_copy);
+    benchmark::DoNotOptimize(new_excptr);
+  }
+}
+BENCHMARK(bm_exception_ptr_move_assign_nonnull);
+
+void bm_exception_ptr_move_assign_null(benchmark::State& state) {
+  std::exception_ptr excptr = nullptr;
+  for (auto _ : state) {
+    std::exception_ptr new_excptr;
+    new_excptr = std::move(excptr);
+    // The compiler should be able to constant-fold the comparison
+    benchmark::DoNotOptimize(new_excptr == nullptr);
+    benchmark::DoNotOptimize(new_excptr);
+  }
+}
+BENCHMARK(bm_exception_ptr_move_assign_null);
+
+void bm_exception_ptr_swap_nonnull(benchmark::State& state) {
+  std::exception_ptr excptr1 = std::make_exception_ptr(41);
+  std::exception_ptr excptr2 = std::make_exception_ptr(42);
+  for (auto _ : state) {
+    swap(excptr1, excptr2);
+    benchmark::DoNotOptimize(excptr1);
+    benchmark::DoNotOptimize(excptr2);
+  }
+}
+BENCHMARK(bm_exception_ptr_swap_nonnull);
+
+void bm_exception_ptr_swap_null(benchmark::State& state) {
+  std::exception_ptr excptr1 = nullptr;
+  std::exception_ptr excptr2 = nullptr;
+  for (auto _ : state) {
+    swap(excptr1, excptr2);
+    // The compiler should be able to constant-fold those comparisons
+    benchmark::DoNotOptimize(excptr1 == nullptr);
+    benchmark::DoNotOptimize(excptr2 == nullptr);
+    benchmark::DoNotOptimize(excptr1 == excptr2);
+  }
+}
+BENCHMARK(bm_exception_ptr_swap_null);
+
 BENCHMARK_MAIN();