This is a fork of Milo Yip's dtoa-benchmark with the following changes:

• CMake support
• Fixed reporting of results
• {fmt} test
• Dragonbox test
• Removed the use of deprecated strstream

Copyright(c) 2014 Milo Yip ([email protected])

This benchmark evaluates the performance of conversion from double precision IEEE-754 floating point (double) to ASCII string. The function prototype is:

void dtoa(double value, char* buffer);

The character string result must be convertible to the original value exactly via some correct implementation of strtod(), i.e. roundtrip convertible.

Note that dtoa() is not a standard function in C and C++.

Firstly the program verifies the correctness of implementations.

Then, one case for benchmark is carried out:

1. RandomDigit: Generates 1000 random double values, filtered out +/-inf and nan. Then convert them to limited precision (1 to 17 decimal digits in significand). Finally convert these numbers into ASCII.

Each digit group is run for 100 times. The minimum time duration is measured for 10 trials.

1. Configure: cmake .
2. Build and run benchmark: make run-benchmark

The results in CSV format will be written to the file result/<cpu>_<os>_<compiler>.csv and automatically converted to HTML with the same base name and the .html extension.

The following are results measured on a MacBook Pro (Apple M1 Pro), where dtoa() is compiled by Apple clang 17.0.0 (clang-1700.0.13.5) and run on macOS. The speedup is based on sprintf().

Function Time (ns) Speedup ostringstream 875.881 0.84x sprintf 735.583 1.00x doubleconv 84.102 8.75x fpconv 63.091 11.66x grisu2 59.064 12.45x ryu 36.949 19.91x fmt 22.345 32.92x dragonbox 20.626 35.66x null 0.931 790.45x

Notes:

• The null implementation does nothing. It measures the overheads of looping and function call.
• sprintf and ostringstream don't generate the shortest representation, e.g. 0.1 is formatted as 0.10000000000000001.
• ryu and dragonbox_* only produce the output in the exponential format, e.g. 0.1 is formatted as 1E-1.

Some results of various configurations are located at result. They can be accessed online, with interactivity provided by Google Charts:

• apple-m1-pro_mac64_clang17.0

Notes:

1. std::to_string() is not tested as it does not fulfill the roundtrip requirement (until C++26).

2. Grisu2 is chosen because it can generate better human-readable number and >99.9% of results are in shortest. Grisu3 needs another dtoa() implementation for not meeting the shortest requirement.

1. How to add an implementation?

   You may clone an existing implementation file. And then modify it and add to the CMake config. Note that it will automatically register to the benchmark by macro REGISTER_TEST(name).

   Making a pull request of new implementations is welcome.

2. Why not converting double to std::string?

   It may introduce heap allocation, which is a big overhead. User can easily wrap these low-level functions to return std::string, if needed.

3. Why fast dtoa() functions is needed?

   They are a very common operations in writing data in text format. The standard way of sprintf(), std::stringstream, often provides poor performance. The author of this benchmark would optimize the sprintf implementation in RapidJSON, thus he creates this project.

[1] Loitsch, Florian. "Printing floating-point numbers quickly and accurately with integers." ACM Sigplan Notices 45.6 (2010): 233-243.

• Printing Floating-Point Numbers