util/string/benchmark/float_to_string/main.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253

#include <library/cpp/testing/benchmark/bench.h>

#include <util/generic/singleton.h>
#include <util/generic/vector.h>
#include <util/generic/xrange.h>
#include <util/generic/ymath.h>
#include <util/random/fast.h>
#include <util/string/cast.h>
#include <util/string/printf.h>

#include <limits>

#include <cmath>

/* Please be careful before making any decisions based on this benchmark.
 *
 * Only `Sprintf("%.<decimals>f", x)` and `FloatToString(x, PREC_POINT_DIGITS, decimals` produce
 * equal results in general case. However, results for cases when x \in [0, 1) must be equal for
 * both `Sprintf` and `FloatToString`.
 *
 * Read more about formatting in STL [1, 2] and Yandex Util formatting [3]
 *
 * [1] http://www.cplusplus.com/reference/cstdio/printf/
 * [2] http://en.cppreference.com/w/c/io/fprintf
 * [3] https://a.yandex-team.ru/arc/trunk/arcadia/util/string/cast.h?rev=2432660#L29
 */

namespace {
    template <typename T>
    struct TExample {
        T Value{};
        int DigitsCount{};
    };

    template <typename T, size_t N>
    struct TExamplesHolder {
        TVector<TExample<T>> Examples;

        TExamplesHolder()
            : Examples(N)
        {
            TFastRng<ui64> prng{N * sizeof(T) * 42};
            for (auto& x : Examples) {
                x.Value = prng.GenRandReal4() + prng.Uniform(Max<ui16>());
                x.DigitsCount = prng.Uniform(std::numeric_limits<T>::max_digits10 + 1);
            }
        }
    };

    template <typename T, size_t N>
    struct TNearZeroExamplesHolder {
        TVector<TExample<T>> Examples;

        TNearZeroExamplesHolder()
            : Examples(N)
        {
            TFastRng<ui64> prng{N * sizeof(T) * 42};
            for (auto& x : Examples) {
                x.Value = prng.GenRandReal4();
                x.DigitsCount = prng.Uniform(std::numeric_limits<T>::max_digits10 + 1);
            }
        }
    };
}

static const char* FORMAT_FIXED[] = {
    "%.0f",
    "%.1f",
    "%.2f",
    "%.3f",
    "%.4f",
    "%.5f",
    "%.6f",
    "%.7f",
    "%.8f",
    "%.9f",
    "%.10f",
    "%.11f",
    "%.12f",
    "%.13f",
    "%.14f",
    "%.15f",
    "%.16f",
    "%.17f",
};

static const char* FORMAT_SIGNIFICANT[] = {
    "%.0g",
    "%.1g",
    "%.2g",
    "%.3g",
    "%.4g",
    "%.5g",
    "%.6g",
    "%.7g",
    "%.8g",
    "%.9g",
    "%.10g",
    "%.11g",
    "%.12g",
    "%.13g",
    "%.14g",
    "%.15g",
    "%.16g",
    "%.17g",
};

#define DEFINE_BENCHMARK(type, count)                                                                \
    Y_CPU_BENCHMARK(SprintfAuto_##type##_##count, iface) {                                           \
        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
        for (const auto i : xrange(iface.Iterations())) {                                            \
            Y_UNUSED(i);                                                                             \
            for (const auto e : examples) {                                                          \
                /* this is in fact equal to Sprintf("%.6f", e.Value) and that is why it is faster */ \
                /* than FloatToString(e.Value) */                                                    \
                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf("%f", e.Value));                                      \
            }                                                                                        \
        }                                                                                            \
    }                                                                                                \
                                                                                                     \
    Y_CPU_BENCHMARK(FloatToStringAuto_##type##_##count, iface) {                                     \
        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
        for (const auto i : xrange(iface.Iterations())) {                                            \
            Y_UNUSED(i);                                                                             \
            for (const auto e : examples) {                                                          \
                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value));                                      \
            }                                                                                        \
        }                                                                                            \
    }                                                                                                \
                                                                                                     \
    Y_CPU_BENCHMARK(SprintfFixed_##type##_##count, iface) {                                          \
        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
        for (const auto i : xrange(iface.Iterations())) {                                            \
            Y_UNUSED(i);                                                                             \
            for (const auto e : examples) {                                                          \
                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_FIXED[e.DigitsCount], e.Value));               \
            }                                                                                        \
        }                                                                                            \
    }                                                                                                \
                                                                                                     \
    Y_CPU_BENCHMARK(FloatToStringFixed_##type##_##count, iface) {                                    \
        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
        for (const auto i : xrange(iface.Iterations())) {                                            \
            Y_UNUSED(i);                                                                             \
            for (const auto e : examples) {                                                          \
                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_NDIGITS, e.DigitsCount));         \
            }                                                                                        \
        }                                                                                            \
    }                                                                                                \
                                                                                                     \
    Y_CPU_BENCHMARK(SprintfSignificant_##type##_##count, iface) {                                    \
        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
        for (const auto i : xrange(iface.Iterations())) {                                            \
            Y_UNUSED(i);                                                                             \
            for (const auto e : examples) {                                                          \
                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_SIGNIFICANT[e.DigitsCount], e.Value));         \
            }                                                                                        \
        }                                                                                            \
    }                                                                                                \
                                                                                                     \
    Y_CPU_BENCHMARK(FloatToStringSignificant_##type##_##count, iface) {                              \
        const auto& examples = Default<TExamplesHolder<type, count>>().Examples;                     \
        for (const auto i : xrange(iface.Iterations())) {                                            \
            Y_UNUSED(i);                                                                             \
            for (const auto e : examples) {                                                          \
                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_POINT_DIGITS, e.DigitsCount));    \
            }                                                                                        \
        }                                                                                            \
    }                                                                                                \
                                                                                                     \
    Y_CPU_BENCHMARK(NearZeroSprintfAuto_##type##_##count, iface) {                                   \
        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
        for (const auto i : xrange(iface.Iterations())) {                                            \
            Y_UNUSED(i);                                                                             \
            for (const auto e : examples) {                                                          \
                /* this is in fact equal to Sprintf("%.6f", e.Value) and that is why it is faster */ \
                /* than FloatToString(e.Value) */                                                    \
                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf("%f", e.Value));                                      \
            }                                                                                        \
        }                                                                                            \
    }                                                                                                \
                                                                                                     \
    Y_CPU_BENCHMARK(NearZeroFloatToStringAuto_##type##_##count, iface) {                             \
        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
        for (const auto i : xrange(iface.Iterations())) {                                            \
            Y_UNUSED(i);                                                                             \
            for (const auto e : examples) {                                                          \
                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value));                                      \
            }                                                                                        \
        }                                                                                            \
    }                                                                                                \
                                                                                                     \
    Y_CPU_BENCHMARK(NearZeroSprintfFixed_##type##_##count, iface) {                                  \
        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
        for (const auto i : xrange(iface.Iterations())) {                                            \
            Y_UNUSED(i);                                                                             \
            for (const auto e : examples) {                                                          \
                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_FIXED[e.DigitsCount], e.Value));               \
            }                                                                                        \
        }                                                                                            \
    }                                                                                                \
                                                                                                     \
    Y_CPU_BENCHMARK(NearZeroFloatToStringFixed_##type##_##count, iface) {                            \
        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
        for (const auto i : xrange(iface.Iterations())) {                                            \
            Y_UNUSED(i);                                                                             \
            for (const auto e : examples) {                                                          \
                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_NDIGITS, e.DigitsCount));         \
            }                                                                                        \
        }                                                                                            \
    }                                                                                                \
                                                                                                     \
    Y_CPU_BENCHMARK(NearZeroSprintfSignificant_##type##_##count, iface) {                            \
        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
        for (const auto i : xrange(iface.Iterations())) {                                            \
            Y_UNUSED(i);                                                                             \
            for (const auto e : examples) {                                                          \
                Y_DO_NOT_OPTIMIZE_AWAY(Sprintf(FORMAT_SIGNIFICANT[e.DigitsCount], e.Value));         \
            }                                                                                        \
        }                                                                                            \
    }                                                                                                \
                                                                                                     \
    Y_CPU_BENCHMARK(NearZeroFloatToStringSignificant_##type##_##count, iface) {                      \
        const auto& examples = Default<TNearZeroExamplesHolder<type, count>>().Examples;             \
        for (const auto i : xrange(iface.Iterations())) {                                            \
            Y_UNUSED(i);                                                                             \
            for (const auto e : examples) {                                                          \
                Y_DO_NOT_OPTIMIZE_AWAY(FloatToString(e.Value, PREC_POINT_DIGITS, e.DigitsCount));    \
            }                                                                                        \
        }                                                                                            \
    }

DEFINE_BENCHMARK(float, 1);
DEFINE_BENCHMARK(float, 2);
DEFINE_BENCHMARK(float, 4);
DEFINE_BENCHMARK(float, 8);
DEFINE_BENCHMARK(float, 16);
DEFINE_BENCHMARK(float, 32);
DEFINE_BENCHMARK(float, 64);
DEFINE_BENCHMARK(float, 128);
DEFINE_BENCHMARK(float, 256);

DEFINE_BENCHMARK(double, 1);
DEFINE_BENCHMARK(double, 2);
DEFINE_BENCHMARK(double, 4);
DEFINE_BENCHMARK(double, 8);
DEFINE_BENCHMARK(double, 16);
DEFINE_BENCHMARK(double, 32);
DEFINE_BENCHMARK(double, 64);
DEFINE_BENCHMARK(double, 128);
DEFINE_BENCHMARK(double, 256);

#undef DEFINE_BENCHMARK