blob: 8ec7488ddf0996fc9fbfc6e7c95c6eef178bcc25 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
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
#include <benchmark/benchmark.h>
#include <exception>
void bm_make_exception_ptr(benchmark::State& state) {
for (auto _ : state) {
benchmark::DoNotOptimize(std::make_exception_ptr(42));
}
}
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();
|
