GitHub - fmtlib/dtoa-benchmark: C++ double-to-string conversion benchmark (original) (raw)

dtoa Benchmark

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

Copyright(c) 2014 Milo Yip (miloyip@gmail.com)

Introduction

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 valueexactly via some correct implementation of strtod, i.e. roundtrip convertible.

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

Procedure

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.

Build and Run

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

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

Results

The following are results measured on a MacBook Pro (Apple M1 Pro), wheredtoa 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 872.266 1.00x
sprintf 734.468 1.19x
puff 629.306 1.39x
doubleconv 84.213 10.36x
to_chars 42.864 20.35x
ryu 37.278 23.40x
schubfach 24.728 35.27x
fmt 22.299 39.12x
dragonbox 20.636 42.27x
null 0.930 937.92x

image image

Notes:

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

Implementations

Function Description
ostringstream std::ostringstream in C++ standard library with setprecision(17).
sprintf sprintf in C standard library with "%.17g" format.
doubleconv C++ implementation extracted from Google's V8 JavaScript Engine with EcmaScriptConverter().ToShortest() (based on Grisu3, fall back to slower bignum algorithm when Grisu3 failed to produce shortest implementation).
fmt fmt::format_to with format string compilation (implements Dragonbox).
dragonbox jkj::dragonbox::to_chars with full tables.
schubfach Schubfach implementation in C++
null Do nothing.

Notes:

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

FAQ

  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 sprintfimplementation in RapidJSON, thus he creates this project.