• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2013 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "benchmark.h"
18 
19 #include <fenv.h>
20 #include <math.h>
21 
22 // Avoid optimization.
23 double d;
24 double v;
25 
BM_math_sqrt(int iters)26 static void BM_math_sqrt(int iters) {
27   StartBenchmarkTiming();
28 
29   d = 0.0;
30   v = 2.0;
31   for (int i = 0; i < iters; ++i) {
32     d += sqrt(v);
33   }
34 
35   StopBenchmarkTiming();
36 }
37 BENCHMARK(BM_math_sqrt);
38 
BM_math_log10(int iters)39 static void BM_math_log10(int iters) {
40   StartBenchmarkTiming();
41 
42   d = 0.0;
43   v = 1234.0;
44   for (int i = 0; i < iters; ++i) {
45     d += log10(v);
46   }
47 
48   StopBenchmarkTiming();
49 }
50 BENCHMARK(BM_math_log10);
51 
BM_math_logb(int iters)52 static void BM_math_logb(int iters) {
53   StartBenchmarkTiming();
54 
55   d = 0.0;
56   v = 1234.0;
57   for (int i = 0; i < iters; ++i) {
58     d += logb(v);
59   }
60 
61   StopBenchmarkTiming();
62 }
63 BENCHMARK(BM_math_logb);
64 
BM_math_isinf_NORMAL(int iters)65 static void BM_math_isinf_NORMAL(int iters) {
66   StartBenchmarkTiming();
67 
68   d = 0.0;
69   v = 1234.0; // FP_NORMAL
70   for (int i = 0; i < iters; ++i) {
71     d += (isinf)(v);
72   }
73 
74   StopBenchmarkTiming();
75 }
76 BENCHMARK(BM_math_isinf_NORMAL);
77 
BM_math_isinf_NAN(int iters)78 static void BM_math_isinf_NAN(int iters) {
79   StartBenchmarkTiming();
80 
81   d = 0.0;
82   v = nan(""); // FP_NAN
83   for (int i = 0; i < iters; ++i) {
84     d += (isinf)(v);
85   }
86 
87   StopBenchmarkTiming();
88 }
89 BENCHMARK(BM_math_isinf_NAN);
90 
BM_math_isinf_INFINITE(int iters)91 static void BM_math_isinf_INFINITE(int iters) {
92   StartBenchmarkTiming();
93 
94   d = 0.0;
95   v = HUGE_VAL; // FP_INFINITE
96   for (int i = 0; i < iters; ++i) {
97     d += (isinf)(v);
98   }
99 
100   StopBenchmarkTiming();
101 }
102 BENCHMARK(BM_math_isinf_INFINITE);
103 
BM_math_isinf_ZERO(int iters)104 static void BM_math_isinf_ZERO(int iters) {
105   StartBenchmarkTiming();
106 
107   d = 0.0;
108   v = 0.0; // FP_ZERO
109   for (int i = 0; i < iters; ++i) {
110     d += (isinf)(v);
111   }
112 
113   StopBenchmarkTiming();
114 }
115 BENCHMARK(BM_math_isinf_ZERO);
116 
BM_math_sin_fast(int iters)117 static void BM_math_sin_fast(int iters) {
118   StartBenchmarkTiming();
119 
120   d = 1.0;
121   for (int i = 0; i < iters; ++i) {
122     d += sin(d);
123   }
124 
125   StopBenchmarkTiming();
126 }
127 BENCHMARK(BM_math_sin_fast);
128 
BM_math_sin_feupdateenv(int iters)129 static void BM_math_sin_feupdateenv(int iters) {
130   StartBenchmarkTiming();
131 
132   d = 1.0;
133   for (int i = 0; i < iters; ++i) {
134     fenv_t __libc_save_rm;
135     feholdexcept(&__libc_save_rm);
136     fesetround(FE_TONEAREST);
137     d += sin(d);
138     feupdateenv(&__libc_save_rm);
139   }
140 
141   StopBenchmarkTiming();
142 }
143 BENCHMARK(BM_math_sin_feupdateenv);
144 
BM_math_sin_fesetenv(int iters)145 static void BM_math_sin_fesetenv(int iters) {
146   StartBenchmarkTiming();
147 
148   d = 1.0;
149   for (int i = 0; i < iters; ++i) {
150     fenv_t __libc_save_rm;
151     feholdexcept(&__libc_save_rm);
152     fesetround(FE_TONEAREST);
153     d += sin(d);
154     fesetenv(&__libc_save_rm);
155   }
156 
157   StopBenchmarkTiming();
158 }
159 BENCHMARK(BM_math_sin_fesetenv);
160 
BM_math_fpclassify_NORMAL(int iters)161 static void BM_math_fpclassify_NORMAL(int iters) {
162   StartBenchmarkTiming();
163 
164   d = 0.0;
165   v = 1234.0; // FP_NORMAL
166   for (int i = 0; i < iters; ++i) {
167     d += fpclassify(v);
168   }
169 
170   StopBenchmarkTiming();
171 }
172 BENCHMARK(BM_math_fpclassify_NORMAL);
173 
BM_math_fpclassify_NAN(int iters)174 static void BM_math_fpclassify_NAN(int iters) {
175   StartBenchmarkTiming();
176 
177   d = 0.0;
178   v = nan(""); // FP_NAN
179   for (int i = 0; i < iters; ++i) {
180     d += fpclassify(v);
181   }
182 
183   StopBenchmarkTiming();
184 }
185 BENCHMARK(BM_math_fpclassify_NAN);
186 
BM_math_fpclassify_INFINITE(int iters)187 static void BM_math_fpclassify_INFINITE(int iters) {
188   StartBenchmarkTiming();
189 
190   d = 0.0;
191   v = HUGE_VAL; // FP_INFINITE
192   for (int i = 0; i < iters; ++i) {
193     d += fpclassify(v);
194   }
195 
196   StopBenchmarkTiming();
197 }
198 BENCHMARK(BM_math_fpclassify_INFINITE);
199 
BM_math_fpclassify_ZERO(int iters)200 static void BM_math_fpclassify_ZERO(int iters) {
201   StartBenchmarkTiming();
202 
203   d = 0.0;
204   v = 0.0; // FP_ZERO
205   for (int i = 0; i < iters; ++i) {
206     d += fpclassify(v);
207   }
208 
209   StopBenchmarkTiming();
210 }
211 BENCHMARK(BM_math_fpclassify_ZERO);
212