d54b1cfa38
This patch is the start of a series to improve the speed of std::format, std::format_to, std::format_to_n, and std::formatted_size. This is mostly achieved by changing the __output_buffer class. This new __output_buffer class also makes it easier to implement buffering for P3107R5 "Permit an efficient implementation of std::print"
118 lines
3.5 KiB
C++
118 lines
3.5 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#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) {
|
|
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();
|