[libc++] Improve std::to_chars for base != 10.

[Mordante]

Summary

This improves the speed of to_chars for bases 2, 8, and 16.
These bases are common and used in <format>. This change
uses a lookup table, like done in base 10 and causes an increase
in code size. The change has a small overhead for the other bases.

Benchmark                             Time             CPU      Time Old      Time New       CPU Old       CPU New
------------------------------------------------------------------------------------------------------------------
BM_to_chars_good/2                 -0.9476         -0.9476           252            13           252            13
BM_to_chars_good/3                 +0.0018         +0.0018           145           145           145           145
BM_to_chars_good/4                 +0.0108         +0.0108           104           105           104           105
BM_to_chars_good/5                 +0.0159         +0.0160            89            91            89            91
BM_to_chars_good/6                 +0.0162         +0.0162            80            81            80            81
BM_to_chars_good/7                 +0.0117         +0.0117            72            73            72            73
BM_to_chars_good/8                 -0.8643         -0.8643            64             9            64             9
BM_to_chars_good/9                 +0.0095         +0.0095            60            60            60            60
BM_to_chars_good/10                +0.0540         +0.0540             6             6             6             6
BM_to_chars_good/11                +0.0299         +0.0299            55            57            55            57
BM_to_chars_good/12                +0.0060         +0.0060            48            49            49            49
BM_to_chars_good/13                +0.0102         +0.0102            48            48            48            48
BM_to_chars_good/14                +0.0184         +0.0185            47            48            47            48
BM_to_chars_good/15                +0.0269         +0.0269            44            45            44            45
BM_to_chars_good/16                -0.8207         -0.8207            37             7            37             7
BM_to_chars_good/17                +0.0241         +0.0241            37            38            37            38
BM_to_chars_good/18                +0.0221         +0.0221            37            38            37            38
BM_to_chars_good/19                +0.0222         +0.0223            37            38            37            38
BM_to_chars_good/20                +0.0317         +0.0317            38            39            38            39
BM_to_chars_good/21                +0.0342         +0.0341            38            39            38            39
BM_to_chars_good/22                +0.0336         +0.0336            36            38            36            38
BM_to_chars_good/23                +0.0222         +0.0222            34            35            34            35
BM_to_chars_good/24                +0.0185         +0.0185            31            32            31            32
BM_to_chars_good/25                +0.0157         +0.0157            32            32            32            32
BM_to_chars_good/26                +0.0181         +0.0181            32            32            32            32
BM_to_chars_good/27                +0.0153         +0.0153            32            32            32            32
BM_to_chars_good/28                +0.0179         +0.0179            32            32            32            32
BM_to_chars_good/29                +0.0189         +0.0189            32            33            32            33
BM_to_chars_good/30                +0.0212         +0.0212            32            33            32            33
BM_to_chars_good/31                +0.0221         +0.0221            32            33            32            33
BM_to_chars_good/32                +0.0292         +0.0292            32            33            32            33
BM_to_chars_good/33                +0.0319         +0.0319            32            33            32            33
BM_to_chars_good/34                +0.0411         +0.0410            33            34            33            34
BM_to_chars_good/35                +0.0515         +0.0515            33            34            33            34
BM_to_chars_good/36                +0.0502         +0.0502            32            34            32            34
BM_to_chars_bad/2                  -0.8752         -0.8752            40             5            40             5
BM_to_chars_bad/3                  +0.1952         +0.1952            21            26            21            26
BM_to_chars_bad/4                  +0.3626         +0.3626            16            22            16            22
BM_to_chars_bad/5                  +0.2267         +0.2268            17            21            17            21
BM_to_chars_bad/6                  +0.3560         +0.3559            14            19            14            19
BM_to_chars_bad/7                  +0.4599         +0.4600            12            18            12            18
BM_to_chars_bad/8                  -0.5074         -0.5074            11             5            11             5
BM_to_chars_bad/9                  +0.4814         +0.4814            10            15            10            15
BM_to_chars_bad/10                 +0.7761         +0.7761             2             4             2             4
BM_to_chars_bad/11                 +0.3948         +0.3948            12            16            12            16
BM_to_chars_bad/12                 +0.3203         +0.3203            10            13            10            13
BM_to_chars_bad/13                 +0.3067         +0.3067            11            14            11            14
BM_to_chars_bad/14                 +0.2235         +0.2235            12            14            12            14
BM_to_chars_bad/15                 +0.2675         +0.2675            11            14            11            14
BM_to_chars_bad/16                 -0.1801         -0.1801             7             5             7             5
BM_to_chars_bad/17                 +0.5651         +0.5651             7            11             7            11
BM_to_chars_bad/18                 +0.5407         +0.5406             7            11             7            11
BM_to_chars_bad/19                 +0.5593         +0.5593             8            12             8            12
BM_to_chars_bad/20                 +0.5823         +0.5823             8            13             8            13
BM_to_chars_bad/21                 +0.6032         +0.6032             9            15             9            15
BM_to_chars_bad/22                 +0.6407         +0.6408             9            14             9            14
BM_to_chars_bad/23                 +0.6292         +0.6292             7            12             7            12
BM_to_chars_bad/24                 +0.5784         +0.5784             6            10             6            10
BM_to_chars_bad/25                 +0.5784         +0.5784             6            10             6            10
BM_to_chars_bad/26                 +0.5713         +0.5713             7            10             7            10
BM_to_chars_bad/27                 +0.5969         +0.5969             7            11             7            11
BM_to_chars_bad/28                 +0.6131         +0.6131             7            11             7            11
BM_to_chars_bad/29                 +0.6937         +0.6937             7            11             7            11
BM_to_chars_bad/30                 +0.7655         +0.7656             7            12             7            12
BM_to_chars_bad/31                 +0.8939         +0.8939             6            12             6            12
BM_to_chars_bad/32                 +1.0157         +1.0157             6            13             6            13
BM_to_chars_bad/33                 +1.0279         +1.0279             7            14             7            14
BM_to_chars_bad/34                 +1.0388         +1.0388             7            14             7            14
BM_to_chars_bad/35                 +1.0990         +1.0990             7            15             7            15
BM_to_chars_bad/36                 +1.1503         +1.1503             7            15             7            15

[ldionne]

I think it would make sense to have a general implementation that works for all bases, and then have a few common bases (likely 2, 8, 10, 16 as you say) be compiled in the library. I think the top-level could look something like:

if (base == 2) // then dispatch to the implementation for base 2 in the library
else if (base == 8) // dispatch to base 8
else if (base == 10) // dispatch to base 10
else if (base == 16) // dispatch to base 16
else // general implementation

I'm not saying use if over switch or whatever -- I'm just saying IMO it would make sense to check for the base, optimize for a few common bases (for a modest increase in code size in the dylib), and then fallback to a general implementation available as templates that will be compiled in the user's binaries. WDYT?

[ldionne]

So if that wasn't clear, I think I'm saying I agree with you that (3) seems like what we want to do.

[Mordante]

In D97705#2689775, @ldionne wrote:

So if that wasn't clear, I think I'm saying I agree with you that (3) seems like what we want to do.

Thanks for your feedback! Then I'll proceed with method 3. I'll make a separate review to fix the bug and then use this review to do the optimization for bases 2, 8, and 16.

[Mordante]

A new version testing some different optimizations options.
Test to see whether it passes a CI run.

[Mordante]

Remove tabs. The CI failed on this the last run.

[Mordante]

Rebased and using the fastest solution.

[Mordante]

In D97705#2689772, @ldionne wrote:

I think it would make sense to have a general implementation that works for all bases, and then have a few common bases (likely 2, 8, 10, 16 as you say) be compiled in the library. I think the top-level could look something like:

I think moving code to the library will only be temporary. It seems the direction is to make these functions constexpr in C++23. https://wg21.link/p2291r3

libcxx/include/charconv

635

Run 1 -> #if 0
Run 2 -> #if 1

[• Quuxplusone]

Still some scattered #if 0/1s left to remove.

libcxx/include/charconv

369

The red flag here was the : unsigned (I was like, "why does the signedness matter? better study closer") but actually, why do we need an enumerator for this at all? It's used only twice, and in contexts like

      _VSTD::memcpy(__p, &__base_2_lut[4 * __c], 4);
~~~
      unsigned __c = __value % _Base;
      __value /= _Base;
      *--__p = "01"[__c];

The number 2 is hard-coded so many places here, two more won't make a difference (and will save two lines and eliminate a red flag). Ditto in the 8 and 16 cases.

(If this was to appease clang-tidy: Don't appease it. :))

374

I'd remove noexcept from line 331, as it's just noise. (Nobody relies on the noexceptness of this function.) Ditto throughout — I assume there will be other redundant noexcepts.

398

Is Clang smart enough to optimize this into '0' + __c? Would the latter be more readable anyway? (Note there is no issue with EBCDIC here; all charsets must have '0'+1 == '1' according to the standard.)
Ditto line 413.

403

Either constexpr if this is C++11-and-later, or _LIBCPP_CONSTEXPR const, surely?

530

__enable_if_t<sizeof(_Tp) >= sizeof(unsigned)>* = nullptr is the more traditional libc++ism. (enable_if_t if this is C++14-and-later.)

[Mordante]

Thanks for the review! The patch is still RFC to see whether this is the direction we want to go. Hence the remaining #if and the lack of polish.

[ldionne]

In D97705#3262177, @Mordante wrote:

Thanks for the review! The patch is still RFC to see whether this is the direction we want to go. Hence the remaining #if and the lack of polish.

Just to make sure I understand (the review summary is difficult to read for me due to formatting issues), we have a base implementation using __to_chars_itoa, and then we also have implementations specific to other bases that use __to_chars_integral<2> and friends. When those base-specific implementations are enabled, we get roughly 3x performance improvement on those bases, at the cost of < 256 bytes of size for a lookup table. That's right?

If so, I'd say make the optimization non-customizeable and always use it.

[Mordante]

In D97705#3349302, @ldionne wrote:

In D97705#3262177, @Mordante wrote:

Just to make sure I understand (the review summary is difficult to read for me due to formatting issues), we have a base implementation using __to_chars_itoa, and then we also have implementations specific to other bases that use __to_chars_integral<2> and friends. When those base-specific implementations are enabled, we get roughly 3x performance improvement on those bases, at the cost of < 256 bytes of size for a lookup table. That's right?

The size of the lookup table differs, 64-bytes for base 2, 128-bytes for base 8, and 512-bytes for base 16.
The speedup is 14 times for base 2, 3 times for base 8, and 2 times for base 16.

libcxx/include/charconv

369

No it had nothing to do with clang-tidy ;-) This was from an earlier experiment it had a generic form for other integral values. However there the size/speed benefit wasn't great so most of that was removed. Now this is also gone.

398

The entire file uses this style, including places are _Base > 10. So I prefer to keep it as is.

403

This was copy-pasted from another part of this file. D121223 addresses these places.

530

This is the same as other places in this file, so I prefer to keep it.
Note the enable_if specifies the type as int so nullptr isn't an option.

[• Quuxplusone]

libcxx/include/charconv

530

This is the same as other places in this file, so I prefer to keep it.

OK.

Note the enable_if specifies the type as int so nullptr isn't an option.

FWIW: The existing enable_if comes out to int = 0, but in my suggested "more traditional libc++ism" rewrite, the __enable_if_t would come out to void* = nullptr instead. I don't see a problem there, so either I'm missing something or you were. (The rewrite would change the mangling, but this is hide-from-abi so we shouldn't care.)

[Mordante]

libcxx/include/charconv

530

I prefer to keep them in this style to keep the file uniform. It indeed shouldn't be an ABI break, but I rather keep them as-is, just in case there is an issue.

[Mordante]

Rebase and address review comments.

[ldionne]

This looks sensible to me.

libcxx/include/charconv

548

I don't think we need _LIBCPP_AVAILABILITY_TO_CHARS here, since this is all implemented in the headers. Or did I miss a dependency on the dylib?

[philnik]

libcxx/include/charconv

617–623

Does this [[likely]] make any difference?

[Mordante]

Rebased and address review comments.
Will land when the build passes.

[Mordante]

libcxx/include/charconv

548

Good catch!

617–623

Yes I've measured in the benchmarks that it makes improvements. However I plan to refactor this file to prepare for https://wg21.link/p2291r3 "Add Constexpr Modifiers to Functions to_chars and from_chars for Integral Types in <charconv>" and 128-bit support. When the base 10 implementation moves to the header this attribute may have less benefit. But that requires another round of profiling.

libcxx/benchmarks/to_chars.bench.cpp

+//===----------------------------------------------------------------------===//
+// 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 <random>
+
+#include "benchmark/benchmark.h"
+#include "test_macros.h"
+
+static const std::array<unsigned, 1000> input = [] {
+  std::mt19937 generator;
+  std::uniform_int_distribution<unsigned> distribution(
+      0, std::numeric_limits<unsigned>::max());
+  std::array<unsigned, 1000> 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<sample, 1000> 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();
+}

libcxx/benchmarks/to_chars_inplace.bench.cpp

+//===----------------------------------------------------------------------===//
+// 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 <random>
+
+#include "benchmark/benchmark.h"
+#include "test_macros.h"
+
+static const std::array<unsigned, 1000> input = [] {
+  std::mt19937 generator;
+  std::uniform_int_distribution<unsigned> distribution(
+      0, std::numeric_limits<unsigned>::max());
+  std::array<unsigned, 1000> 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<sample, 1000> 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();
+}
+

libcxx/benchmarks/to_chars_inplace_multiplexed.bench.cpp

+//===----------------------------------------------------------------------===//
+// 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 <random>
+
+#include "benchmark/benchmark.h"
+#include "test_macros.h"
+
+static const std::array<unsigned, 1000> input = [] {
+  std::mt19937 generator;
+  std::uniform_int_distribution<unsigned> distribution(
+      0, std::numeric_limits<unsigned>::max());
+  std::array<unsigned, 1000> 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<sample, 1000> 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();
+}
+
+

libcxx/benchmarks/to_chars_inplace_multiplexed_for_format.bench.cpp

+//===----------------------------------------------------------------------===//
+// 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 <random>
+
+#include "benchmark/benchmark.h"
+#include "test_macros.h"
+
+static const std::array<unsigned, 1000> input = [] {
+  std::mt19937 generator;
+  std::uniform_int_distribution<unsigned> distribution(
+      0, std::numeric_limits<unsigned>::max());
+  std::array<unsigned, 1000> 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<sample, 1000> 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();
+}

libcxx/include/charconv

 } // namespace std
 
 */
 
 #include <__config>
 #include <__availability>
 #include <__errc>
 #include <cmath> // for log2f
+#include <cstdlib> // Why is _LIBCPP_UNREACHABLE in this header?
 #include <cstdint>
 #include <cstring>
 #include <limits>
 #include <type_traits>
 
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
__to_chars_integral(char* __first, char* __last, _Tp __value, int __base,
     {
         *__first++ = '-';
         __x = __complement(__x);
     }
 
     return __to_chars_integral(__first, __last, __x, __base, false_type());
 }
 
+// TODO REMOVE PROOF OF CONCEPT CODE {{{
+
+template <typename _Tp>
+_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 <typename _Tp>
+_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 <typename _Tp, unsigned _Base>
+_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 <typename _Tp, unsigned _Base>
+_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 <typename _Tp>
+_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 <typename _Tp>
+_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 <typename _Tp>
 _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());
 
     auto __p = __last;
     while (__p != __first)
     {
         auto __c = __value % __base;
         __value /= __base;
         *--__p = "0123456789abcdefghijklmnopqrstuvwxyz"[__c];
         if (__value == 0)
             break;
     }
 
     auto __len = __last - __p;
     if (__value != 0 || !__len)
         return {__last, errc::value_too_large};
     else
     {
         _VSTD::memmove(__first, __p, __len);
         return {__first + __len, {}};
     }
+#endif
 }
 
 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
 _LIBCPP_AVAILABILITY_TO_CHARS
 inline _LIBCPP_INLINE_VISIBILITY to_chars_result
 to_chars(char* __first, char* __last, _Tp __value)
 {
     return __to_chars_itoa(__first, __last, __value, is_signed<_Tp>());

libcxx/to_chars.txt

+---------------------------------------------------------------
+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

libcxx/to_chars_inplace.txt

+---------------------------------------------------------------
+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

libcxx/to_chars_inplace_multiplexed.txt

+---------------------------------------------------------------
+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

libcxx/to_chars_inplace_multiplexed_for_format.txt

+---------------------------------------------------------------
+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