72fe1c8df6
As for exp/exp2 benchmark, this patch add two benchmark for pow: one which measures thoughput and one which measures latency. The input data is the same as powf. Test: ran 32-bit and 64-bit x86 tests on host Change-Id: I04335fac9e76fb3f39935323dacf6b7be6a6f917
566 lines
14 KiB
C++
566 lines
14 KiB
C++
/*
|
|
* Copyright (C) 2013 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <fenv.h>
|
|
#include <math.h>
|
|
|
|
#include <benchmark/benchmark.h>
|
|
#include "util.h"
|
|
|
|
static const double values[] = { 1234.0, nan(""), HUGE_VAL, 0.0 };
|
|
static const char* names[] = { "1234.0", "nan", "HUGE_VAL", "0.0" };
|
|
|
|
static void SetLabel(benchmark::State& state) {
|
|
state.SetLabel(names[state.range(0)]);
|
|
}
|
|
|
|
// Avoid optimization.
|
|
volatile double d;
|
|
volatile double v;
|
|
volatile float f;
|
|
|
|
static float zero = 0.0f;
|
|
static double zerod = 0.0f;
|
|
|
|
static void BM_math_sqrt(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = 2.0;
|
|
while (state.KeepRunning()) {
|
|
d += sqrt(v);
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_sqrt);
|
|
|
|
static void BM_math_log10(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = 1234.0;
|
|
while (state.KeepRunning()) {
|
|
d += log10(v);
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_log10);
|
|
|
|
static void BM_math_logb(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = 1234.0;
|
|
while (state.KeepRunning()) {
|
|
d += logb(v);
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_logb);
|
|
|
|
static void BM_math_isfinite_macro(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += isfinite(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_isfinite_macro, "MATH_COMMON");
|
|
|
|
static void BM_math_isfinite(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += isfinite(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_isfinite, "MATH_COMMON");
|
|
|
|
static void BM_math_isinf_macro(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += isinf(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_isinf_macro, "MATH_COMMON");
|
|
|
|
static void BM_math_isinf(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += (isinf)(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_isinf, "MATH_COMMON");
|
|
|
|
static void BM_math_isnan_macro(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += isnan(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_isnan_macro, "MATH_COMMON");
|
|
|
|
static void BM_math_isnan(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += (isnan)(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_isnan, "MATH_COMMON");
|
|
|
|
static void BM_math_isnormal_macro(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += isnormal(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_isnormal_macro, "MATH_COMMON");
|
|
|
|
static void BM_math_isnormal(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += isnormal(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_isnormal, "MATH_COMMON");
|
|
|
|
static void BM_math_sin_fast(benchmark::State& state) {
|
|
d = 1.0;
|
|
while (state.KeepRunning()) {
|
|
d += sin(d);
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_sin_fast);
|
|
|
|
static void BM_math_sin_feupdateenv(benchmark::State& state) {
|
|
d = 1.0;
|
|
while (state.KeepRunning()) {
|
|
fenv_t __libc_save_rm;
|
|
feholdexcept(&__libc_save_rm);
|
|
fesetround(FE_TONEAREST);
|
|
d += sin(d);
|
|
feupdateenv(&__libc_save_rm);
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_sin_feupdateenv);
|
|
|
|
static void BM_math_sin_fesetenv(benchmark::State& state) {
|
|
d = 1.0;
|
|
while (state.KeepRunning()) {
|
|
fenv_t __libc_save_rm;
|
|
feholdexcept(&__libc_save_rm);
|
|
fesetround(FE_TONEAREST);
|
|
d += sin(d);
|
|
fesetenv(&__libc_save_rm);
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_sin_fesetenv);
|
|
|
|
static void BM_math_fpclassify(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += fpclassify(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_fpclassify, "MATH_COMMON");
|
|
|
|
static void BM_math_signbit_macro(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += signbit(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_signbit_macro, "MATH_COMMON");
|
|
|
|
static void BM_math_signbit(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += signbit(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_signbit, "MATH_COMMON");
|
|
|
|
static void BM_math_fabs_macro(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += fabs(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_fabs_macro, "MATH_COMMON");
|
|
|
|
static void BM_math_fabs(benchmark::State& state) {
|
|
d = 0.0;
|
|
v = values[state.range(0)];
|
|
while (state.KeepRunning()) {
|
|
d += (fabs)(v);
|
|
}
|
|
SetLabel(state);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_fabs, "MATH_COMMON");
|
|
|
|
static void BM_math_sincos(benchmark::State& state) {
|
|
d = 1.0;
|
|
while (state.KeepRunning()) {
|
|
double s, c;
|
|
sincos(d, &s, &c);
|
|
d += s + c;
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_sincos);
|
|
|
|
#include "expf_input.cpp"
|
|
|
|
static void BM_math_expf_speccpu2017(benchmark::State& state) {
|
|
f = 0.0;
|
|
auto cin = expf_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = expf(*cin);
|
|
if (++cin == expf_input.cend())
|
|
cin = expf_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_expf_speccpu2017);
|
|
|
|
static void BM_math_expf_speccpu2017_latency(benchmark::State& state) {
|
|
f = 0.0;
|
|
auto cin = expf_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = expf(f * zero + *cin);
|
|
if (++cin == expf_input.cend())
|
|
cin = expf_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_expf_speccpu2017_latency);
|
|
|
|
// Create a double version of expf_input to avoid overhead of float to
|
|
// double conversion.
|
|
static const std::vector<double> exp_input (expf_input.begin(),
|
|
expf_input.end());
|
|
|
|
static void BM_math_exp_speccpu2017(benchmark::State& state) {
|
|
d = 0.0;
|
|
auto cin = exp_input.cbegin();
|
|
for (auto _ : state) {
|
|
d = exp(*cin);
|
|
if (++cin == exp_input.cend())
|
|
cin = exp_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_exp_speccpu2017);
|
|
|
|
static void BM_math_exp_speccpu2017_latency(benchmark::State& state) {
|
|
d = 0.0;
|
|
auto cin = exp_input.cbegin();
|
|
for (auto _ : state) {
|
|
d = exp(d * zerod + *cin);
|
|
if (++cin == exp_input.cend())
|
|
cin = exp_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_exp_speccpu2017_latency);
|
|
|
|
static void BM_math_exp2f_speccpu2017(benchmark::State& state) {
|
|
f = 0.0;
|
|
auto cin = expf_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = exp2f(*cin);
|
|
if (++cin == expf_input.cend())
|
|
cin = expf_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_exp2f_speccpu2017);
|
|
|
|
static void BM_math_exp2f_speccpu2017_latency(benchmark::State& state) {
|
|
f = 0.0;
|
|
auto cin = expf_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = exp2f(f * zero + *cin);
|
|
if (++cin == expf_input.cend())
|
|
cin = expf_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_exp2f_speccpu2017_latency);
|
|
|
|
static void BM_math_exp2_speccpu2017(benchmark::State& state) {
|
|
d = 0.0;
|
|
auto cin = exp_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = exp2(*cin);
|
|
if (++cin == exp_input.cend())
|
|
cin = exp_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_exp2_speccpu2017);
|
|
|
|
static void BM_math_exp2_speccpu2017_latency(benchmark::State& state) {
|
|
d = 0.0;
|
|
auto cin = exp_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = exp2(d * zero + *cin);
|
|
if (++cin == exp_input.cend())
|
|
cin = exp_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_exp2_speccpu2017_latency);
|
|
|
|
#include "powf_input.cpp"
|
|
|
|
static const std::vector<std::pair<double, double>> pow_input
|
|
(powf_input.begin(), powf_input.end());
|
|
|
|
static void BM_math_powf_speccpu2006(benchmark::State& state) {
|
|
f = 0.0;
|
|
auto cin = powf_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = powf(cin->first, cin->second);
|
|
if (++cin == powf_input.cend())
|
|
cin = powf_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_powf_speccpu2006);
|
|
|
|
static void BM_math_powf_speccpu2017_latency(benchmark::State& state) {
|
|
f = 0.0;
|
|
auto cin = powf_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = powf(f * zero + cin->first, cin->second);
|
|
if (++cin == powf_input.cend())
|
|
cin = powf_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_powf_speccpu2017_latency);
|
|
|
|
static void BM_math_pow_speccpu2006(benchmark::State& state) {
|
|
d = 0.0;
|
|
auto cin = pow_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = pow(cin->first, cin->second);
|
|
if (++cin == pow_input.cend())
|
|
cin = pow_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_pow_speccpu2006);
|
|
|
|
static void BM_math_pow_speccpu2017_latency(benchmark::State& state) {
|
|
d = 0.0;
|
|
auto cin = pow_input.cbegin();
|
|
for (auto _ : state) {
|
|
d = powf(d * zero + cin->first, cin->second);
|
|
if (++cin == pow_input.cend())
|
|
cin = pow_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_pow_speccpu2017_latency);
|
|
|
|
#include "logf_input.cpp"
|
|
|
|
static const std::vector<double> log_input (logf_input.begin(),
|
|
logf_input.end());
|
|
|
|
static void BM_math_logf_speccpu2017(benchmark::State& state) {
|
|
f = 0.0;
|
|
auto cin = logf_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = logf(*cin);
|
|
if (++cin == logf_input.cend())
|
|
cin = logf_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_logf_speccpu2017);
|
|
|
|
static void BM_math_logf_speccpu2017_latency(benchmark::State& state) {
|
|
f = 0.0;
|
|
auto cin = logf_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = logf(f * zero + *cin);
|
|
if (++cin == logf_input.cend())
|
|
cin = logf_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_logf_speccpu2017_latency);
|
|
|
|
static void BM_math_log_speccpu2017(benchmark::State& state) {
|
|
d = 0.0;
|
|
auto cin = log_input.cbegin();
|
|
for (auto _ : state) {
|
|
d = log(*cin);
|
|
if (++cin == log_input.cend())
|
|
cin = log_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_log_speccpu2017);
|
|
|
|
static void BM_math_log_speccpu2017_latency(benchmark::State& state) {
|
|
d = 0.0;
|
|
auto cin = log_input.cbegin();
|
|
for (auto _ : state) {
|
|
d = log(d * zerod + *cin);
|
|
if (++cin == log_input.cend())
|
|
cin = log_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_log_speccpu2017_latency);
|
|
|
|
static void BM_math_log2f_speccpu2017(benchmark::State& state) {
|
|
f = 0.0;
|
|
auto cin = logf_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = log2f(*cin);
|
|
if (++cin == logf_input.cend())
|
|
cin = logf_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_log2f_speccpu2017);
|
|
|
|
static void BM_math_log2_speccpu2017_latency(benchmark::State& state) {
|
|
d = 0.0;
|
|
auto cin = log_input.cbegin();
|
|
for (auto _ : state) {
|
|
d = log2(d * zerod + *cin);
|
|
if (++cin == log_input.cend())
|
|
cin = log_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_log2_speccpu2017_latency);
|
|
|
|
static void BM_math_log2_speccpu2017(benchmark::State& state) {
|
|
d = 0.0;
|
|
auto cin = log_input.cbegin();
|
|
for (auto _ : state) {
|
|
d = log2(*cin);
|
|
if (++cin == log_input.cend())
|
|
cin = log_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_log2_speccpu2017);
|
|
|
|
static void BM_math_log2f_speccpu2017_latency(benchmark::State& state) {
|
|
f = 0.0;
|
|
auto cin = logf_input.cbegin();
|
|
for (auto _ : state) {
|
|
f = log2f(f * zero + *cin);
|
|
if (++cin == logf_input.cend())
|
|
cin = logf_input.cbegin();
|
|
}
|
|
}
|
|
BIONIC_BENCHMARK(BM_math_log2f_speccpu2017_latency);
|
|
|
|
// Four ranges of values are checked:
|
|
// * 0.0 <= x < 0.1
|
|
// * 0.1 <= x < 0.7
|
|
// * 0.7 <= x < 3.1
|
|
// * -3.1 <= x < 3.1
|
|
// * 3.3 <= x < 33.3
|
|
// * 100.0 <= x < 1000.0
|
|
// * 1e6 <= x < 1e32
|
|
// * 1e32 < x < FLT_MAX
|
|
|
|
#include "sincosf_input.cpp"
|
|
|
|
static void BM_math_sinf(benchmark::State& state) {
|
|
auto range = sincosf_input[state.range(0)];
|
|
auto cin = range.values.cbegin();
|
|
f = 0.0;
|
|
for (auto _ : state) {
|
|
f = sinf(*cin);
|
|
if (++cin == range.values.cend())
|
|
cin = range.values.cbegin();
|
|
}
|
|
state.SetLabel(range.label);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_sinf, "MATH_SINCOS_COMMON");
|
|
|
|
static void BM_math_sinf_latency(benchmark::State& state) {
|
|
auto range = sincosf_input[state.range(0)];
|
|
auto cin = range.values.cbegin();
|
|
f = 0.0;
|
|
for (auto _ : state) {
|
|
f = sinf(f * zero + *cin);
|
|
if (++cin == range.values.cend())
|
|
cin = range.values.cbegin();
|
|
}
|
|
state.SetLabel(range.label);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_sinf_latency, "MATH_SINCOS_COMMON");
|
|
|
|
static void BM_math_cosf(benchmark::State& state) {
|
|
auto range = sincosf_input[state.range(0)];
|
|
auto cin = range.values.cbegin();
|
|
f = 0.0;
|
|
for (auto _ : state) {
|
|
f = cosf(*cin);
|
|
if (++cin == range.values.cend())
|
|
cin = range.values.cbegin();
|
|
}
|
|
state.SetLabel(range.label);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_cosf, "MATH_SINCOS_COMMON");
|
|
|
|
static void BM_math_cosf_latency(benchmark::State& state) {
|
|
auto range = sincosf_input[state.range(0)];
|
|
auto cin = range.values.cbegin();
|
|
f = 0.0;
|
|
for (auto _ : state) {
|
|
f = cosf(f * zero + *cin);
|
|
if (++cin == range.values.cend())
|
|
cin = range.values.cbegin();
|
|
}
|
|
state.SetLabel(range.label);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_cosf_latency, "MATH_SINCOS_COMMON");
|
|
|
|
static void BM_math_sincosf(benchmark::State& state) {
|
|
auto range = sincosf_input[state.range(0)];
|
|
auto cin = range.values.cbegin();
|
|
f = 0.0;
|
|
for (auto _ : state) {
|
|
float s, c;
|
|
sincosf(*cin, &s, &c);
|
|
f += s;
|
|
if (++cin == range.values.cend())
|
|
cin = range.values.cbegin();
|
|
}
|
|
state.SetLabel(range.label);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_sincosf, "MATH_SINCOS_COMMON");
|
|
|
|
static void BM_math_sincosf_latency(benchmark::State& state) {
|
|
auto range = sincosf_input[state.range(0)];
|
|
auto cin = range.values.cbegin();
|
|
f = 0.0;
|
|
for (auto _ : state) {
|
|
float s, c;
|
|
sincosf(f * zero + *cin, &s, &c);
|
|
f += s;
|
|
if (++cin == range.values.cend())
|
|
cin = range.values.cbegin();
|
|
}
|
|
state.SetLabel(range.label);
|
|
}
|
|
BIONIC_BENCHMARK_WITH_ARG(BM_math_sincosf_latency, "MATH_SINCOS_COMMON");
|