diff --git a/libcxx/benchmarks/to_chars.bench.cpp b/libcxx/benchmarks/to_chars.bench.cpp new file mode 100644 --- /dev/null +++ b/libcxx/benchmarks/to_chars.bench.cpp @@ -0,0 +1,75 @@ +//===----------------------------------------------------------------------===// +// 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 +#include +#include + +#include "benchmark/benchmark.h" +#include "test_macros.h" + +static const std::array input = [] { + std::mt19937 generator; + std::uniform_int_distribution distribution( + 0, std::numeric_limits::max()); + std::array result; + std::generate_n(result.begin(), result.size(), + [&] { return distribution(generator); }); + return result; +}(); + +static void BM_to_chars_good(benchmark::State& state) { + char buffer[128]; + int base = state.range(0); + while (state.KeepRunningBatch(input.size())) + for (auto value : input) +#if 0 + benchmark::DoNotOptimize( + std::to_chars(buffer, &buffer[128], value, base)); +#else + // Use internal function for comparision + benchmark::DoNotOptimize(std::__to_chars_integral( + buffer, &buffer[128], value, base, std::false_type())); +#endif +} +BENCHMARK(BM_to_chars_good)->DenseRange(2, 36, 1); + +static void BM_to_chars_bad(benchmark::State& state) { + char buffer[128]; + int base = state.range(0); + struct sample { + unsigned size; + unsigned value; + }; + std::array data; + // Assume the failure occurs, on average, halfway during the conversion. + std::transform(input.begin(), input.end(), data.begin(), [&](unsigned value) { + std::to_chars_result result = + std::to_chars(buffer, &buffer[128], value, base); + return sample{unsigned((result.ptr - buffer) / 2), value}; + }); + + while (state.KeepRunningBatch(data.size())) + for (auto element : data) +#if 0 + benchmark::DoNotOptimize( + std::to_chars(buffer, &buffer[element.size], element.value, base)); +#else + // Use internal function for comparision + benchmark::DoNotOptimize(std::__to_chars_integral( + buffer, &buffer[element.size], element.value, base, std::false_type())); +#endif +} +BENCHMARK(BM_to_chars_bad)->DenseRange(2, 36, 1); + +int main(int argc, char** argv) { + benchmark::Initialize(&argc, argv); + if (benchmark::ReportUnrecognizedArguments(argc, argv)) + return 1; + + benchmark::RunSpecifiedBenchmarks(); +} diff --git a/libcxx/benchmarks/to_chars_inplace.bench.cpp b/libcxx/benchmarks/to_chars_inplace.bench.cpp new file mode 100644 --- /dev/null +++ b/libcxx/benchmarks/to_chars_inplace.bench.cpp @@ -0,0 +1,76 @@ +//===----------------------------------------------------------------------===// +// 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 +#include +#include + +#include "benchmark/benchmark.h" +#include "test_macros.h" + +static const std::array input = [] { + std::mt19937 generator; + std::uniform_int_distribution distribution( + 0, std::numeric_limits::max()); + std::array result; + std::generate_n(result.begin(), result.size(), + [&] { return distribution(generator); }); + return result; +}(); + +static void BM_to_chars_good(benchmark::State& state) { + char buffer[128]; + int base = state.range(0); + while (state.KeepRunningBatch(input.size())) + for (auto value : input) +#if 0 + benchmark::DoNotOptimize( + std::to_chars(buffer, &buffer[128], value, base)); +#else + // Use internal function for comparision + benchmark::DoNotOptimize(std::__to_chars_integral_inplace( + buffer, &buffer[128], value, base, std::false_type())); +#endif +} +BENCHMARK(BM_to_chars_good)->DenseRange(2, 36, 1); + +static void BM_to_chars_bad(benchmark::State& state) { + char buffer[128]; + int base = state.range(0); + struct sample { + unsigned size; + unsigned value; + }; + std::array data; + // Assume the failure occurs, on average, halfway during the conversion. + std::transform(input.begin(), input.end(), data.begin(), [&](unsigned value) { + std::to_chars_result result = + std::to_chars(buffer, &buffer[128], value, base); + return sample{unsigned((result.ptr - buffer) / 2), value}; + }); + + while (state.KeepRunningBatch(data.size())) + for (auto element : data) +#if 0 + benchmark::DoNotOptimize( + std::to_chars(buffer, &buffer[element.size], element.value, base)); +#else + // Use internal function for comparision + benchmark::DoNotOptimize(std::__to_chars_integral_inplace( + buffer, &buffer[element.size], element.value, base, std::false_type())); +#endif +} +BENCHMARK(BM_to_chars_bad)->DenseRange(2, 36, 1); + +int main(int argc, char** argv) { + benchmark::Initialize(&argc, argv); + if (benchmark::ReportUnrecognizedArguments(argc, argv)) + return 1; + + benchmark::RunSpecifiedBenchmarks(); +} + diff --git a/libcxx/benchmarks/to_chars_inplace_multiplexed.bench.cpp b/libcxx/benchmarks/to_chars_inplace_multiplexed.bench.cpp new file mode 100644 --- /dev/null +++ b/libcxx/benchmarks/to_chars_inplace_multiplexed.bench.cpp @@ -0,0 +1,77 @@ +//===----------------------------------------------------------------------===// +// 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 +#include +#include + +#include "benchmark/benchmark.h" +#include "test_macros.h" + +static const std::array input = [] { + std::mt19937 generator; + std::uniform_int_distribution distribution( + 0, std::numeric_limits::max()); + std::array result; + std::generate_n(result.begin(), result.size(), + [&] { return distribution(generator); }); + return result; +}(); + +static void BM_to_chars_good(benchmark::State& state) { + char buffer[128]; + int base = state.range(0); + while (state.KeepRunningBatch(input.size())) + for (auto value : input) +#if 0 + benchmark::DoNotOptimize( + std::to_chars(buffer, &buffer[128], value, base)); +#else + // Use internal function for comparision + benchmark::DoNotOptimize(std::__to_chars_integral_inplace_multiplexed( + buffer, &buffer[128], value, base, std::false_type())); +#endif +} +BENCHMARK(BM_to_chars_good)->DenseRange(2, 36, 1); + +static void BM_to_chars_bad(benchmark::State& state) { + char buffer[128]; + int base = state.range(0); + struct sample { + unsigned size; + unsigned value; + }; + std::array data; + // Assume the failure occurs, on average, halfway during the conversion. + std::transform(input.begin(), input.end(), data.begin(), [&](unsigned value) { + std::to_chars_result result = + std::to_chars(buffer, &buffer[128], value, base); + return sample{unsigned((result.ptr - buffer) / 2), value}; + }); + + while (state.KeepRunningBatch(data.size())) + for (auto element : data) +#if 0 + benchmark::DoNotOptimize( + std::to_chars(buffer, &buffer[element.size], element.value, base)); +#else + // Use internal function for comparision + benchmark::DoNotOptimize(std::__to_chars_integral_inplace_multiplexed( + buffer, &buffer[element.size], element.value, base, std::false_type())); +#endif +} +BENCHMARK(BM_to_chars_bad)->DenseRange(2, 36, 1); + +int main(int argc, char** argv) { + benchmark::Initialize(&argc, argv); + if (benchmark::ReportUnrecognizedArguments(argc, argv)) + return 1; + + benchmark::RunSpecifiedBenchmarks(); +} + + diff --git a/libcxx/benchmarks/to_chars_inplace_multiplexed_for_format.bench.cpp b/libcxx/benchmarks/to_chars_inplace_multiplexed_for_format.bench.cpp new file mode 100644 --- /dev/null +++ b/libcxx/benchmarks/to_chars_inplace_multiplexed_for_format.bench.cpp @@ -0,0 +1,78 @@ +//===----------------------------------------------------------------------===// +// 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 +#include +#include + +#include "benchmark/benchmark.h" +#include "test_macros.h" + +static const std::array input = [] { + std::mt19937 generator; + std::uniform_int_distribution distribution( + 0, std::numeric_limits::max()); + std::array result; + std::generate_n(result.begin(), result.size(), + [&] { return distribution(generator); }); + return result; +}(); + +static void BM_to_chars_good(benchmark::State& state) { + char buffer[128]; + int base = state.range(0); + while (state.KeepRunningBatch(input.size())) + for (auto value : input) +#if 0 + benchmark::DoNotOptimize( + std::to_chars(buffer, &buffer[128], value, base)); +#else + // Use internal function for comparision + benchmark::DoNotOptimize( + std::__to_chars_integral_inplace_multiplexed_for_format( + buffer, &buffer[128], value, base, std::false_type())); +#endif +} +BENCHMARK(BM_to_chars_good)->DenseRange(2, 36, 1); + +static void BM_to_chars_bad(benchmark::State& state) { + char buffer[128]; + int base = state.range(0); + struct sample { + unsigned size; + unsigned value; + }; + std::array data; + // Assume the failure occurs, on average, halfway during the conversion. + std::transform(input.begin(), input.end(), data.begin(), [&](unsigned value) { + std::to_chars_result result = + std::to_chars(buffer, &buffer[128], value, base); + return sample{unsigned((result.ptr - buffer) / 2), value}; + }); + + while (state.KeepRunningBatch(data.size())) + for (auto element : data) +#if 0 + benchmark::DoNotOptimize( + std::to_chars(buffer, &buffer[element.size], element.value, base)); +#else + // Use internal function for comparision + benchmark::DoNotOptimize( + std::__to_chars_integral_inplace_multiplexed_for_format( + buffer, &buffer[element.size], element.value, base, + std::false_type())); +#endif +} +BENCHMARK(BM_to_chars_bad)->DenseRange(2, 36, 1); + +int main(int argc, char** argv) { + benchmark::Initialize(&argc, argv); + if (benchmark::ReportUnrecognizedArguments(argc, argv)) + return 1; + + benchmark::RunSpecifiedBenchmarks(); +} diff --git a/libcxx/include/charconv b/libcxx/include/charconv --- a/libcxx/include/charconv +++ b/libcxx/include/charconv @@ -77,6 +77,7 @@ #include <__availability> #include <__errc> #include // for log2f +#include // Why is _LIBCPP_UNREACHABLE in this header? #include #include #include @@ -358,12 +359,267 @@ return __to_chars_integral(__first, __last, __x, __base, false_type()); } +// TODO REMOVE PROOF OF CONCEPT CODE {{{ + +template +_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_INLINE_VISIBILITY unsigned +__to_chars_width_inplace(_Tp __value, unsigned __one) { + unsigned __two = __one * __one; + unsigned __three = __two * __one; + unsigned __four = __three * __one; + + _LIBCPP_ASSERT(__value >= 0, "The function requires a non-negative value."); + + unsigned __r = 0; + do { + + if (__value < __one) + return __r + 1; + if (__value < __two) + return __r + 2; + if (__value < __three) + return __r + 3; + + __value /= __four; + __r += 4; + + } while (__value != 0); + + return __r; +} + +template +_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_INLINE_VISIBILITY to_chars_result +__to_chars_integral_inplace(char* __first, char* __last, _Tp __value, + int __base, false_type) { + if (__base == 10) + return __to_chars_itoa(__first, __last, __value, false_type()); + + auto __diff = __last - __first; + auto __width = __to_chars_width_inplace(__value, __base); + if (__width > __diff) + return {__last, errc::value_too_large}; + + __last = __first + __width; + auto __p = __last; + do { + auto __c = __value % __base; + __value /= __base; + *--__p = "0123456789abcdefghijklmnopqrstuvwxyz"[__c]; + } while (__value != 0); + return {__last, errc(0)}; +} + +template +_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_INLINE_VISIBILITY unsigned +__to_chars_width_inplace_multiplexed(_Tp __value) { + unsigned __one = _Base; + unsigned __two = __one * __one; + unsigned __three = __two * __one; + unsigned __four = __three * __one; + + unsigned __r = 0; + do { + + if (__value < __one) + return __r + 1; + if (__value < __two) + return __r + 2; + if (__value < __three) + return __r + 3; + + __value /= __four; + __r += 4; + + } while (__value != 0); + + return __r; +} +template +_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_INLINE_VISIBILITY to_chars_result +__to_chars_integral_inplace_multiplexed(char* __first, char* __last, + _Tp __value) { + + auto __diff = __last - __first; + auto __width = __to_chars_width_inplace_multiplexed<_Tp, _Base>(__value); + if (__width > __diff) + return {__last, errc::value_too_large}; + + __last = __first + __width; + auto __p = __last; + do { + auto __c = __value % _Base; + __value /= _Base; + *--__p = "0123456789abcdefghijklmnopqrstuvwxyz"[__c]; + } while (__value != 0); + return {__last, errc(0)}; +} + +template +_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_INLINE_VISIBILITY to_chars_result +__to_chars_integral_inplace_multiplexed(char* __first, char* __last, + _Tp __value, int __base, false_type) { + + switch (__base) { + case 2: + return __to_chars_integral_inplace_multiplexed<_Tp, 2>(__first, __last, + __value); + case 3: + return __to_chars_integral_inplace_multiplexed<_Tp, 3>(__first, __last, + __value); + case 4: + return __to_chars_integral_inplace_multiplexed<_Tp, 4>(__first, __last, + __value); + case 5: + return __to_chars_integral_inplace_multiplexed<_Tp, 5>(__first, __last, + __value); + case 6: + return __to_chars_integral_inplace_multiplexed<_Tp, 6>(__first, __last, + __value); + case 7: + return __to_chars_integral_inplace_multiplexed<_Tp, 7>(__first, __last, + __value); + case 8: + return __to_chars_integral_inplace_multiplexed<_Tp, 8>(__first, __last, + __value); + case 9: + return __to_chars_integral_inplace_multiplexed<_Tp, 9>(__first, __last, + __value); + case 10: + return __to_chars_itoa(__first, __last, __value, false_type()); + case 11: + return __to_chars_integral_inplace_multiplexed<_Tp, 11>(__first, __last, + __value); + case 12: + return __to_chars_integral_inplace_multiplexed<_Tp, 12>(__first, __last, + __value); + case 13: + return __to_chars_integral_inplace_multiplexed<_Tp, 13>(__first, __last, + __value); + case 14: + return __to_chars_integral_inplace_multiplexed<_Tp, 14>(__first, __last, + __value); + case 15: + return __to_chars_integral_inplace_multiplexed<_Tp, 15>(__first, __last, + __value); + case 16: + return __to_chars_integral_inplace_multiplexed<_Tp, 16>(__first, __last, + __value); + case 17: + return __to_chars_integral_inplace_multiplexed<_Tp, 17>(__first, __last, + __value); + case 18: + return __to_chars_integral_inplace_multiplexed<_Tp, 18>(__first, __last, + __value); + case 19: + return __to_chars_integral_inplace_multiplexed<_Tp, 19>(__first, __last, + __value); + case 20: + return __to_chars_integral_inplace_multiplexed<_Tp, 20>(__first, __last, + __value); + case 21: + return __to_chars_integral_inplace_multiplexed<_Tp, 21>(__first, __last, + __value); + case 22: + return __to_chars_integral_inplace_multiplexed<_Tp, 22>(__first, __last, + __value); + case 23: + return __to_chars_integral_inplace_multiplexed<_Tp, 23>(__first, __last, + __value); + case 24: + return __to_chars_integral_inplace_multiplexed<_Tp, 24>(__first, __last, + __value); + case 25: + return __to_chars_integral_inplace_multiplexed<_Tp, 25>(__first, __last, + __value); + case 26: + return __to_chars_integral_inplace_multiplexed<_Tp, 26>(__first, __last, + __value); + case 27: + return __to_chars_integral_inplace_multiplexed<_Tp, 27>(__first, __last, + __value); + case 28: + return __to_chars_integral_inplace_multiplexed<_Tp, 28>(__first, __last, + __value); + case 29: + return __to_chars_integral_inplace_multiplexed<_Tp, 29>(__first, __last, + __value); + case 30: + return __to_chars_integral_inplace_multiplexed<_Tp, 30>(__first, __last, + __value); + case 31: + return __to_chars_integral_inplace_multiplexed<_Tp, 31>(__first, __last, + __value); + case 32: + return __to_chars_integral_inplace_multiplexed<_Tp, 32>(__first, __last, + __value); + case 33: + return __to_chars_integral_inplace_multiplexed<_Tp, 33>(__first, __last, + __value); + case 34: + return __to_chars_integral_inplace_multiplexed<_Tp, 34>(__first, __last, + __value); + case 35: + return __to_chars_integral_inplace_multiplexed<_Tp, 35>(__first, __last, + __value); + case 36: + return __to_chars_integral_inplace_multiplexed<_Tp, 36>(__first, __last, + __value); + } + _LIBCPP_ASSERT(false, "Unvalid base used"); + _LIBCPP_UNREACHABLE(); +} + +template +_LIBCPP_AVAILABILITY_TO_CHARS _LIBCPP_INLINE_VISIBILITY to_chars_result +__to_chars_integral_inplace_multiplexed_for_format(char* __first, char* __last, + _Tp __value, int __base, false_type) { + switch (__base) { + case 2: + return __to_chars_integral_inplace_multiplexed<_Tp, 2>(__first, __last, + __value); + case 8: + return __to_chars_integral_inplace_multiplexed<_Tp, 8>(__first, __last, + __value); + case 10: + return __to_chars_itoa(__first, __last, __value, false_type()); + + case 16: + return __to_chars_integral_inplace_multiplexed<_Tp, 16>(__first, __last, + __value); + } + + // Copy-paste inplace + auto __diff = __last - __first; + auto __width = __to_chars_width_inplace(__value, __base); + if (__width > __diff) + return {__last, errc::value_too_large}; + + __last = __first + __width; + auto __p = __last; + do { + auto __c = __value % __base; + __value /= __base; + *--__p = "0123456789abcdefghijklmnopqrstuvwxyz"[__c]; + } while (__value != 0); + return {__last, errc(0)}; + +} + +// }}} + + template _LIBCPP_AVAILABILITY_TO_CHARS inline _LIBCPP_INLINE_VISIBILITY to_chars_result __to_chars_integral(char* __first, char* __last, _Tp __value, int __base, false_type) { + //return __to_chars_integral_inplace(__first, __last, __value, __base, false_type()); + //return __to_chars_integral_inplace_multiplexed(__first, __last, __value, __base, false_type()); + //return __to_chars_integral_inplace_multiplexed_for_format(__first, __last, __value, __base, false_type()); + +#if 1 if (__base == 10) return __to_chars_itoa(__first, __last, __value, false_type()); @@ -385,6 +641,7 @@ _VSTD::memmove(__first, __p, __len); return {__first + __len, {}}; } +#endif } template ::value, int>::type = 0> diff --git a/libcxx/to_chars.txt b/libcxx/to_chars.txt new file mode 100644 --- /dev/null +++ b/libcxx/to_chars.txt @@ -0,0 +1,73 @@ +--------------------------------------------------------------- +Benchmark Time CPU Iterations +--------------------------------------------------------------- +BM_to_chars_good/2 169 ns 169 ns 4157000 +BM_to_chars_good/3 108 ns 108 ns 6495000 +BM_to_chars_good/4 83.6 ns 83.6 ns 8369000 +BM_to_chars_good/5 73.3 ns 73.3 ns 9543000 +BM_to_chars_good/6 67.1 ns 67.1 ns 10435000 +BM_to_chars_good/7 62.1 ns 62.1 ns 11266000 +BM_to_chars_good/8 56.4 ns 56.4 ns 12401000 +BM_to_chars_good/9 53.1 ns 53.1 ns 13183000 +BM_to_chars_good/10 5.64 ns 5.64 ns 124218000 +BM_to_chars_good/11 50.1 ns 50.1 ns 13981000 +BM_to_chars_good/12 46.9 ns 46.9 ns 14942000 +BM_to_chars_good/13 46.6 ns 46.6 ns 15033000 +BM_to_chars_good/14 46.2 ns 46.2 ns 15146000 +BM_to_chars_good/15 44.9 ns 44.9 ns 15587000 +BM_to_chars_good/16 41.0 ns 41.0 ns 17073000 +BM_to_chars_good/17 40.9 ns 40.9 ns 17099000 +BM_to_chars_good/18 40.9 ns 40.9 ns 17133000 +BM_to_chars_good/19 40.8 ns 40.8 ns 17148000 +BM_to_chars_good/20 40.7 ns 40.7 ns 17189000 +BM_to_chars_good/21 40.6 ns 40.6 ns 17262000 +BM_to_chars_good/22 39.4 ns 39.4 ns 17769000 +BM_to_chars_good/23 37.7 ns 37.7 ns 18556000 +BM_to_chars_good/24 36.4 ns 36.4 ns 19237000 +BM_to_chars_good/25 36.3 ns 36.3 ns 19282000 +BM_to_chars_good/26 36.2 ns 36.2 ns 19334000 +BM_to_chars_good/27 36.1 ns 36.1 ns 19385000 +BM_to_chars_good/28 36.0 ns 36.0 ns 19437000 +BM_to_chars_good/29 36.0 ns 36.0 ns 19470000 +BM_to_chars_good/30 35.9 ns 35.9 ns 19495000 +BM_to_chars_good/31 35.8 ns 35.8 ns 19532000 +BM_to_chars_good/32 35.0 ns 35.0 ns 19985000 +BM_to_chars_good/33 35.0 ns 35.0 ns 19986000 +BM_to_chars_good/34 35.0 ns 35.0 ns 19912000 +BM_to_chars_good/35 34.8 ns 34.8 ns 20124000 +BM_to_chars_good/36 34.3 ns 34.3 ns 20412000 +BM_to_chars_bad/2 97.4 ns 97.4 ns 7189000 +BM_to_chars_bad/3 62.0 ns 62.0 ns 11289000 +BM_to_chars_bad/4 48.4 ns 48.4 ns 14461000 +BM_to_chars_bad/5 42.2 ns 42.2 ns 16585000 +BM_to_chars_bad/6 37.4 ns 37.4 ns 18698000 +BM_to_chars_bad/7 34.9 ns 34.9 ns 20056000 +BM_to_chars_bad/8 31.1 ns 31.1 ns 22535000 +BM_to_chars_bad/9 30.6 ns 30.6 ns 22888000 +BM_to_chars_bad/10 1.57 ns 1.57 ns 445547000 +BM_to_chars_bad/11 27.7 ns 27.7 ns 25278000 +BM_to_chars_bad/12 25.2 ns 25.2 ns 27722000 +BM_to_chars_bad/13 25.1 ns 25.1 ns 27850000 +BM_to_chars_bad/14 25.0 ns 25.0 ns 27952000 +BM_to_chars_bad/15 24.9 ns 24.9 ns 28096000 +BM_to_chars_bad/16 24.1 ns 24.1 ns 29049000 +BM_to_chars_bad/17 23.9 ns 23.9 ns 29292000 +BM_to_chars_bad/18 23.6 ns 23.6 ns 29656000 +BM_to_chars_bad/19 23.2 ns 23.2 ns 30134000 +BM_to_chars_bad/20 22.7 ns 22.7 ns 30843000 +BM_to_chars_bad/21 22.0 ns 22.0 ns 31748000 +BM_to_chars_bad/22 21.1 ns 21.1 ns 33130000 +BM_to_chars_bad/23 20.0 ns 20.0 ns 34936000 +BM_to_chars_bad/24 19.0 ns 19.0 ns 36791000 +BM_to_chars_bad/25 19.0 ns 19.0 ns 36822000 +BM_to_chars_bad/26 19.0 ns 19.0 ns 36869000 +BM_to_chars_bad/27 19.0 ns 19.0 ns 36931000 +BM_to_chars_bad/28 18.9 ns 18.9 ns 36986000 +BM_to_chars_bad/29 18.9 ns 18.9 ns 37055000 +BM_to_chars_bad/30 18.9 ns 18.9 ns 37105000 +BM_to_chars_bad/31 18.8 ns 18.8 ns 37152000 +BM_to_chars_bad/32 18.4 ns 18.4 ns 37972000 +BM_to_chars_bad/33 18.4 ns 18.4 ns 38036000 +BM_to_chars_bad/34 18.4 ns 18.4 ns 38071000 +BM_to_chars_bad/35 18.4 ns 18.4 ns 38114000 +BM_to_chars_bad/36 18.3 ns 18.3 ns 38175000 diff --git a/libcxx/to_chars_inplace.txt b/libcxx/to_chars_inplace.txt new file mode 100644 --- /dev/null +++ b/libcxx/to_chars_inplace.txt @@ -0,0 +1,73 @@ +--------------------------------------------------------------- +Benchmark Time CPU Iterations +--------------------------------------------------------------- +BM_to_chars_good/2 207 ns 207 ns 3375000 +BM_to_chars_good/3 132 ns 132 ns 5294000 +BM_to_chars_good/4 102 ns 102 ns 6858000 +BM_to_chars_good/5 88.6 ns 88.6 ns 7903000 +BM_to_chars_good/6 80.5 ns 80.5 ns 8692000 +BM_to_chars_good/7 74.9 ns 74.9 ns 9348000 +BM_to_chars_good/8 67.1 ns 67.1 ns 10441000 +BM_to_chars_good/9 64.0 ns 64.0 ns 10930000 +BM_to_chars_good/10 5.72 ns 5.72 ns 122330000 +BM_to_chars_good/11 60.9 ns 60.9 ns 11490000 +BM_to_chars_good/12 56.0 ns 56.0 ns 12493000 +BM_to_chars_good/13 55.6 ns 55.6 ns 12595000 +BM_to_chars_good/14 54.8 ns 54.8 ns 12781000 +BM_to_chars_good/15 53.5 ns 53.5 ns 13085000 +BM_to_chars_good/16 49.6 ns 49.6 ns 14126000 +BM_to_chars_good/17 49.3 ns 49.3 ns 14188000 +BM_to_chars_good/18 49.1 ns 49.1 ns 14269000 +BM_to_chars_good/19 48.7 ns 48.7 ns 14371000 +BM_to_chars_good/20 48.2 ns 48.2 ns 14529000 +BM_to_chars_good/21 47.6 ns 47.6 ns 14701000 +BM_to_chars_good/22 46.2 ns 46.2 ns 15144000 +BM_to_chars_good/23 43.5 ns 43.5 ns 16075000 +BM_to_chars_good/24 41.1 ns 41.1 ns 17012000 +BM_to_chars_good/25 41.1 ns 41.1 ns 17046000 +BM_to_chars_good/26 41.0 ns 41.0 ns 17081000 +BM_to_chars_good/27 40.8 ns 40.8 ns 17149000 +BM_to_chars_good/28 40.8 ns 40.8 ns 17178000 +BM_to_chars_good/29 40.7 ns 40.7 ns 17188000 +BM_to_chars_good/30 40.7 ns 40.7 ns 17207000 +BM_to_chars_good/31 40.7 ns 40.7 ns 17196000 +BM_to_chars_good/32 39.8 ns 39.8 ns 17572000 +BM_to_chars_good/33 40.0 ns 40.0 ns 17518000 +BM_to_chars_good/34 40.1 ns 40.1 ns 17446000 +BM_to_chars_good/35 40.0 ns 40.0 ns 17498000 +BM_to_chars_good/36 39.6 ns 39.6 ns 17692000 +BM_to_chars_bad/2 41.4 ns 41.4 ns 16906000 +BM_to_chars_bad/3 26.1 ns 26.1 ns 26811000 +BM_to_chars_bad/4 20.0 ns 20.0 ns 35069000 +BM_to_chars_bad/5 16.7 ns 16.7 ns 42042000 +BM_to_chars_bad/6 15.5 ns 15.5 ns 45095000 +BM_to_chars_bad/7 14.4 ns 14.4 ns 48582000 +BM_to_chars_bad/8 11.5 ns 11.5 ns 60868000 +BM_to_chars_bad/9 11.5 ns 11.5 ns 61141000 +BM_to_chars_bad/10 1.56 ns 1.56 ns 447260000 +BM_to_chars_bad/11 11.8 ns 11.8 ns 59268000 +BM_to_chars_bad/12 9.61 ns 9.61 ns 72891000 +BM_to_chars_bad/13 9.85 ns 9.85 ns 71195000 +BM_to_chars_bad/14 10.00 ns 10.00 ns 70024000 +BM_to_chars_bad/15 9.99 ns 9.99 ns 70079000 +BM_to_chars_bad/16 9.05 ns 9.05 ns 77329000 +BM_to_chars_bad/17 9.12 ns 9.12 ns 76758000 +BM_to_chars_bad/18 9.22 ns 9.22 ns 75882000 +BM_to_chars_bad/19 9.33 ns 9.33 ns 75010000 +BM_to_chars_bad/20 9.36 ns 9.36 ns 74823000 +BM_to_chars_bad/21 9.29 ns 9.29 ns 75319000 +BM_to_chars_bad/22 8.34 ns 8.34 ns 84118000 +BM_to_chars_bad/23 6.70 ns 6.70 ns 104367000 +BM_to_chars_bad/24 5.30 ns 5.30 ns 132207000 +BM_to_chars_bad/25 5.37 ns 5.37 ns 130535000 +BM_to_chars_bad/26 5.45 ns 5.45 ns 128552000 +BM_to_chars_bad/27 5.46 ns 5.46 ns 128250000 +BM_to_chars_bad/28 5.59 ns 5.59 ns 125324000 +BM_to_chars_bad/29 5.74 ns 5.74 ns 121973000 +BM_to_chars_bad/30 5.88 ns 5.88 ns 119009000 +BM_to_chars_bad/31 6.11 ns 6.11 ns 114601000 +BM_to_chars_bad/32 6.23 ns 6.23 ns 112315000 +BM_to_chars_bad/33 6.50 ns 6.50 ns 107715000 +BM_to_chars_bad/34 6.91 ns 6.91 ns 101306000 +BM_to_chars_bad/35 7.19 ns 7.19 ns 97436000 +BM_to_chars_bad/36 7.32 ns 7.32 ns 95732000 diff --git a/libcxx/to_chars_inplace_multiplexed.txt b/libcxx/to_chars_inplace_multiplexed.txt new file mode 100644 --- /dev/null +++ b/libcxx/to_chars_inplace_multiplexed.txt @@ -0,0 +1,73 @@ +--------------------------------------------------------------- +Benchmark Time CPU Iterations +--------------------------------------------------------------- +BM_to_chars_good/2 25.1 ns 25.1 ns 27895000 +BM_to_chars_good/3 26.3 ns 26.3 ns 26605000 +BM_to_chars_good/4 16.9 ns 16.9 ns 41412000 +BM_to_chars_good/5 17.5 ns 17.5 ns 39975000 +BM_to_chars_good/6 18.8 ns 18.8 ns 37164000 +BM_to_chars_good/7 26.0 ns 26.0 ns 26874000 +BM_to_chars_good/8 12.3 ns 12.3 ns 57273000 +BM_to_chars_good/9 13.3 ns 13.3 ns 52608000 +BM_to_chars_good/10 7.08 ns 7.08 ns 98874000 +BM_to_chars_good/11 15.1 ns 15.1 ns 46395000 +BM_to_chars_good/12 11.9 ns 11.9 ns 58906000 +BM_to_chars_good/13 12.7 ns 12.7 ns 54876000 +BM_to_chars_good/14 15.8 ns 15.8 ns 44189000 +BM_to_chars_good/15 13.9 ns 13.9 ns 50337000 +BM_to_chars_good/16 6.27 ns 6.27 ns 111684000 +BM_to_chars_good/17 10.8 ns 10.8 ns 64552000 +BM_to_chars_good/18 10.8 ns 10.8 ns 64932000 +BM_to_chars_good/19 17.3 ns 17.3 ns 40367000 +BM_to_chars_good/20 11.7 ns 11.7 ns 59794000 +BM_to_chars_good/21 18.0 ns 18.0 ns 38846000 +BM_to_chars_good/22 12.6 ns 12.6 ns 55556000 +BM_to_chars_good/23 10.8 ns 10.8 ns 64606000 +BM_to_chars_good/24 8.71 ns 8.71 ns 80057000 +BM_to_chars_good/25 8.51 ns 8.51 ns 82148000 +BM_to_chars_good/26 9.32 ns 9.32 ns 75096000 +BM_to_chars_good/27 13.5 ns 13.5 ns 51962000 +BM_to_chars_good/28 10.5 ns 10.5 ns 66706000 +BM_to_chars_good/29 10.4 ns 10.4 ns 67210000 +BM_to_chars_good/30 10.1 ns 10.1 ns 68586000 +BM_to_chars_good/31 14.1 ns 14.1 ns 49514000 +BM_to_chars_good/32 7.65 ns 7.65 ns 91227000 +BM_to_chars_good/33 10.4 ns 10.4 ns 67275000 +BM_to_chars_good/34 10.7 ns 10.7 ns 65600000 +BM_to_chars_good/35 14.9 ns 14.9 ns 46970000 +BM_to_chars_good/36 10.7 ns 10.7 ns 65040000 +BM_to_chars_bad/2 13.3 ns 13.3 ns 52762000 +BM_to_chars_bad/3 10.2 ns 10.2 ns 68296000 +BM_to_chars_bad/4 7.49 ns 7.49 ns 93507000 +BM_to_chars_bad/5 7.22 ns 7.22 ns 96989000 +BM_to_chars_bad/6 8.95 ns 8.95 ns 78270000 +BM_to_chars_bad/7 8.03 ns 8.03 ns 87173000 +BM_to_chars_bad/8 6.43 ns 6.43 ns 108853000 +BM_to_chars_bad/9 6.23 ns 6.23 ns 112420000 +BM_to_chars_bad/10 2.83 ns 2.83 ns 247252000 +BM_to_chars_bad/11 7.70 ns 7.70 ns 90852000 +BM_to_chars_bad/12 5.37 ns 5.37 ns 130057000 +BM_to_chars_bad/13 6.09 ns 6.09 ns 114896000 +BM_to_chars_bad/14 7.30 ns 7.30 ns 95932000 +BM_to_chars_bad/15 8.14 ns 8.14 ns 85793000 +BM_to_chars_bad/16 3.40 ns 3.40 ns 206091000 +BM_to_chars_bad/17 4.59 ns 4.59 ns 152366000 +BM_to_chars_bad/18 5.27 ns 5.27 ns 132814000 +BM_to_chars_bad/19 5.19 ns 5.19 ns 134996000 +BM_to_chars_bad/20 6.42 ns 6.42 ns 108936000 +BM_to_chars_bad/21 6.92 ns 6.92 ns 101159000 +BM_to_chars_bad/22 7.15 ns 7.15 ns 97766000 +BM_to_chars_bad/23 6.09 ns 6.09 ns 115569000 +BM_to_chars_bad/24 4.08 ns 4.08 ns 171214000 +BM_to_chars_bad/25 4.38 ns 4.38 ns 159925000 +BM_to_chars_bad/26 4.97 ns 4.97 ns 140855000 +BM_to_chars_bad/27 4.30 ns 4.30 ns 162814000 +BM_to_chars_bad/28 4.67 ns 4.67 ns 150008000 +BM_to_chars_bad/29 5.48 ns 5.48 ns 127689000 +BM_to_chars_bad/30 4.61 ns 4.61 ns 151946000 +BM_to_chars_bad/31 4.97 ns 4.97 ns 140722000 +BM_to_chars_bad/32 5.62 ns 5.62 ns 124587000 +BM_to_chars_bad/33 5.93 ns 5.93 ns 117450000 +BM_to_chars_bad/34 6.14 ns 6.14 ns 114110000 +BM_to_chars_bad/35 6.63 ns 6.63 ns 105181000 +BM_to_chars_bad/36 6.43 ns 6.43 ns 109004000 diff --git a/libcxx/to_chars_inplace_multiplexed_for_format.txt b/libcxx/to_chars_inplace_multiplexed_for_format.txt new file mode 100644 --- /dev/null +++ b/libcxx/to_chars_inplace_multiplexed_for_format.txt @@ -0,0 +1,73 @@ +--------------------------------------------------------------- +Benchmark Time CPU Iterations +--------------------------------------------------------------- +BM_to_chars_good/2 24.3 ns 24.3 ns 28758000 +BM_to_chars_good/3 132 ns 132 ns 5294000 +BM_to_chars_good/4 102 ns 102 ns 6834000 +BM_to_chars_good/5 88.8 ns 88.8 ns 7885000 +BM_to_chars_good/6 80.8 ns 80.8 ns 8666000 +BM_to_chars_good/7 75.1 ns 75.1 ns 9320000 +BM_to_chars_good/8 11.6 ns 11.6 ns 60335000 +BM_to_chars_good/9 63.9 ns 63.9 ns 10946000 +BM_to_chars_good/10 6.97 ns 6.97 ns 100343000 +BM_to_chars_good/11 61.0 ns 61.0 ns 11480000 +BM_to_chars_good/12 56.0 ns 56.0 ns 12507000 +BM_to_chars_good/13 55.4 ns 55.4 ns 12629000 +BM_to_chars_good/14 54.5 ns 54.5 ns 12841000 +BM_to_chars_good/15 53.5 ns 53.5 ns 13083000 +BM_to_chars_good/16 8.68 ns 8.68 ns 80617000 +BM_to_chars_good/17 49.4 ns 49.4 ns 14169000 +BM_to_chars_good/18 49.1 ns 49.1 ns 14252000 +BM_to_chars_good/19 48.8 ns 48.8 ns 14354000 +BM_to_chars_good/20 48.3 ns 48.3 ns 14497000 +BM_to_chars_good/21 47.7 ns 47.7 ns 14663000 +BM_to_chars_good/22 46.6 ns 46.6 ns 15022000 +BM_to_chars_good/23 43.9 ns 43.9 ns 15963000 +BM_to_chars_good/24 41.2 ns 41.2 ns 16994000 +BM_to_chars_good/25 41.1 ns 41.1 ns 17028000 +BM_to_chars_good/26 41.0 ns 41.0 ns 17067000 +BM_to_chars_good/27 40.9 ns 40.9 ns 17121000 +BM_to_chars_good/28 40.8 ns 40.8 ns 17153000 +BM_to_chars_good/29 40.8 ns 40.8 ns 17166000 +BM_to_chars_good/30 40.7 ns 40.7 ns 17184000 +BM_to_chars_good/31 40.7 ns 40.7 ns 17197000 +BM_to_chars_good/32 39.9 ns 39.9 ns 17533000 +BM_to_chars_good/33 40.0 ns 40.0 ns 17513000 +BM_to_chars_good/34 40.0 ns 40.0 ns 17502000 +BM_to_chars_good/35 39.9 ns 39.9 ns 17532000 +BM_to_chars_good/36 39.7 ns 39.7 ns 17646000 +BM_to_chars_bad/2 11.8 ns 11.8 ns 59407000 +BM_to_chars_bad/3 27.6 ns 27.6 ns 25380000 +BM_to_chars_bad/4 20.8 ns 20.8 ns 33587000 +BM_to_chars_bad/5 17.7 ns 17.7 ns 39554000 +BM_to_chars_bad/6 17.4 ns 17.4 ns 40182000 +BM_to_chars_bad/7 16.1 ns 16.1 ns 43550000 +BM_to_chars_bad/8 5.89 ns 5.89 ns 118927000 +BM_to_chars_bad/9 12.4 ns 12.4 ns 56444000 +BM_to_chars_bad/10 2.76 ns 2.76 ns 253901000 +BM_to_chars_bad/11 13.8 ns 13.8 ns 50880000 +BM_to_chars_bad/12 9.87 ns 9.87 ns 70901000 +BM_to_chars_bad/13 10.4 ns 10.4 ns 67295000 +BM_to_chars_bad/14 11.3 ns 11.3 ns 62006000 +BM_to_chars_bad/15 11.6 ns 11.6 ns 60062000 +BM_to_chars_bad/16 5.11 ns 5.11 ns 136841000 +BM_to_chars_bad/17 9.33 ns 9.33 ns 75048000 +BM_to_chars_bad/18 9.57 ns 9.57 ns 73109000 +BM_to_chars_bad/19 9.89 ns 9.89 ns 70818000 +BM_to_chars_bad/20 10.3 ns 10.3 ns 67842000 +BM_to_chars_bad/21 10.7 ns 10.7 ns 65696000 +BM_to_chars_bad/22 9.80 ns 9.80 ns 71456000 +BM_to_chars_bad/23 7.30 ns 7.30 ns 95885000 +BM_to_chars_bad/24 5.38 ns 5.38 ns 130057000 +BM_to_chars_bad/25 5.47 ns 5.47 ns 128061000 +BM_to_chars_bad/26 5.60 ns 5.60 ns 124935000 +BM_to_chars_bad/27 5.66 ns 5.66 ns 123725000 +BM_to_chars_bad/28 5.87 ns 5.87 ns 119319000 +BM_to_chars_bad/29 6.12 ns 6.12 ns 114450000 +BM_to_chars_bad/30 6.36 ns 6.36 ns 110046000 +BM_to_chars_bad/31 6.70 ns 6.70 ns 104480000 +BM_to_chars_bad/32 7.03 ns 7.03 ns 99701000 +BM_to_chars_bad/33 7.57 ns 7.57 ns 92534000 +BM_to_chars_bad/34 8.13 ns 8.13 ns 86108000 +BM_to_chars_bad/35 8.61 ns 8.61 ns 81312000 +BM_to_chars_bad/36 8.83 ns 8.83 ns 79214000