Add benchmarks for individual operations

Author: vogelsgesang

libcxx/test/benchmarks/exception_ptr.bench.cpp

@@ -18,7 +18,122 @@ void bm_make_exception_ptr(benchmark::State& state) {
 }
 BENCHMARK(bm_make_exception_ptr)->ThreadRange(1, 8);
 
-static bool exception_ptr_moves_copies_swap(std::exception_ptr p1) {
+void bm_exception_ptr_copy_ctor_nonnull(benchmark::State& state) {
+  std::exception_ptr excptr = std::make_exception_ptr(42);
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(excptr);
+    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) {
+    benchmark::DoNotOptimize(excptr);
+    benchmark::DoNotOptimize(std::exception_ptr(excptr));
+  }
+}
+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(excptr_copy);
+    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) {
+    benchmark::DoNotOptimize(excptr);
+    benchmark::DoNotOptimize(std::exception_ptr(std::move(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) {
+    benchmark::DoNotOptimize(excptr);
+    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) {
+    benchmark::DoNotOptimize(excptr);
+    std::exception_ptr new_excptr;
+    new_excptr = excptr;
+    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);
+    benchmark::DoNotOptimize(excptr_copy);
+    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) {
+    benchmark::DoNotOptimize(excptr);
+    std::exception_ptr new_excptr;
+    new_excptr = std::move(excptr);
+    benchmark::DoNotOptimize(new_excptr);
+  }
+}
+BENCHMARK(bm_exception_ptr_move_assign_null);
+
+void bm_exception_ptr_swap_nonnull(benchmark::State& state) {
+  std::exception_ptr excptr = std::make_exception_ptr(41);
+  std::exception_ptr excptr2 = std::make_exception_ptr(42);
+  for (auto _ : state) {
+    swap(excptr, excptr2);
+    benchmark::DoNotOptimize(excptr);
+    benchmark::DoNotOptimize(excptr2);
+  }
+}
+BENCHMARK(bm_exception_ptr_swap_nonnull);
+
+void bm_exception_ptr_swap_null(benchmark::State& state) {
+  std::exception_ptr excptr = nullptr;
+  std::exception_ptr excptr2 = nullptr;
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(excptr);
+    swap(excptr, excptr2);
+    benchmark::DoNotOptimize(excptr2);
+  }
+}
+BENCHMARK(bm_exception_ptr_swap_null);
+
+// A chain of moves, copies and swaps.
+// In contrast to the previous benchmarks of individual operations,
+// this benchmark performs a chain of operations. It thereby
+// specifically stresses the information available to the compiler
+// for optimizations from the header itself.
+static bool exception_ptr_move_copy_swap(std::exception_ptr p1) {
   // Taken from https://llvm.org/PR45547
   std::exception_ptr p2(p1);
   std::exception_ptr p3(std::move(p2));
@@ -33,34 +148,34 @@ static bool exception_ptr_moves_copies_swap(std::exception_ptr p1) {
 }
 
 // Benchmark copies, moves and comparisons of a non-null exception_ptr.
-void bm_nonnull_exception_ptr(benchmark::State& state) {
+void bm_exception_ptr_move_copy_swap_nonnull(benchmark::State& state) {
   std::exception_ptr excptr = std::make_exception_ptr(42);
   for (auto _ : state) {
     benchmark::DoNotOptimize(excptr);
-    benchmark::DoNotOptimize(exception_ptr_moves_copies_swap(excptr));
+    benchmark::DoNotOptimize(exception_ptr_move_copy_swap(excptr));
   }
 }
-BENCHMARK(bm_nonnull_exception_ptr);
+BENCHMARK(bm_exception_ptr_move_copy_swap_nonnull);
 
 // Benchmark copies, moves and comparisons of a nullptr exception_ptr
 // where the compiler cannot prove that the exception_ptr is always
 // a nullptr and needs to emit runtime checks.
-void bm_null_exception_ptr(benchmark::State& state) {
+void bm_exception_ptr_move_copy_swap_null(benchmark::State& state) {
   std::exception_ptr excptr;
   for (auto _ : state) {
     benchmark::DoNotOptimize(excptr);
-    benchmark::DoNotOptimize(exception_ptr_moves_copies_swap(excptr));
+    benchmark::DoNotOptimize(exception_ptr_move_copy_swap(excptr));
   }
 }
-BENCHMARK(bm_null_exception_ptr);
+BENCHMARK(bm_exception_ptr_move_copy_swap_null);
 
 // Benchmark copies, moves and comparisons of a nullptr exception_ptr
 // where the compiler can proof that the exception_ptr is always a nullptr.
-void bm_optimized_null_exception_ptr(benchmark::State& state) {
+void bm_exception_ptr_move_copy_swap_null_optimized(benchmark::State& state) {
   for (auto _ : state) {
-    benchmark::DoNotOptimize(exception_ptr_moves_copies_swap(std::exception_ptr{nullptr}));
+    benchmark::DoNotOptimize(exception_ptr_move_copy_swap(std::exception_ptr{nullptr}));
   }
 }
-BENCHMARK(bm_optimized_null_exception_ptr);
+BENCHMARK(bm_exception_ptr_move_copy_swap_null_optimized);
 
 BENCHMARK_MAIN();