proxygen
Functions
MathBenchmark.cpp File Reference
#include <folly/Math.h>
#include <algorithm>
#include <random>
#include <folly/Benchmark.h>

Go to the source code of this file.

Functions

 BENCHMARK_DRAW_LINE ()
 
 BENCHMARK (divTruncInt8, iters)
 
 BENCHMARK (divFloorInt8, iters)
 
 BENCHMARK (divCeilInt8, iters)
 
 BENCHMARK_RELATIVE (branchlessDivCeilInt8, iters)
 
 BENCHMARK_RELATIVE (branchfulDivCeilInt8, iters)
 
 BENCHMARK_RELATIVE (brokenButWidespreadDivCeilInt8, iters)
 
 BENCHMARK_RELATIVE (viaFloatDivCeilInt8, iters)
 
 BENCHMARK_RELATIVE (viaDoubleDivCeilInt8, iters)
 
 BENCHMARK_RELATIVE (viaLongDoubleDivCeilInt8, iters)
 
 BENCHMARK (divRoundAwayInt8, iters)
 
 BENCHMARK (divTruncInt16, iters)
 
 BENCHMARK (divFloorInt16, iters)
 
 BENCHMARK (divCeilInt16, iters)
 
 BENCHMARK_RELATIVE (branchlessDivCeilInt16, iters)
 
 BENCHMARK_RELATIVE (branchfulDivCeilInt16, iters)
 
 BENCHMARK_RELATIVE (brokenButWidespreadDivCeilInt16, iters)
 
 BENCHMARK_RELATIVE (viaFloatDivCeilInt16, iters)
 
 BENCHMARK_RELATIVE (viaDoubleDivCeilInt16, iters)
 
 BENCHMARK_RELATIVE (viaLongDoubleDivCeilInt16, iters)
 
 BENCHMARK (divRoundAwayInt16, iters)
 
 BENCHMARK (divTruncInt32, iters)
 
 BENCHMARK (divFloorInt32, iters)
 
 BENCHMARK (divCeilInt32, iters)
 
 BENCHMARK_RELATIVE (branchlessDivCeilInt32, iters)
 
 BENCHMARK_RELATIVE (branchfulDivCeilInt32, iters)
 
 BENCHMARK_RELATIVE (brokenButWidespreadDivCeilInt32, iters)
 
 BENCHMARK_RELATIVE (approxViaFloatDivCeilInt32, iters)
 
 BENCHMARK_RELATIVE (viaDoubleDivCeilInt32, iters)
 
 BENCHMARK_RELATIVE (viaLongDoubleDivCeilInt32, iters)
 
 BENCHMARK (divRoundAwayInt32, iters)
 
 BENCHMARK (divTruncInt64, iters)
 
 BENCHMARK (divFloorInt64, iters)
 
 BENCHMARK (divCeilInt64, iters)
 
 BENCHMARK_RELATIVE (branchlessDivCeilInt64, iters)
 
 BENCHMARK_RELATIVE (branchfulDivCeilInt64, iters)
 
 BENCHMARK_RELATIVE (brokenButWidespreadDivCeilInt64, iters)
 
 BENCHMARK_RELATIVE (approxViaFloatDivCeilInt64, iters)
 
 BENCHMARK_RELATIVE (approxViaDoubleDivCeilInt64, iters)
 
 BENCHMARK_RELATIVE (viaLongDoubleDivCeilInt64, iters)
 
 BENCHMARK (divRoundAwayInt64, iters)
 
 BENCHMARK (divTruncUint8, iters)
 
 BENCHMARK (divFloorUint8, iters)
 
 BENCHMARK (divCeilUint8, iters)
 
 BENCHMARK_RELATIVE (branchlessDivCeilUint8, iters)
 
 BENCHMARK_RELATIVE (branchfulDivCeilUint8, iters)
 
 BENCHMARK_RELATIVE (brokenButWidespreadDivCeilUint8, iters)
 
 BENCHMARK_RELATIVE (viaFloatDivCeilUint8, iters)
 
 BENCHMARK_RELATIVE (viaDoubleDivCeilUint8, iters)
 
 BENCHMARK_RELATIVE (viaLongDoubleDivCeilUint8, iters)
 
 BENCHMARK (divRoundAwayUint8, iters)
 
 BENCHMARK (divTruncUint16, iters)
 
 BENCHMARK (divFloorUint16, iters)
 
 BENCHMARK (divCeilUint16, iters)
 
 BENCHMARK_RELATIVE (branchlessDivCeilUint16, iters)
 
 BENCHMARK_RELATIVE (branchfulDivCeilUint16, iters)
 
 BENCHMARK_RELATIVE (brokenButWidespreadDivCeilUint16, iters)
 
 BENCHMARK_RELATIVE (viaFloatDivCeilUint16, iters)
 
 BENCHMARK_RELATIVE (viaDoubleDivCeilUint16, iters)
 
 BENCHMARK_RELATIVE (viaLongDoubleDivCeilUint16, iters)
 
 BENCHMARK (divRoundAwayUint16, iters)
 
 BENCHMARK (divTruncUint32, iters)
 
 BENCHMARK (divFloorUint32, iters)
 
 BENCHMARK (divCeilUint32, iters)
 
 BENCHMARK_RELATIVE (branchlessDivCeilUint32, iters)
 
 BENCHMARK_RELATIVE (branchfulDivCeilUint32, iters)
 
 BENCHMARK_RELATIVE (brokenButWidespreadDivCeilUint32, iters)
 
 BENCHMARK_RELATIVE (approxViaFloatDivCeilUint32, iters)
 
 BENCHMARK_RELATIVE (viaDoubleDivCeilUint32, iters)
 
 BENCHMARK_RELATIVE (viaLongDoubleDivCeilUint32, iters)
 
 BENCHMARK (divRoundAwayUint32, iters)
 
 BENCHMARK (divTruncUint64, iters)
 
 BENCHMARK (divFloorUint64, iters)
 
 BENCHMARK (divCeilUint64, iters)
 
 BENCHMARK_RELATIVE (branchlessDivCeilUint64, iters)
 
 BENCHMARK_RELATIVE (branchfulDivCeilUint64, iters)
 
 BENCHMARK_RELATIVE (brokenButWidespreadDivCeilUint64, iters)
 
 BENCHMARK_RELATIVE (approxViaFloatDivCeilUint64, iters)
 
 BENCHMARK_RELATIVE (approxViaDoubleDivCeilUint64, iters)
 
 BENCHMARK_RELATIVE (viaLongDoubleDivCeilUint64, iters)
 
 BENCHMARK (divRoundAwayUint64, iters)
 
int main (int argc, char **argv)
 

Function Documentation

BENCHMARK ( divTruncInt8  ,
iters   
)

Definition at line 95 of file MathBenchmark.cpp.

95  {
96  runDivTests<int8_t>(&folly::divTrunc<int8_t, int8_t>, iters);
97 }
BENCHMARK ( divFloorInt8  ,
iters   
)

Definition at line 98 of file MathBenchmark.cpp.

98  {
99  runDivTests<int8_t>(&folly::divFloor<int8_t, int8_t>, iters);
100 }
BENCHMARK ( divCeilInt8  ,
iters   
)

Definition at line 101 of file MathBenchmark.cpp.

101  {
102  runDivTests<int8_t>(&folly::divCeil<int8_t, int8_t>, iters);
103 }
BENCHMARK ( divRoundAwayInt8  ,
iters   
)

Definition at line 122 of file MathBenchmark.cpp.

References BENCHMARK_DRAW_LINE().

122  {
123  runDivTests<int8_t>(&folly::divRoundAway<int8_t, int8_t>, iters);
124 }
BENCHMARK ( divTruncInt16  ,
iters   
)

Definition at line 127 of file MathBenchmark.cpp.

127  {
128  runDivTests<int16_t>(&folly::divTrunc<int16_t, int16_t>, iters);
129 }
BENCHMARK ( divFloorInt16  ,
iters   
)

Definition at line 130 of file MathBenchmark.cpp.

130  {
131  runDivTests<int16_t>(&folly::divFloor<int16_t, int16_t>, iters);
132 }
BENCHMARK ( divCeilInt16  ,
iters   
)

Definition at line 133 of file MathBenchmark.cpp.

133  {
134  runDivTests<int16_t>(&folly::divCeil<int16_t, int16_t>, iters);
135 }
BENCHMARK ( divRoundAwayInt16  ,
iters   
)

Definition at line 154 of file MathBenchmark.cpp.

References BENCHMARK_DRAW_LINE().

154  {
155  runDivTests<int16_t>(&folly::divRoundAway<int16_t, int16_t>, iters);
156 }
BENCHMARK ( divTruncInt32  ,
iters   
)

Definition at line 159 of file MathBenchmark.cpp.

159  {
160  runDivTests<int32_t>(&folly::divTrunc<int32_t, int32_t>, iters);
161 }
BENCHMARK ( divFloorInt32  ,
iters   
)

Definition at line 162 of file MathBenchmark.cpp.

162  {
163  runDivTests<int32_t>(&folly::divFloor<int32_t, int32_t>, iters);
164 }
BENCHMARK ( divCeilInt32  ,
iters   
)

Definition at line 165 of file MathBenchmark.cpp.

165  {
166  runDivTests<int32_t>(&folly::divCeil<int32_t, int32_t>, iters);
167 }
BENCHMARK ( divRoundAwayInt32  ,
iters   
)

Definition at line 186 of file MathBenchmark.cpp.

References BENCHMARK_DRAW_LINE().

186  {
187  runDivTests<int32_t>(&folly::divRoundAway<int32_t, int32_t>, iters);
188 }
BENCHMARK ( divTruncInt64  ,
iters   
)

Definition at line 191 of file MathBenchmark.cpp.

191  {
192  runDivTests<int64_t>(&folly::divTrunc<int64_t, int64_t>, iters);
193 }
BENCHMARK ( divFloorInt64  ,
iters   
)

Definition at line 194 of file MathBenchmark.cpp.

194  {
195  runDivTests<int64_t>(&folly::divFloor<int64_t, int64_t>, iters);
196 }
BENCHMARK ( divCeilInt64  ,
iters   
)

Definition at line 197 of file MathBenchmark.cpp.

197  {
198  runDivTests<int64_t>(&folly::divCeil<int64_t, int64_t>, iters);
199 }
BENCHMARK ( divRoundAwayInt64  ,
iters   
)

Definition at line 218 of file MathBenchmark.cpp.

References BENCHMARK_DRAW_LINE().

218  {
219  runDivTests<int64_t>(&folly::divRoundAway<int64_t, int64_t>, iters);
220 }
BENCHMARK ( divTruncUint8  ,
iters   
)

Definition at line 223 of file MathBenchmark.cpp.

223  {
224  runDivTests<uint8_t>(&folly::divTrunc<uint8_t, uint8_t>, iters);
225 }
BENCHMARK ( divFloorUint8  ,
iters   
)

Definition at line 226 of file MathBenchmark.cpp.

226  {
227  runDivTests<uint8_t>(&folly::divFloor<uint8_t, uint8_t>, iters);
228 }
BENCHMARK ( divCeilUint8  ,
iters   
)

Definition at line 229 of file MathBenchmark.cpp.

229  {
230  runDivTests<uint8_t>(&folly::divCeil<uint8_t, uint8_t>, iters);
231 }
BENCHMARK ( divRoundAwayUint8  ,
iters   
)

Definition at line 250 of file MathBenchmark.cpp.

References BENCHMARK_DRAW_LINE().

250  {
251  runDivTests<uint8_t>(&folly::divRoundAway<uint8_t, uint8_t>, iters);
252 }
BENCHMARK ( divTruncUint16  ,
iters   
)

Definition at line 255 of file MathBenchmark.cpp.

255  {
256  runDivTests<uint16_t>(&folly::divTrunc<uint16_t, uint16_t>, iters);
257 }
BENCHMARK ( divFloorUint16  ,
iters   
)

Definition at line 258 of file MathBenchmark.cpp.

258  {
259  runDivTests<uint16_t>(&folly::divFloor<uint16_t, uint16_t>, iters);
260 }
BENCHMARK ( divCeilUint16  ,
iters   
)

Definition at line 261 of file MathBenchmark.cpp.

261  {
262  runDivTests<uint16_t>(&folly::divCeil<uint16_t, uint16_t>, iters);
263 }
BENCHMARK ( divRoundAwayUint16  ,
iters   
)

Definition at line 282 of file MathBenchmark.cpp.

References BENCHMARK_DRAW_LINE().

282  {
283  runDivTests<uint16_t>(&folly::divRoundAway<uint16_t, uint16_t>, iters);
284 }
BENCHMARK ( divTruncUint32  ,
iters   
)

Definition at line 287 of file MathBenchmark.cpp.

287  {
288  runDivTests<uint32_t>(&folly::divTrunc<uint32_t, uint32_t>, iters);
289 }
BENCHMARK ( divFloorUint32  ,
iters   
)

Definition at line 290 of file MathBenchmark.cpp.

290  {
291  runDivTests<uint32_t>(&folly::divFloor<uint32_t, uint32_t>, iters);
292 }
BENCHMARK ( divCeilUint32  ,
iters   
)

Definition at line 293 of file MathBenchmark.cpp.

293  {
294  runDivTests<uint32_t>(&folly::divCeil<uint32_t, uint32_t>, iters);
295 }
BENCHMARK ( divRoundAwayUint32  ,
iters   
)

Definition at line 314 of file MathBenchmark.cpp.

References BENCHMARK_DRAW_LINE().

314  {
315  runDivTests<uint32_t>(&folly::divRoundAway<uint32_t, uint32_t>, iters);
316 }
BENCHMARK ( divTruncUint64  ,
iters   
)

Definition at line 319 of file MathBenchmark.cpp.

319  {
320  runDivTests<uint64_t>(&folly::divTrunc<uint64_t, uint64_t>, iters);
321 }
BENCHMARK ( divFloorUint64  ,
iters   
)

Definition at line 322 of file MathBenchmark.cpp.

322  {
323  runDivTests<uint64_t>(&folly::divFloor<uint64_t, uint64_t>, iters);
324 }
BENCHMARK ( divCeilUint64  ,
iters   
)

Definition at line 325 of file MathBenchmark.cpp.

325  {
326  runDivTests<uint64_t>(&folly::divCeil<uint64_t, uint64_t>, iters);
327 }
BENCHMARK ( divRoundAwayUint64  ,
iters   
)

Definition at line 346 of file MathBenchmark.cpp.

346  {
347  runDivTests<uint64_t>(&folly::divRoundAway<uint64_t, uint64_t>, iters);
348 }
BENCHMARK_DRAW_LINE ( )

Referenced by BENCHMARK().

BENCHMARK_RELATIVE ( branchlessDivCeilInt8  ,
iters   
)

Definition at line 104 of file MathBenchmark.cpp.

104  {
105  runDivTests<int8_t>(&folly::detail::divCeilBranchless<int8_t>, iters);
106 }
BENCHMARK_RELATIVE ( branchfulDivCeilInt8  ,
iters   
)

Definition at line 107 of file MathBenchmark.cpp.

107  {
108  runDivTests<int8_t>(&folly::detail::divCeilBranchful<int8_t>, iters);
109 }
BENCHMARK_RELATIVE ( brokenButWidespreadDivCeilInt8  ,
iters   
)

Definition at line 110 of file MathBenchmark.cpp.

110  {
111  runDivTests<int8_t>(&brokenButWidespreadDivCeil<int8_t>, iters);
112 }
BENCHMARK_RELATIVE ( viaFloatDivCeilInt8  ,
iters   
)

Definition at line 113 of file MathBenchmark.cpp.

113  {
114  runDivTests<int8_t>(&viaFloatDivCeil<int8_t>, iters);
115 }
BENCHMARK_RELATIVE ( viaDoubleDivCeilInt8  ,
iters   
)

Definition at line 116 of file MathBenchmark.cpp.

116  {
117  runDivTests<int8_t>(&viaDoubleDivCeil<int8_t>, iters);
118 }
BENCHMARK_RELATIVE ( viaLongDoubleDivCeilInt8  ,
iters   
)

Definition at line 119 of file MathBenchmark.cpp.

119  {
120  runDivTests<int8_t>(&viaLongDoubleDivCeil<int8_t>, iters);
121 }
BENCHMARK_RELATIVE ( branchlessDivCeilInt16  ,
iters   
)

Definition at line 136 of file MathBenchmark.cpp.

136  {
137  runDivTests<int16_t>(&folly::detail::divCeilBranchless<int16_t>, iters);
138 }
BENCHMARK_RELATIVE ( branchfulDivCeilInt16  ,
iters   
)

Definition at line 139 of file MathBenchmark.cpp.

139  {
140  runDivTests<int16_t>(&folly::detail::divCeilBranchful<int16_t>, iters);
141 }
BENCHMARK_RELATIVE ( brokenButWidespreadDivCeilInt16  ,
iters   
)

Definition at line 142 of file MathBenchmark.cpp.

142  {
143  runDivTests<int16_t>(&brokenButWidespreadDivCeil<int16_t>, iters);
144 }
BENCHMARK_RELATIVE ( viaFloatDivCeilInt16  ,
iters   
)

Definition at line 145 of file MathBenchmark.cpp.

145  {
146  runDivTests<int16_t>(&viaFloatDivCeil<int16_t>, iters);
147 }
BENCHMARK_RELATIVE ( viaDoubleDivCeilInt16  ,
iters   
)

Definition at line 148 of file MathBenchmark.cpp.

148  {
149  runDivTests<int16_t>(&viaDoubleDivCeil<int16_t>, iters);
150 }
BENCHMARK_RELATIVE ( viaLongDoubleDivCeilInt16  ,
iters   
)

Definition at line 151 of file MathBenchmark.cpp.

151  {
152  runDivTests<int16_t>(&viaLongDoubleDivCeil<int16_t>, iters);
153 }
BENCHMARK_RELATIVE ( branchlessDivCeilInt32  ,
iters   
)

Definition at line 168 of file MathBenchmark.cpp.

168  {
169  runDivTests<int32_t>(&folly::detail::divCeilBranchless<int32_t>, iters);
170 }
BENCHMARK_RELATIVE ( branchfulDivCeilInt32  ,
iters   
)

Definition at line 171 of file MathBenchmark.cpp.

171  {
172  runDivTests<int32_t>(&folly::detail::divCeilBranchful<int32_t>, iters);
173 }
BENCHMARK_RELATIVE ( brokenButWidespreadDivCeilInt32  ,
iters   
)

Definition at line 174 of file MathBenchmark.cpp.

174  {
175  runDivTests<int32_t>(&brokenButWidespreadDivCeil<int32_t>, iters);
176 }
BENCHMARK_RELATIVE ( approxViaFloatDivCeilInt32  ,
iters   
)

Definition at line 177 of file MathBenchmark.cpp.

177  {
178  runDivTests<int32_t>(&viaFloatDivCeil<int32_t>, iters);
179 }
BENCHMARK_RELATIVE ( viaDoubleDivCeilInt32  ,
iters   
)

Definition at line 180 of file MathBenchmark.cpp.

180  {
181  runDivTests<int32_t>(&viaDoubleDivCeil<int32_t>, iters);
182 }
BENCHMARK_RELATIVE ( viaLongDoubleDivCeilInt32  ,
iters   
)

Definition at line 183 of file MathBenchmark.cpp.

183  {
184  runDivTests<int32_t>(&viaLongDoubleDivCeil<int32_t>, iters);
185 }
BENCHMARK_RELATIVE ( branchlessDivCeilInt64  ,
iters   
)

Definition at line 200 of file MathBenchmark.cpp.

200  {
201  runDivTests<int64_t>(&folly::detail::divCeilBranchless<int64_t>, iters);
202 }
BENCHMARK_RELATIVE ( branchfulDivCeilInt64  ,
iters   
)

Definition at line 203 of file MathBenchmark.cpp.

203  {
204  runDivTests<int64_t>(&folly::detail::divCeilBranchful<int64_t>, iters);
205 }
BENCHMARK_RELATIVE ( brokenButWidespreadDivCeilInt64  ,
iters   
)

Definition at line 206 of file MathBenchmark.cpp.

206  {
207  runDivTests<int64_t>(&brokenButWidespreadDivCeil<int64_t>, iters);
208 }
BENCHMARK_RELATIVE ( approxViaFloatDivCeilInt64  ,
iters   
)

Definition at line 209 of file MathBenchmark.cpp.

209  {
210  runDivTests<int64_t>(&viaFloatDivCeil<int64_t>, iters);
211 }
BENCHMARK_RELATIVE ( approxViaDoubleDivCeilInt64  ,
iters   
)

Definition at line 212 of file MathBenchmark.cpp.

212  {
213  runDivTests<int64_t>(&viaDoubleDivCeil<int64_t>, iters);
214 }
BENCHMARK_RELATIVE ( viaLongDoubleDivCeilInt64  ,
iters   
)

Definition at line 215 of file MathBenchmark.cpp.

215  {
216  runDivTests<int64_t>(&viaLongDoubleDivCeil<int64_t>, iters);
217 }
BENCHMARK_RELATIVE ( branchlessDivCeilUint8  ,
iters   
)

Definition at line 232 of file MathBenchmark.cpp.

232  {
233  runDivTests<uint8_t>(&folly::detail::divCeilBranchless<uint8_t>, iters);
234 }
BENCHMARK_RELATIVE ( branchfulDivCeilUint8  ,
iters   
)

Definition at line 235 of file MathBenchmark.cpp.

235  {
236  runDivTests<uint8_t>(&folly::detail::divCeilBranchful<uint8_t>, iters);
237 }
BENCHMARK_RELATIVE ( brokenButWidespreadDivCeilUint8  ,
iters   
)

Definition at line 238 of file MathBenchmark.cpp.

238  {
239  runDivTests<uint8_t>(&brokenButWidespreadDivCeil<uint8_t>, iters);
240 }
BENCHMARK_RELATIVE ( viaFloatDivCeilUint8  ,
iters   
)

Definition at line 241 of file MathBenchmark.cpp.

241  {
242  runDivTests<uint8_t>(&viaFloatDivCeil<uint8_t>, iters);
243 }
BENCHMARK_RELATIVE ( viaDoubleDivCeilUint8  ,
iters   
)

Definition at line 244 of file MathBenchmark.cpp.

244  {
245  runDivTests<uint8_t>(&viaDoubleDivCeil<uint8_t>, iters);
246 }
BENCHMARK_RELATIVE ( viaLongDoubleDivCeilUint8  ,
iters   
)

Definition at line 247 of file MathBenchmark.cpp.

247  {
248  runDivTests<uint8_t>(&viaLongDoubleDivCeil<uint8_t>, iters);
249 }
BENCHMARK_RELATIVE ( branchlessDivCeilUint16  ,
iters   
)

Definition at line 264 of file MathBenchmark.cpp.

264  {
265  runDivTests<uint16_t>(&folly::detail::divCeilBranchless<uint16_t>, iters);
266 }
BENCHMARK_RELATIVE ( branchfulDivCeilUint16  ,
iters   
)

Definition at line 267 of file MathBenchmark.cpp.

267  {
268  runDivTests<uint16_t>(&folly::detail::divCeilBranchful<uint16_t>, iters);
269 }
BENCHMARK_RELATIVE ( brokenButWidespreadDivCeilUint16  ,
iters   
)

Definition at line 270 of file MathBenchmark.cpp.

270  {
271  runDivTests<uint16_t>(&brokenButWidespreadDivCeil<uint16_t>, iters);
272 }
BENCHMARK_RELATIVE ( viaFloatDivCeilUint16  ,
iters   
)

Definition at line 273 of file MathBenchmark.cpp.

273  {
274  runDivTests<uint16_t>(&viaFloatDivCeil<uint16_t>, iters);
275 }
BENCHMARK_RELATIVE ( viaDoubleDivCeilUint16  ,
iters   
)

Definition at line 276 of file MathBenchmark.cpp.

276  {
277  runDivTests<uint16_t>(&viaDoubleDivCeil<uint16_t>, iters);
278 }
BENCHMARK_RELATIVE ( viaLongDoubleDivCeilUint16  ,
iters   
)

Definition at line 279 of file MathBenchmark.cpp.

279  {
280  runDivTests<uint16_t>(&viaLongDoubleDivCeil<uint16_t>, iters);
281 }
BENCHMARK_RELATIVE ( branchlessDivCeilUint32  ,
iters   
)

Definition at line 296 of file MathBenchmark.cpp.

296  {
297  runDivTests<uint32_t>(&folly::detail::divCeilBranchless<uint32_t>, iters);
298 }
BENCHMARK_RELATIVE ( branchfulDivCeilUint32  ,
iters   
)

Definition at line 299 of file MathBenchmark.cpp.

299  {
300  runDivTests<uint32_t>(&folly::detail::divCeilBranchful<uint32_t>, iters);
301 }
BENCHMARK_RELATIVE ( brokenButWidespreadDivCeilUint32  ,
iters   
)

Definition at line 302 of file MathBenchmark.cpp.

302  {
303  runDivTests<uint32_t>(&brokenButWidespreadDivCeil<uint32_t>, iters);
304 }
BENCHMARK_RELATIVE ( approxViaFloatDivCeilUint32  ,
iters   
)

Definition at line 305 of file MathBenchmark.cpp.

305  {
306  runDivTests<uint32_t>(&viaFloatDivCeil<uint32_t>, iters);
307 }
BENCHMARK_RELATIVE ( viaDoubleDivCeilUint32  ,
iters   
)

Definition at line 308 of file MathBenchmark.cpp.

308  {
309  runDivTests<uint32_t>(&viaDoubleDivCeil<uint32_t>, iters);
310 }
BENCHMARK_RELATIVE ( viaLongDoubleDivCeilUint32  ,
iters   
)

Definition at line 311 of file MathBenchmark.cpp.

311  {
312  runDivTests<uint32_t>(&viaLongDoubleDivCeil<uint32_t>, iters);
313 }
BENCHMARK_RELATIVE ( branchlessDivCeilUint64  ,
iters   
)

Definition at line 328 of file MathBenchmark.cpp.

328  {
329  runDivTests<uint64_t>(&folly::detail::divCeilBranchless<uint64_t>, iters);
330 }
BENCHMARK_RELATIVE ( branchfulDivCeilUint64  ,
iters   
)

Definition at line 331 of file MathBenchmark.cpp.

331  {
332  runDivTests<uint64_t>(&folly::detail::divCeilBranchful<uint64_t>, iters);
333 }
BENCHMARK_RELATIVE ( brokenButWidespreadDivCeilUint64  ,
iters   
)

Definition at line 334 of file MathBenchmark.cpp.

334  {
335  runDivTests<uint64_t>(&brokenButWidespreadDivCeil<uint64_t>, iters);
336 }
BENCHMARK_RELATIVE ( approxViaFloatDivCeilUint64  ,
iters   
)

Definition at line 337 of file MathBenchmark.cpp.

337  {
338  runDivTests<uint64_t>(&viaFloatDivCeil<uint64_t>, iters);
339 }
BENCHMARK_RELATIVE ( approxViaDoubleDivCeilUint64  ,
iters   
)

Definition at line 340 of file MathBenchmark.cpp.

340  {
341  runDivTests<uint64_t>(&viaDoubleDivCeil<uint64_t>, iters);
342 }
BENCHMARK_RELATIVE ( viaLongDoubleDivCeilUint64  ,
iters   
)

Definition at line 343 of file MathBenchmark.cpp.

343  {
344  runDivTests<uint64_t>(&viaLongDoubleDivCeil<uint64_t>, iters);
345 }
int main ( int  argc,
char **  argv 
)

Definition at line 350 of file MathBenchmark.cpp.

References folly::runBenchmarks().

350  {
351  gflags::ParseCommandLineFlags(&argc, &argv, true);
352  folly::runBenchmarks();
353  return 0;
354 }
folly::runBenchmarks
void runBenchmarks()
Definition: Benchmark.cpp:456
argv
char ** argv
Definition: SmallLocksBenchmark.cpp:430