util/generic/benchmark/log2/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

#include <library/cpp/testing/benchmark/bench.h>
 
#include <library/cpp/fast_log/fast_log.h>
 
#include <util/generic/singleton.h> 
#include <util/generic/vector.h> 
#include <util/random/fast.h> 
#include <util/generic/xrange.h> 
 
#include <cmath> 
namespace { 
    template <typename T, size_t N> 
    struct TExamplesHolder { 
        TVector<T> Examples;
 
        TExamplesHolder() 
            : Examples(N)
        {
            TFastRng<ui64> prng{N * 42}; 
            for (auto& x : Examples) { 
                x = prng.GenRandReal4() + prng.Uniform(1932); // 1934 is just a random number 
            } 
        } 
    }; 
} 
 
#define DEFINE_BENCHMARK(type, count)                                            \ 
    Y_CPU_BENCHMARK(libm_log2f_##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(log2f(e));                                \
            }                                                                    \
        }                                                                        \
    }                                                                            \
                                                                                 \
    Y_CPU_BENCHMARK(libm_logf_##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(logf(e));                                 \
            }                                                                    \
        }                                                                        \
    }                                                                            \
    Y_CPU_BENCHMARK(STL_Log2_##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(std::log2(e));                            \ 
            }                                                                    \ 
        }                                                                        \ 
    }                                                                            \ 
                                                                                 \ 
    Y_CPU_BENCHMARK(STL_Log_##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(std::log(e));                             \ 
            }                                                                    \ 
        }                                                                        \ 
    }                                                                            \ 
                                                                                 \ 
    Y_CPU_BENCHMARK(Fast_Log2_##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(FastLog2f(e));                            \ 
            }                                                                    \ 
        }                                                                        \ 
    }                                                                            \ 
                                                                                 \ 
    Y_CPU_BENCHMARK(FastLogf##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(FastLogf(e));                             \ 
            }                                                                    \ 
        }                                                                        \ 
    }                                                                            \ 
                                                                                 \ 
    Y_CPU_BENCHMARK(Faster_Log2_##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(FasterLog2f(e));                          \
            }                                                                    \ 
        }                                                                        \ 
    }                                                                            \ 
                                                                                 \ 
    Y_CPU_BENCHMARK(Faster_Log_##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(FasterLogf(e));                           \
            }                                                                    \ 
        }                                                                        \ 
    }                                                                            \
                                                                                 \
    Y_CPU_BENCHMARK(Fastest_Log2f_##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(FastestLog2f(e));                         \
            }                                                                    \
        }                                                                        \
    }                                                                            \
                                                                                 \
    Y_CPU_BENCHMARK(Fastest_Log_##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(FastestLogf(e));                          \
            }                                                                    \
        }                                                                        \
    } 
 
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(float, 1024) 
DEFINE_BENCHMARK(float, 2048) 
DEFINE_BENCHMARK(float, 4096) 
 
#undef DEFINE_BENCHMARK