v811_spc009/bionic/benchmarks/math_benchmark.cpp

/*
 * 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");