b2d2494731
This patch fixes warnings and errors that come up when running the benchmarks as part of the test suite. It also adds the necessary Lit annotations to make it pass in various configurations and increases the portability of the benchmarks.
123 lines
3.6 KiB
C++
123 lines
3.6 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// 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_real_distribution<double> distribution;
|
|
std::mt19937 generator;
|
|
std::array<double, 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(), "%f", 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();
|