blob: a69a4f6dd75c67074d6ceea6d672322f0a70d9a0 [file] [log] [blame]
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <memory>
#include "base/basictypes.h"
#include "base/memory/aligned_memory.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "cobalt/media/base/vector_math.h"
#include "cobalt/media/base/vector_math_testing.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/perf/perf_test.h"
using base::TimeTicks;
using std::fill;
namespace cobalt {
namespace media {
static const int kBenchmarkIterations = 200000;
static const int kEWMABenchmarkIterations = 50000;
static const float kScale = 0.5;
static const int kVectorSize = 8192;
class VectorMathPerfTest : public testing::Test {
public:
VectorMathPerfTest() {
// Initialize input and output vectors.
input_vector_.reset(static_cast<float*>(base::AlignedAlloc(
sizeof(float) * kVectorSize, vector_math::kRequiredAlignment)));
output_vector_.reset(static_cast<float*>(base::AlignedAlloc(
sizeof(float) * kVectorSize, vector_math::kRequiredAlignment)));
fill(input_vector_.get(), input_vector_.get() + kVectorSize, 1.0f);
fill(output_vector_.get(), output_vector_.get() + kVectorSize, 0.0f);
}
void RunBenchmark(void (*fn)(const float[], float, int, float[]),
bool aligned, const std::string& test_name,
const std::string& trace_name) {
TimeTicks start = TimeTicks::Now();
for (int i = 0; i < kBenchmarkIterations; ++i) {
fn(input_vector_.get(), kScale, kVectorSize - (aligned ? 0 : 1),
output_vector_.get());
}
double total_time_milliseconds =
(TimeTicks::Now() - start).InMillisecondsF();
perf_test::PrintResult(test_name, "", trace_name,
kBenchmarkIterations / total_time_milliseconds,
"runs/ms", true);
}
void RunBenchmark(std::pair<float, float> (*fn)(float, const float[], int,
float),
int len, const std::string& test_name,
const std::string& trace_name) {
TimeTicks start = TimeTicks::Now();
for (int i = 0; i < kEWMABenchmarkIterations; ++i) {
fn(0.5f, input_vector_.get(), len, 0.1f);
}
double total_time_milliseconds =
(TimeTicks::Now() - start).InMillisecondsF();
perf_test::PrintResult(test_name, "", trace_name,
kEWMABenchmarkIterations / total_time_milliseconds,
"runs/ms", true);
}
protected:
std::unique_ptr<float, base::AlignedFreeDeleter> input_vector_;
std::unique_ptr<float, base::AlignedFreeDeleter> output_vector_;
private:
DISALLOW_COPY_AND_ASSIGN(VectorMathPerfTest);
};
// Define platform dependent function names for SIMD optimized methods.
#if defined(ARCH_CPU_X86_FAMILY)
#define FMAC_FUNC FMAC_SSE
#define FMUL_FUNC FMUL_SSE
#define EWMAAndMaxPower_FUNC EWMAAndMaxPower_SSE
#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
#define FMAC_FUNC FMAC_NEON
#define FMUL_FUNC FMUL_NEON
#define EWMAAndMaxPower_FUNC EWMAAndMaxPower_NEON
#endif
// Benchmark for each optimized vector_math::FMAC() method.
TEST_F(VectorMathPerfTest, FMAC) {
// Benchmark FMAC_C().
RunBenchmark(vector_math::FMAC_C, true, "vector_math_fmac", "unoptimized");
#if defined(FMAC_FUNC)
// Benchmark FMAC_FUNC() with unaligned size.
ASSERT_NE(
(kVectorSize - 1) % (vector_math::kRequiredAlignment / sizeof(float)),
0U);
RunBenchmark(vector_math::FMAC_FUNC, false, "vector_math_fmac",
"optimized_unaligned");
// Benchmark FMAC_FUNC() with aligned size.
ASSERT_EQ(kVectorSize % (vector_math::kRequiredAlignment / sizeof(float)),
0U);
RunBenchmark(vector_math::FMAC_FUNC, true, "vector_math_fmac",
"optimized_aligned");
#endif
}
// Benchmark for each optimized vector_math::FMUL() method.
TEST_F(VectorMathPerfTest, FMUL) {
// Benchmark FMUL_C().
RunBenchmark(vector_math::FMUL_C, true, "vector_math_fmul", "unoptimized");
#if defined(FMUL_FUNC)
// Benchmark FMUL_FUNC() with unaligned size.
ASSERT_NE(
(kVectorSize - 1) % (vector_math::kRequiredAlignment / sizeof(float)),
0U);
RunBenchmark(vector_math::FMUL_FUNC, false, "vector_math_fmul",
"optimized_unaligned");
// Benchmark FMUL_FUNC() with aligned size.
ASSERT_EQ(kVectorSize % (vector_math::kRequiredAlignment / sizeof(float)),
0U);
RunBenchmark(vector_math::FMUL_FUNC, true, "vector_math_fmul",
"optimized_aligned");
#endif
}
// Benchmark for each optimized vector_math::EWMAAndMaxPower() method.
TEST_F(VectorMathPerfTest, EWMAAndMaxPower) {
// Benchmark EWMAAndMaxPower_C().
RunBenchmark(vector_math::EWMAAndMaxPower_C, kVectorSize,
"vector_math_ewma_and_max_power", "unoptimized");
#if defined(EWMAAndMaxPower_FUNC)
// Benchmark EWMAAndMaxPower_FUNC() with unaligned size.
ASSERT_NE(
(kVectorSize - 1) % (vector_math::kRequiredAlignment / sizeof(float)),
0U);
RunBenchmark(vector_math::EWMAAndMaxPower_FUNC, kVectorSize - 1,
"vector_math_ewma_and_max_power", "optimized_unaligned");
// Benchmark EWMAAndMaxPower_FUNC() with aligned size.
ASSERT_EQ(kVectorSize % (vector_math::kRequiredAlignment / sizeof(float)),
0U);
RunBenchmark(vector_math::EWMAAndMaxPower_FUNC, kVectorSize,
"vector_math_ewma_and_max_power", "optimized_aligned");
#endif
}
} // namespace media
} // namespace cobalt