Port SincResampler's ConvolveBenchmark, as well as VectorMath's benchmarks to media_perftests.

media/base/sinc_resampler_perftest.cc

+// 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 "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/cpu.h"
+#include "base/time/time.h"
+#include "media/base/sinc_resampler.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/perf/perf_test.h"
+
+namespace media {
+
+static const int kBenchmarkIterations = 50000000;
+
+static const double kSampleRateRatio = 192000.0 / 44100.0;
+static const double kKernelInterpolationFactor = 0.5;
+
+// Helper class to ensure ChunkedResample() functions properly.
+class MockSource {
+ public:
+  MOCK_METHOD2(ProvideInput, void(int frames, float* destination));

[scherkus (not reviewing), 2013/10/29 00:13:45]

it doesn't look like this class is doing anything or has any gmock expectations
set

can you try replacing it with:

static void DoNothing(int frames, float* destination) {}

... and base::Bind(&DoNothing) below?

[rileya (GONE FROM CHROMIUM), 2013/10/29 01:23:30]

Seems to work, done.

+};
+
+// Define platform independent function name for Convolve* tests.
+#if defined(ARCH_CPU_X86_FAMILY)
+#define CONVOLVE_FUNC Convolve_SSE
+#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
+#define CONVOLVE_FUNC Convolve_NEON
+#endif
+
+void RunConvolveBenchmark(

[scherkus (not reviewing), 2013/10/29 00:13:45]

static

+    SincResampler& resampler,

[scherkus (not reviewing), 2013/10/29 00:13:45]

the only time we pass as reference is when its const-ref, otherwise use pointers

+    float (*convolve_fn)(const float*, const float*, const float*, double),

[rileya (GONE FROM CHROMIUM), 2013/10/28 23:38:57]

Here and in the vector math tests I pass a function pointer into a testing
function to save duplicating some code. However, given that these are
performance tests, there is some chance that the overhead of potentially
dereferencing the function pointer on each iteration could make things slightly
slower artificially. I imagine most compilers will be clever enough with
optimizations to avoid issues here (some informal testing on Linux didn't show
any appreciable difference in performance), but still...

Making the test function take the function pointer as a template parameter, and
thus generating a copy of the test function for each function pointer, might
make it more likely for the compiler to optimize the dereference out, but that's
a) uglier than just using the fn ptr as a regular param and b) still not a
complete guarantee the compiler will be smart...

[scherkus (not reviewing), 2013/10/29 00:13:45]

I'd wager the overhead is dwarfed by the convolving code itself. For fun you can
try sticking in some slow code inside the convolving code and seeing if we can
measure any difference

(my assembly is rusty, but I'm curious what the resulting code looks like. I'd
guess w/ function pointers it ends up doing a call instruction w/ the address
stored in a register or on the stack) 

[rileya (GONE FROM CHROMIUM), 2013/10/29 01:23:30]

Yeah that was what I thought, I'll try to take a look at what the generated code
does.

+    bool aligned,
+    const std::string& trace_name) {
+  base::TimeTicks start = base::TimeTicks::HighResNow();
+  for (int i = 0; i < kBenchmarkIterations; ++i) {
+    convolve_fn(resampler.get_kernel_for_testing() + (aligned ? 0 : 1),
+                resampler.get_kernel_for_testing(),
+                resampler.get_kernel_for_testing(),
+                kKernelInterpolationFactor);
+  }
+  double total_time_seconds =
+      (base::TimeTicks::HighResNow() - start).InSecondsF();
+  perf_test::PrintResult("sinc_resampler_convolve",
+                         "",
+                         trace_name,
+                         kBenchmarkIterations / total_time_seconds,
+                         "runs/s",
+                         true);
+}
+
+// Benchmark for the various Convolve() methods.  Make sure to build with
+// branding=Chrome so that DCHECKs are compiled out when benchmarking.
+TEST(SincResamplerPerfTest, Convolve) {
+  // Initialize a dummy resampler.
+  MockSource mock_source;
+  SincResampler resampler(
+      kSampleRateRatio, SincResampler::kDefaultRequestSize,
+      base::Bind(&MockSource::ProvideInput, base::Unretained(&mock_source)));
+
+  RunConvolveBenchmark(
+      resampler, SincResampler::Convolve_C, true, "unoptimized_aligned");
+
+#if defined(CONVOLVE_FUNC)
+#if defined(ARCH_CPU_X86_FAMILY)
+  ASSERT_TRUE(base::CPU().has_sse());
+#endif
+  RunConvolveBenchmark(
+      resampler, SincResampler::CONVOLVE_FUNC, true, "optimized_aligned");
+  RunConvolveBenchmark(
+      resampler, SincResampler::CONVOLVE_FUNC, false, "optimized_unaligned");
+#endif
+}
+
+#undef CONVOLVE_FUNC
+
+} // namespace media