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
|
//===----------------------------------------------------------------------===//
//
// 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
// Don't warn about std::sprintf
// ADDITIONAL_COMPILE_FLAGS: -Wno-deprecated
#include <array>
#include <charconv>
#include <cstdio>
#include <format>
#include <iterator>
#include <list>
#include <random>
#include <vector>
#include "benchmark/benchmark.h"
std::array data = [] {
std::uniform_int_distribution<int> distribution{std::numeric_limits<int>::min(), std::numeric_limits<int>::max()};
std::mt19937 generator;
std::array<int, 1000> result;
std::generate_n(result.begin(), result.size(), [&] { return distribution(generator); });
return result;
}();
static void BM_sprintf(benchmark::State& state) {
std::array<char, 100> output;
while (state.KeepRunningBatch(data.size()))
for (auto value : data) {
std::sprintf(output.data(), "%d", value);
benchmark::DoNotOptimize(output.data());
}
}
static void BM_to_string(benchmark::State& state) {
while (state.KeepRunningBatch(data.size()))
for (auto value : data) {
std::string s = std::to_string(value);
benchmark::DoNotOptimize(s);
}
}
static void BM_to_chars(benchmark::State& state) {
std::array<char, 100> output;
while (state.KeepRunningBatch(data.size()))
for (auto value : data) {
std::to_chars(output.data(), output.data() + output.size(), value);
benchmark::DoNotOptimize(output.data());
}
}
static void BM_to_chars_as_string(benchmark::State& state) {
std::array<char, 100> output;
while (state.KeepRunningBatch(data.size()))
for (auto value : data) {
char* end = std::to_chars(output.data(), output.data() + output.size(), value).ptr;
std::string s{output.data(), end};
benchmark::DoNotOptimize(s);
}
}
static void BM_format(benchmark::State& state) {
while (state.KeepRunningBatch(data.size()))
for (auto value : data) {
std::string s = std::format("{}", value);
benchmark::DoNotOptimize(s);
}
}
template <class C>
static void BM_format_to_back_inserter(benchmark::State& state) {
while (state.KeepRunningBatch(data.size()))
for (auto value : data) {
C c;
std::format_to(std::back_inserter(c), "{}", value);
benchmark::DoNotOptimize(c);
}
}
template <class F>
static void BM_format_to_iterator(benchmark::State& state, F&& f) {
auto output = f();
while (state.KeepRunningBatch(data.size()))
for (auto value : data) {
std::format_to(std::begin(output), "{}", value);
benchmark::DoNotOptimize(std::begin(output));
}
}
BENCHMARK(BM_sprintf);
BENCHMARK(BM_to_string);
BENCHMARK(BM_to_chars);
BENCHMARK(BM_to_chars_as_string);
BENCHMARK(BM_format);
BENCHMARK_TEMPLATE(BM_format_to_back_inserter, std::string);
BENCHMARK_TEMPLATE(BM_format_to_back_inserter, std::vector<char>);
BENCHMARK_TEMPLATE(BM_format_to_back_inserter, std::list<char>);
BENCHMARK_CAPTURE(BM_format_to_iterator, <std::array>, ([] {
std::array<char, 100> a;
return a;
}));
BENCHMARK_CAPTURE(BM_format_to_iterator, <std::string>, ([] {
std::string s;
s.resize(100);
return s;
}));
BENCHMARK_CAPTURE(BM_format_to_iterator, <std::vector>, ([] {
std::vector<char> v;
v.resize(100);
return v;
}));
BENCHMARK_MAIN();
|
