dtoa benchmark

This project is a rewrite of Milo Yip’s dtoa-benchmark with an updated set of algorithms reflecting the current state of the art and a simplified workflow.

Introduction

This benchmark measures the performance of converting double-precision IEEE-754 floating-point values (double) to ASCII strings. Each implementation exposes a function with the signature:

char* dtoa(double value, char* buffer);

that writes a textual representation of value into buffer and returns a pointer to one past the last written character. The resulting string must round-trip: parsing it back through a correct strtod must yield exactly the original double.

Note: dtoa is not a standard C or C++ function.

Procedure

The benchmark runs in two phases:

1. Correctness verification. Every implementation is validated against a set of edge cases and 100,000 random double values (excluding ±inf and NaN) to confirm round-trip correctness.

2. Performance measurement. For each implementation the benchmark runs:

   • 17 per-digit sub-benchmarks. Each converts a pool of 100,000 random double values reduced to a fixed precision of 1–17 significant decimal digits. These produce the time vs. digit count chart.
   • One mixed benchmark over a single shuffled pool containing all 1.7M values from the per-digit pools combined. Its mean time per conversion is reported as the headline Time (ns) in the results table; this is the metric to use for an at-a-glance comparison.

   Iteration counts and statistical stabilization are handled by Google Benchmark.

Build and Run

cmake .
make run-benchmark

Results are written in Google Benchmark's JSON format to:

results/<cpu>_<os>_<compiler>_<commit>.json

and automatically converted to a self-contained HTML report with the same base name. The JSON context block carries CPU/cache info, library version, and commit_hash/machine/os/compiler keys for downstream analysis.

Results

The following results were measured on a MacBook Pro (Apple M1 Pro) using:

• Compiler: Apple clang version 21.0.0 (clang-2100.0.123.102)
• OS: macOS

Time per double (smaller is better):

ostringstream and sprintf omitted; they are an order of magnitude slower than the rest.

Time vs digit count (log scale):

Notes

• null performs no conversion and measures loop + call overhead.
• sprintf and ostringstream do not generate shortest representations (e.g. 0.1 → 0.10000000000000001).
• ryu, dragonbox, and schubfach always emit exponential notation (e.g. 0.1 → 1E-1).

Additional benchmark results are available in the results directory and viewable online.

Methods

Notes

std::to_string is excluded because it does not guarantee round-trip correctness (until C++26).

Why is fast dtoa important?

Floating-point formatting is ubiquitous in text output. Standard facilities such as sprintf and std::stringstream are often slow. This benchmark originated from performance work in RapidJSON.

See Also

• Faster double-to-string conversion
• The smallest state-of-the-art double-to-string implementation