930 lines
29 KiB
C++
930 lines
29 KiB
C++
/*
|
|
* Copyright (c) 2016, Alliance for Open Media. All rights reserved.
|
|
*
|
|
* This source code is subject to the terms of the BSD 2 Clause License and
|
|
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
|
|
* was not distributed with this source code in the LICENSE file, you can
|
|
* obtain it at www.aomedia.org/license/software. If the Alliance for Open
|
|
* Media Patent License 1.0 was not distributed with this source code in the
|
|
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
|
|
*/
|
|
|
|
#include <cmath>
|
|
#include <cstdlib>
|
|
#include <string>
|
|
#include <tuple>
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
#include "config/aom_config.h"
|
|
#include "config/aom_dsp_rtcd.h"
|
|
|
|
#include "aom_ports/mem.h"
|
|
#include "av1/common/common_data.h"
|
|
#include "test/acm_random.h"
|
|
#include "test/register_state_check.h"
|
|
#include "test/util.h"
|
|
#include "test/function_equivalence_test.h"
|
|
|
|
using libaom_test::ACMRandom;
|
|
using libaom_test::FunctionEquivalenceTest;
|
|
using ::testing::Combine;
|
|
using ::testing::Range;
|
|
using ::testing::Values;
|
|
using ::testing::ValuesIn;
|
|
|
|
namespace {
|
|
const int kNumIterations = 10000;
|
|
|
|
static const int16_t kInt13Max = (1 << 12) - 1;
|
|
|
|
typedef uint64_t (*SSI16Func)(const int16_t *src, int stride, int width,
|
|
int height);
|
|
typedef libaom_test::FuncParam<SSI16Func> TestFuncs;
|
|
|
|
class SumSquaresTest : public ::testing::TestWithParam<TestFuncs> {
|
|
public:
|
|
~SumSquaresTest() override = default;
|
|
void SetUp() override {
|
|
params_ = this->GetParam();
|
|
rnd_.Reset(ACMRandom::DeterministicSeed());
|
|
src_ = reinterpret_cast<int16_t *>(aom_memalign(16, 256 * 256 * 2));
|
|
ASSERT_NE(src_, nullptr);
|
|
}
|
|
|
|
void TearDown() override { aom_free(src_); }
|
|
void RunTest(bool is_random);
|
|
void RunSpeedTest();
|
|
|
|
void GenRandomData(int width, int height, int stride) {
|
|
const int msb = 11; // Up to 12 bit input
|
|
const int limit = 1 << (msb + 1);
|
|
for (int ii = 0; ii < height; ii++) {
|
|
for (int jj = 0; jj < width; jj++) {
|
|
src_[ii * stride + jj] = rnd_(2) ? rnd_(limit) : -rnd_(limit);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GenExtremeData(int width, int height, int stride) {
|
|
const int msb = 11; // Up to 12 bit input
|
|
const int limit = 1 << (msb + 1);
|
|
const int val = rnd_(2) ? limit - 1 : -(limit - 1);
|
|
for (int ii = 0; ii < height; ii++) {
|
|
for (int jj = 0; jj < width; jj++) {
|
|
src_[ii * stride + jj] = val;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected:
|
|
TestFuncs params_;
|
|
int16_t *src_;
|
|
ACMRandom rnd_;
|
|
};
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SumSquaresTest);
|
|
|
|
void SumSquaresTest::RunTest(bool is_random) {
|
|
int failed = 0;
|
|
for (int k = 0; k < kNumIterations; k++) {
|
|
const int width = 4 * (rnd_(31) + 1); // Up to 128x128
|
|
const int height = 4 * (rnd_(31) + 1); // Up to 128x128
|
|
int stride = 4 << rnd_(7); // Up to 256 stride
|
|
while (stride < width) { // Make sure it's valid
|
|
stride = 4 << rnd_(7);
|
|
}
|
|
if (is_random) {
|
|
GenRandomData(width, height, stride);
|
|
} else {
|
|
GenExtremeData(width, height, stride);
|
|
}
|
|
const uint64_t res_ref = params_.ref_func(src_, stride, width, height);
|
|
uint64_t res_tst;
|
|
API_REGISTER_STATE_CHECK(res_tst =
|
|
params_.tst_func(src_, stride, width, height));
|
|
|
|
if (!failed) {
|
|
failed = res_ref != res_tst;
|
|
EXPECT_EQ(res_ref, res_tst)
|
|
<< "Error: Sum Squares Test [" << width << "x" << height
|
|
<< "] C output does not match optimized output.";
|
|
}
|
|
}
|
|
}
|
|
|
|
void SumSquaresTest::RunSpeedTest() {
|
|
for (int block = BLOCK_4X4; block < BLOCK_SIZES_ALL; block++) {
|
|
const int width = block_size_wide[block]; // Up to 128x128
|
|
const int height = block_size_high[block]; // Up to 128x128
|
|
int stride = 4 << rnd_(7); // Up to 256 stride
|
|
while (stride < width) { // Make sure it's valid
|
|
stride = 4 << rnd_(7);
|
|
}
|
|
GenExtremeData(width, height, stride);
|
|
const int num_loops = 1000000000 / (width + height);
|
|
aom_usec_timer timer;
|
|
aom_usec_timer_start(&timer);
|
|
|
|
for (int i = 0; i < num_loops; ++i)
|
|
params_.ref_func(src_, stride, width, height);
|
|
|
|
aom_usec_timer_mark(&timer);
|
|
const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
|
|
printf("SumSquaresTest C %3dx%-3d: %7.2f ns\n", width, height,
|
|
1000.0 * elapsed_time / num_loops);
|
|
|
|
aom_usec_timer timer1;
|
|
aom_usec_timer_start(&timer1);
|
|
for (int i = 0; i < num_loops; ++i)
|
|
params_.tst_func(src_, stride, width, height);
|
|
aom_usec_timer_mark(&timer1);
|
|
const int elapsed_time1 = static_cast<int>(aom_usec_timer_elapsed(&timer1));
|
|
printf("SumSquaresTest Test %3dx%-3d: %7.2f ns\n", width, height,
|
|
1000.0 * elapsed_time1 / num_loops);
|
|
}
|
|
}
|
|
|
|
TEST_P(SumSquaresTest, OperationCheck) {
|
|
RunTest(true); // GenRandomData
|
|
}
|
|
|
|
TEST_P(SumSquaresTest, ExtremeValues) {
|
|
RunTest(false); // GenExtremeData
|
|
}
|
|
|
|
TEST_P(SumSquaresTest, DISABLED_Speed) { RunSpeedTest(); }
|
|
|
|
#if HAVE_SSE2
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
SSE2, SumSquaresTest,
|
|
::testing::Values(TestFuncs(&aom_sum_squares_2d_i16_c,
|
|
&aom_sum_squares_2d_i16_sse2)));
|
|
|
|
#endif // HAVE_SSE2
|
|
|
|
#if HAVE_NEON
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
NEON, SumSquaresTest,
|
|
::testing::Values(TestFuncs(&aom_sum_squares_2d_i16_c,
|
|
&aom_sum_squares_2d_i16_neon)));
|
|
|
|
#endif // HAVE_NEON
|
|
|
|
#if HAVE_SVE
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
SVE, SumSquaresTest,
|
|
::testing::Values(TestFuncs(&aom_sum_squares_2d_i16_c,
|
|
&aom_sum_squares_2d_i16_sve)));
|
|
|
|
#endif // HAVE_SVE
|
|
|
|
#if HAVE_AVX2
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
AVX2, SumSquaresTest,
|
|
::testing::Values(TestFuncs(&aom_sum_squares_2d_i16_c,
|
|
&aom_sum_squares_2d_i16_avx2)));
|
|
#endif // HAVE_AVX2
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// 1D version
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef uint64_t (*F1D)(const int16_t *src, uint32_t n);
|
|
typedef libaom_test::FuncParam<F1D> TestFuncs1D;
|
|
|
|
class SumSquares1DTest : public FunctionEquivalenceTest<F1D> {
|
|
protected:
|
|
static const int kIterations = 1000;
|
|
static const int kMaxSize = 256;
|
|
};
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SumSquares1DTest);
|
|
|
|
TEST_P(SumSquares1DTest, RandomValues) {
|
|
DECLARE_ALIGNED(16, int16_t, src[kMaxSize * kMaxSize]);
|
|
|
|
for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
|
|
for (int i = 0; i < kMaxSize * kMaxSize; ++i)
|
|
src[i] = rng_(kInt13Max * 2 + 1) - kInt13Max;
|
|
|
|
// Block size is between 64 and 128 * 128 and is always a multiple of 64.
|
|
const int n = (rng_(255) + 1) * 64;
|
|
|
|
const uint64_t ref_res = params_.ref_func(src, n);
|
|
uint64_t tst_res;
|
|
API_REGISTER_STATE_CHECK(tst_res = params_.tst_func(src, n));
|
|
|
|
ASSERT_EQ(ref_res, tst_res);
|
|
}
|
|
}
|
|
|
|
TEST_P(SumSquares1DTest, ExtremeValues) {
|
|
DECLARE_ALIGNED(16, int16_t, src[kMaxSize * kMaxSize]);
|
|
|
|
for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
|
|
if (rng_(2)) {
|
|
for (int i = 0; i < kMaxSize * kMaxSize; ++i) src[i] = kInt13Max;
|
|
} else {
|
|
for (int i = 0; i < kMaxSize * kMaxSize; ++i) src[i] = -kInt13Max;
|
|
}
|
|
|
|
// Block size is between 64 and 128 * 128 and is always a multiple of 64.
|
|
const int n = (rng_(255) + 1) * 64;
|
|
|
|
const uint64_t ref_res = params_.ref_func(src, n);
|
|
uint64_t tst_res;
|
|
API_REGISTER_STATE_CHECK(tst_res = params_.tst_func(src, n));
|
|
|
|
ASSERT_EQ(ref_res, tst_res);
|
|
}
|
|
}
|
|
|
|
#if HAVE_SSE2
|
|
INSTANTIATE_TEST_SUITE_P(SSE2, SumSquares1DTest,
|
|
::testing::Values(TestFuncs1D(
|
|
aom_sum_squares_i16_c, aom_sum_squares_i16_sse2)));
|
|
|
|
#endif // HAVE_SSE2
|
|
|
|
#if HAVE_NEON
|
|
INSTANTIATE_TEST_SUITE_P(NEON, SumSquares1DTest,
|
|
::testing::Values(TestFuncs1D(
|
|
aom_sum_squares_i16_c, aom_sum_squares_i16_neon)));
|
|
|
|
#endif // HAVE_NEON
|
|
|
|
#if HAVE_SVE
|
|
INSTANTIATE_TEST_SUITE_P(SVE, SumSquares1DTest,
|
|
::testing::Values(TestFuncs1D(
|
|
aom_sum_squares_i16_c, aom_sum_squares_i16_sve)));
|
|
|
|
#endif // HAVE_SVE
|
|
|
|
typedef int64_t (*SSEFunc)(const uint8_t *a, int a_stride, const uint8_t *b,
|
|
int b_stride, int width, int height);
|
|
typedef libaom_test::FuncParam<SSEFunc> TestSSEFuncs;
|
|
|
|
typedef std::tuple<TestSSEFuncs, int> SSETestParam;
|
|
|
|
class SSETest : public ::testing::TestWithParam<SSETestParam> {
|
|
public:
|
|
~SSETest() override = default;
|
|
void SetUp() override {
|
|
params_ = GET_PARAM(0);
|
|
width_ = GET_PARAM(1);
|
|
is_hbd_ =
|
|
#if CONFIG_AV1_HIGHBITDEPTH
|
|
params_.ref_func == aom_highbd_sse_c;
|
|
#else
|
|
false;
|
|
#endif
|
|
rnd_.Reset(ACMRandom::DeterministicSeed());
|
|
src_ = reinterpret_cast<uint8_t *>(aom_memalign(32, 256 * 256 * 2));
|
|
ref_ = reinterpret_cast<uint8_t *>(aom_memalign(32, 256 * 256 * 2));
|
|
ASSERT_NE(src_, nullptr);
|
|
ASSERT_NE(ref_, nullptr);
|
|
}
|
|
|
|
void TearDown() override {
|
|
aom_free(src_);
|
|
aom_free(ref_);
|
|
}
|
|
void RunTest(bool is_random, int width, int height, int run_times);
|
|
|
|
void GenRandomData(int width, int height, int stride) {
|
|
uint16_t *src16 = reinterpret_cast<uint16_t *>(src_);
|
|
uint16_t *ref16 = reinterpret_cast<uint16_t *>(ref_);
|
|
const int msb = 11; // Up to 12 bit input
|
|
const int limit = 1 << (msb + 1);
|
|
for (int ii = 0; ii < height; ii++) {
|
|
for (int jj = 0; jj < width; jj++) {
|
|
if (!is_hbd_) {
|
|
src_[ii * stride + jj] = rnd_.Rand8();
|
|
ref_[ii * stride + jj] = rnd_.Rand8();
|
|
} else {
|
|
src16[ii * stride + jj] = rnd_(limit);
|
|
ref16[ii * stride + jj] = rnd_(limit);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void GenExtremeData(int width, int height, int stride, uint8_t *data,
|
|
int16_t val) {
|
|
uint16_t *data16 = reinterpret_cast<uint16_t *>(data);
|
|
for (int ii = 0; ii < height; ii++) {
|
|
for (int jj = 0; jj < width; jj++) {
|
|
if (!is_hbd_) {
|
|
data[ii * stride + jj] = static_cast<uint8_t>(val);
|
|
} else {
|
|
data16[ii * stride + jj] = val;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected:
|
|
bool is_hbd_;
|
|
int width_;
|
|
TestSSEFuncs params_;
|
|
uint8_t *src_;
|
|
uint8_t *ref_;
|
|
ACMRandom rnd_;
|
|
};
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SSETest);
|
|
|
|
void SSETest::RunTest(bool is_random, int width, int height, int run_times) {
|
|
int failed = 0;
|
|
aom_usec_timer ref_timer, test_timer;
|
|
for (int k = 0; k < 3; k++) {
|
|
int stride = 4 << rnd_(7); // Up to 256 stride
|
|
while (stride < width) { // Make sure it's valid
|
|
stride = 4 << rnd_(7);
|
|
}
|
|
if (is_random) {
|
|
GenRandomData(width, height, stride);
|
|
} else {
|
|
const int msb = is_hbd_ ? 12 : 8; // Up to 12 bit input
|
|
const int limit = (1 << msb) - 1;
|
|
if (k == 0) {
|
|
GenExtremeData(width, height, stride, src_, 0);
|
|
GenExtremeData(width, height, stride, ref_, limit);
|
|
} else {
|
|
GenExtremeData(width, height, stride, src_, limit);
|
|
GenExtremeData(width, height, stride, ref_, 0);
|
|
}
|
|
}
|
|
int64_t res_ref, res_tst;
|
|
uint8_t *src = src_;
|
|
uint8_t *ref = ref_;
|
|
if (is_hbd_) {
|
|
src = CONVERT_TO_BYTEPTR(src_);
|
|
ref = CONVERT_TO_BYTEPTR(ref_);
|
|
}
|
|
res_ref = params_.ref_func(src, stride, ref, stride, width, height);
|
|
res_tst = params_.tst_func(src, stride, ref, stride, width, height);
|
|
if (run_times > 1) {
|
|
aom_usec_timer_start(&ref_timer);
|
|
for (int j = 0; j < run_times; j++) {
|
|
params_.ref_func(src, stride, ref, stride, width, height);
|
|
}
|
|
aom_usec_timer_mark(&ref_timer);
|
|
const int elapsed_time_c =
|
|
static_cast<int>(aom_usec_timer_elapsed(&ref_timer));
|
|
|
|
aom_usec_timer_start(&test_timer);
|
|
for (int j = 0; j < run_times; j++) {
|
|
params_.tst_func(src, stride, ref, stride, width, height);
|
|
}
|
|
aom_usec_timer_mark(&test_timer);
|
|
const int elapsed_time_simd =
|
|
static_cast<int>(aom_usec_timer_elapsed(&test_timer));
|
|
|
|
printf(
|
|
"c_time=%d \t simd_time=%d \t "
|
|
"gain=%d\n",
|
|
elapsed_time_c, elapsed_time_simd,
|
|
(elapsed_time_c / elapsed_time_simd));
|
|
} else {
|
|
if (!failed) {
|
|
failed = res_ref != res_tst;
|
|
EXPECT_EQ(res_ref, res_tst)
|
|
<< "Error:" << (is_hbd_ ? "hbd " : " ") << k << " SSE Test ["
|
|
<< width << "x" << height
|
|
<< "] C output does not match optimized output.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_P(SSETest, OperationCheck) {
|
|
for (int height = 4; height <= 128; height += 4) {
|
|
RunTest(true, width_, height, 1); // GenRandomData
|
|
}
|
|
}
|
|
|
|
TEST_P(SSETest, ExtremeValues) {
|
|
for (int height = 4; height <= 128; height += 4) {
|
|
RunTest(false, width_, height, 1);
|
|
}
|
|
}
|
|
|
|
TEST_P(SSETest, DISABLED_Speed) {
|
|
for (int height = 4; height <= 128; height += 4) {
|
|
RunTest(true, width_, height, 100);
|
|
}
|
|
}
|
|
|
|
#if HAVE_NEON
|
|
TestSSEFuncs sse_neon[] = {
|
|
TestSSEFuncs(&aom_sse_c, &aom_sse_neon),
|
|
#if CONFIG_AV1_HIGHBITDEPTH
|
|
TestSSEFuncs(&aom_highbd_sse_c, &aom_highbd_sse_neon)
|
|
#endif
|
|
};
|
|
INSTANTIATE_TEST_SUITE_P(NEON, SSETest,
|
|
Combine(ValuesIn(sse_neon), Range(4, 129, 4)));
|
|
#endif // HAVE_NEON
|
|
|
|
#if HAVE_NEON_DOTPROD
|
|
TestSSEFuncs sse_neon_dotprod[] = {
|
|
TestSSEFuncs(&aom_sse_c, &aom_sse_neon_dotprod),
|
|
};
|
|
INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SSETest,
|
|
Combine(ValuesIn(sse_neon_dotprod), Range(4, 129, 4)));
|
|
#endif // HAVE_NEON_DOTPROD
|
|
|
|
#if HAVE_SSE4_1
|
|
TestSSEFuncs sse_sse4[] = {
|
|
TestSSEFuncs(&aom_sse_c, &aom_sse_sse4_1),
|
|
#if CONFIG_AV1_HIGHBITDEPTH
|
|
TestSSEFuncs(&aom_highbd_sse_c, &aom_highbd_sse_sse4_1)
|
|
#endif
|
|
};
|
|
INSTANTIATE_TEST_SUITE_P(SSE4_1, SSETest,
|
|
Combine(ValuesIn(sse_sse4), Range(4, 129, 4)));
|
|
#endif // HAVE_SSE4_1
|
|
|
|
#if HAVE_AVX2
|
|
|
|
TestSSEFuncs sse_avx2[] = {
|
|
TestSSEFuncs(&aom_sse_c, &aom_sse_avx2),
|
|
#if CONFIG_AV1_HIGHBITDEPTH
|
|
TestSSEFuncs(&aom_highbd_sse_c, &aom_highbd_sse_avx2)
|
|
#endif
|
|
};
|
|
INSTANTIATE_TEST_SUITE_P(AVX2, SSETest,
|
|
Combine(ValuesIn(sse_avx2), Range(4, 129, 4)));
|
|
#endif // HAVE_AVX2
|
|
|
|
#if HAVE_SVE
|
|
#if CONFIG_AV1_HIGHBITDEPTH
|
|
TestSSEFuncs sse_sve[] = { TestSSEFuncs(&aom_highbd_sse_c,
|
|
&aom_highbd_sse_sve) };
|
|
INSTANTIATE_TEST_SUITE_P(SVE, SSETest,
|
|
Combine(ValuesIn(sse_sve), Range(4, 129, 4)));
|
|
#endif
|
|
#endif // HAVE_SVE
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// get_blk sum squares test functions
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef void (*sse_sum_func)(const int16_t *data, int stride, int bw, int bh,
|
|
int *x_sum, int64_t *x2_sum);
|
|
typedef libaom_test::FuncParam<sse_sum_func> TestSSE_SumFuncs;
|
|
|
|
typedef std::tuple<TestSSE_SumFuncs, TX_SIZE> SSE_SumTestParam;
|
|
|
|
class SSE_Sum_Test : public ::testing::TestWithParam<SSE_SumTestParam> {
|
|
public:
|
|
~SSE_Sum_Test() override = default;
|
|
void SetUp() override {
|
|
params_ = GET_PARAM(0);
|
|
rnd_.Reset(ACMRandom::DeterministicSeed());
|
|
src_ = reinterpret_cast<int16_t *>(aom_memalign(32, 256 * 256 * 2));
|
|
ASSERT_NE(src_, nullptr);
|
|
}
|
|
|
|
void TearDown() override { aom_free(src_); }
|
|
void RunTest(bool is_random, int tx_size, int run_times);
|
|
|
|
void GenRandomData(int width, int height, int stride) {
|
|
const int msb = 11; // Up to 12 bit input
|
|
const int limit = 1 << (msb + 1);
|
|
for (int ii = 0; ii < height; ii++) {
|
|
for (int jj = 0; jj < width; jj++) {
|
|
src_[ii * stride + jj] = rnd_(limit);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GenExtremeData(int width, int height, int stride, int16_t *data,
|
|
int16_t val) {
|
|
for (int ii = 0; ii < height; ii++) {
|
|
for (int jj = 0; jj < width; jj++) {
|
|
data[ii * stride + jj] = val;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected:
|
|
TestSSE_SumFuncs params_;
|
|
int16_t *src_;
|
|
ACMRandom rnd_;
|
|
};
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SSE_Sum_Test);
|
|
|
|
void SSE_Sum_Test::RunTest(bool is_random, int tx_size, int run_times) {
|
|
aom_usec_timer ref_timer, test_timer;
|
|
int width = tx_size_wide[tx_size];
|
|
int height = tx_size_high[tx_size];
|
|
for (int k = 0; k < 3; k++) {
|
|
int stride = 4 << rnd_(7); // Up to 256 stride
|
|
while (stride < width) { // Make sure it's valid
|
|
stride = 4 << rnd_(7);
|
|
}
|
|
if (is_random) {
|
|
GenRandomData(width, height, stride);
|
|
} else {
|
|
const int msb = 12; // Up to 12 bit input
|
|
const int limit = (1 << msb) - 1;
|
|
if (k == 0) {
|
|
GenExtremeData(width, height, stride, src_, limit);
|
|
} else {
|
|
GenExtremeData(width, height, stride, src_, -limit);
|
|
}
|
|
}
|
|
int sum_c = 0;
|
|
int64_t sse_intr = 0;
|
|
int sum_intr = 0;
|
|
int64_t sse_c = 0;
|
|
|
|
params_.ref_func(src_, stride, width, height, &sum_c, &sse_c);
|
|
params_.tst_func(src_, stride, width, height, &sum_intr, &sse_intr);
|
|
|
|
if (run_times > 1) {
|
|
aom_usec_timer_start(&ref_timer);
|
|
for (int j = 0; j < run_times; j++) {
|
|
params_.ref_func(src_, stride, width, height, &sum_c, &sse_c);
|
|
}
|
|
aom_usec_timer_mark(&ref_timer);
|
|
const int elapsed_time_c =
|
|
static_cast<int>(aom_usec_timer_elapsed(&ref_timer));
|
|
|
|
aom_usec_timer_start(&test_timer);
|
|
for (int j = 0; j < run_times; j++) {
|
|
params_.tst_func(src_, stride, width, height, &sum_intr, &sse_intr);
|
|
}
|
|
aom_usec_timer_mark(&test_timer);
|
|
const int elapsed_time_simd =
|
|
static_cast<int>(aom_usec_timer_elapsed(&test_timer));
|
|
|
|
printf(
|
|
"c_time=%d \t simd_time=%d \t "
|
|
"gain=%f\t width=%d\t height=%d \n",
|
|
elapsed_time_c, elapsed_time_simd,
|
|
(float)((float)elapsed_time_c / (float)elapsed_time_simd), width,
|
|
height);
|
|
|
|
} else {
|
|
EXPECT_EQ(sum_c, sum_intr)
|
|
<< "Error:" << k << " SSE Sum Test [" << width << "x" << height
|
|
<< "] C output does not match optimized output.";
|
|
EXPECT_EQ(sse_c, sse_intr)
|
|
<< "Error:" << k << " SSE Sum Test [" << width << "x" << height
|
|
<< "] C output does not match optimized output.";
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_P(SSE_Sum_Test, OperationCheck) {
|
|
RunTest(true, GET_PARAM(1), 1); // GenRandomData
|
|
}
|
|
|
|
TEST_P(SSE_Sum_Test, ExtremeValues) { RunTest(false, GET_PARAM(1), 1); }
|
|
|
|
TEST_P(SSE_Sum_Test, DISABLED_Speed) { RunTest(true, GET_PARAM(1), 10000); }
|
|
|
|
#if HAVE_SSE2 || HAVE_AVX2 || HAVE_NEON
|
|
const TX_SIZE kValidBlockSize[] = { TX_4X4, TX_8X8, TX_16X16, TX_32X32,
|
|
TX_64X64, TX_4X8, TX_8X4, TX_8X16,
|
|
TX_16X8, TX_16X32, TX_32X16, TX_64X32,
|
|
TX_32X64, TX_4X16, TX_16X4, TX_8X32,
|
|
TX_32X8, TX_16X64, TX_64X16 };
|
|
#endif
|
|
|
|
#if HAVE_SSE2
|
|
TestSSE_SumFuncs sse_sum_sse2[] = { TestSSE_SumFuncs(
|
|
&aom_get_blk_sse_sum_c, &aom_get_blk_sse_sum_sse2) };
|
|
INSTANTIATE_TEST_SUITE_P(SSE2, SSE_Sum_Test,
|
|
Combine(ValuesIn(sse_sum_sse2),
|
|
ValuesIn(kValidBlockSize)));
|
|
#endif // HAVE_SSE2
|
|
|
|
#if HAVE_AVX2
|
|
TestSSE_SumFuncs sse_sum_avx2[] = { TestSSE_SumFuncs(
|
|
&aom_get_blk_sse_sum_c, &aom_get_blk_sse_sum_avx2) };
|
|
INSTANTIATE_TEST_SUITE_P(AVX2, SSE_Sum_Test,
|
|
Combine(ValuesIn(sse_sum_avx2),
|
|
ValuesIn(kValidBlockSize)));
|
|
#endif // HAVE_AVX2
|
|
|
|
#if HAVE_NEON
|
|
TestSSE_SumFuncs sse_sum_neon[] = { TestSSE_SumFuncs(
|
|
&aom_get_blk_sse_sum_c, &aom_get_blk_sse_sum_neon) };
|
|
INSTANTIATE_TEST_SUITE_P(NEON, SSE_Sum_Test,
|
|
Combine(ValuesIn(sse_sum_neon),
|
|
ValuesIn(kValidBlockSize)));
|
|
#endif // HAVE_NEON
|
|
|
|
#if HAVE_SVE
|
|
TestSSE_SumFuncs sse_sum_sve[] = { TestSSE_SumFuncs(&aom_get_blk_sse_sum_c,
|
|
&aom_get_blk_sse_sum_sve) };
|
|
INSTANTIATE_TEST_SUITE_P(SVE, SSE_Sum_Test,
|
|
Combine(ValuesIn(sse_sum_sve),
|
|
ValuesIn(kValidBlockSize)));
|
|
#endif // HAVE_SVE
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// 2D Variance test functions
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef uint64_t (*Var2DFunc)(uint8_t *src, int stride, int width, int height);
|
|
typedef libaom_test::FuncParam<Var2DFunc> TestFuncVar2D;
|
|
|
|
const uint16_t test_block_size[2] = { 128, 256 };
|
|
|
|
class Lowbd2dVarTest : public ::testing::TestWithParam<TestFuncVar2D> {
|
|
public:
|
|
~Lowbd2dVarTest() override = default;
|
|
void SetUp() override {
|
|
params_ = this->GetParam();
|
|
rnd_.Reset(ACMRandom::DeterministicSeed());
|
|
src_ = reinterpret_cast<uint8_t *>(
|
|
aom_memalign(16, 512 * 512 * sizeof(uint8_t)));
|
|
ASSERT_NE(src_, nullptr);
|
|
}
|
|
|
|
void TearDown() override { aom_free(src_); }
|
|
void RunTest(bool is_random);
|
|
void RunSpeedTest();
|
|
|
|
void GenRandomData(int width, int height, int stride) {
|
|
const int msb = 7; // Up to 8 bit input
|
|
const int limit = 1 << (msb + 1);
|
|
for (int ii = 0; ii < height; ii++) {
|
|
for (int jj = 0; jj < width; jj++) {
|
|
src_[ii * stride + jj] = rnd_(limit);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GenExtremeData(int width, int height, int stride) {
|
|
const int msb = 7; // Up to 8 bit input
|
|
const int limit = 1 << (msb + 1);
|
|
const int val = rnd_(2) ? limit - 1 : 0;
|
|
for (int ii = 0; ii < height; ii++) {
|
|
for (int jj = 0; jj < width; jj++) {
|
|
src_[ii * stride + jj] = val;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected:
|
|
TestFuncVar2D params_;
|
|
uint8_t *src_;
|
|
ACMRandom rnd_;
|
|
};
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(Lowbd2dVarTest);
|
|
|
|
void Lowbd2dVarTest::RunTest(bool is_random) {
|
|
int failed = 0;
|
|
for (int k = 0; k < kNumIterations; k++) {
|
|
const int width = 4 * (rnd_(63) + 1); // Up to 256x256
|
|
const int height = 4 * (rnd_(63) + 1); // Up to 256x256
|
|
int stride = 4 << rnd_(8); // Up to 512 stride
|
|
while (stride < width) { // Make sure it's valid
|
|
stride = 4 << rnd_(8);
|
|
}
|
|
if (is_random) {
|
|
GenRandomData(width, height, stride);
|
|
} else {
|
|
GenExtremeData(width, height, stride);
|
|
}
|
|
|
|
const uint64_t res_ref = params_.ref_func(src_, stride, width, height);
|
|
uint64_t res_tst;
|
|
API_REGISTER_STATE_CHECK(res_tst =
|
|
params_.tst_func(src_, stride, width, height));
|
|
|
|
if (!failed) {
|
|
failed = res_ref != res_tst;
|
|
EXPECT_EQ(res_ref, res_tst)
|
|
<< "Error: Sum Squares Test [" << width << "x" << height
|
|
<< "] C output does not match optimized output.";
|
|
}
|
|
}
|
|
}
|
|
|
|
void Lowbd2dVarTest::RunSpeedTest() {
|
|
for (int block = 0; block < 2; block++) {
|
|
const int width = test_block_size[block];
|
|
const int height = test_block_size[block];
|
|
int stride = 4 << rnd_(8); // Up to 512 stride
|
|
while (stride < width) { // Make sure it's valid
|
|
stride = 4 << rnd_(8);
|
|
}
|
|
GenExtremeData(width, height, stride);
|
|
const int num_loops = 1000000000 / (width + height);
|
|
aom_usec_timer timer;
|
|
aom_usec_timer_start(&timer);
|
|
|
|
for (int i = 0; i < num_loops; ++i)
|
|
params_.ref_func(src_, stride, width, height);
|
|
|
|
aom_usec_timer_mark(&timer);
|
|
const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
|
|
|
|
aom_usec_timer timer1;
|
|
aom_usec_timer_start(&timer1);
|
|
for (int i = 0; i < num_loops; ++i)
|
|
params_.tst_func(src_, stride, width, height);
|
|
aom_usec_timer_mark(&timer1);
|
|
const int elapsed_time1 = static_cast<int>(aom_usec_timer_elapsed(&timer1));
|
|
printf("%3dx%-3d: Scaling = %.2f\n", width, height,
|
|
(double)elapsed_time / elapsed_time1);
|
|
}
|
|
}
|
|
|
|
TEST_P(Lowbd2dVarTest, OperationCheck) {
|
|
RunTest(true); // GenRandomData
|
|
}
|
|
|
|
TEST_P(Lowbd2dVarTest, ExtremeValues) {
|
|
RunTest(false); // GenExtremeData
|
|
}
|
|
|
|
TEST_P(Lowbd2dVarTest, DISABLED_Speed) { RunSpeedTest(); }
|
|
|
|
#if HAVE_SSE2
|
|
|
|
INSTANTIATE_TEST_SUITE_P(SSE2, Lowbd2dVarTest,
|
|
::testing::Values(TestFuncVar2D(&aom_var_2d_u8_c,
|
|
&aom_var_2d_u8_sse2)));
|
|
|
|
#endif // HAVE_SSE2
|
|
|
|
#if HAVE_AVX2
|
|
|
|
INSTANTIATE_TEST_SUITE_P(AVX2, Lowbd2dVarTest,
|
|
::testing::Values(TestFuncVar2D(&aom_var_2d_u8_c,
|
|
&aom_var_2d_u8_avx2)));
|
|
|
|
#endif // HAVE_SSE2
|
|
|
|
#if HAVE_NEON
|
|
|
|
INSTANTIATE_TEST_SUITE_P(NEON, Lowbd2dVarTest,
|
|
::testing::Values(TestFuncVar2D(&aom_var_2d_u8_c,
|
|
&aom_var_2d_u8_neon)));
|
|
|
|
#endif // HAVE_NEON
|
|
|
|
#if HAVE_NEON_DOTPROD
|
|
|
|
INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, Lowbd2dVarTest,
|
|
::testing::Values(TestFuncVar2D(
|
|
&aom_var_2d_u8_c, &aom_var_2d_u8_neon_dotprod)));
|
|
|
|
#endif // HAVE_NEON_DOTPROD
|
|
|
|
#if CONFIG_AV1_HIGHBITDEPTH
|
|
class Highbd2dVarTest : public ::testing::TestWithParam<TestFuncVar2D> {
|
|
public:
|
|
~Highbd2dVarTest() override = default;
|
|
void SetUp() override {
|
|
params_ = this->GetParam();
|
|
rnd_.Reset(ACMRandom::DeterministicSeed());
|
|
src_ = reinterpret_cast<uint16_t *>(
|
|
aom_memalign(16, 512 * 512 * sizeof(uint16_t)));
|
|
ASSERT_NE(src_, nullptr);
|
|
}
|
|
|
|
void TearDown() override { aom_free(src_); }
|
|
void RunTest(bool is_random);
|
|
void RunSpeedTest();
|
|
|
|
void GenRandomData(int width, int height, int stride) {
|
|
const int msb = 11; // Up to 12 bit input
|
|
const int limit = 1 << (msb + 1);
|
|
for (int ii = 0; ii < height; ii++) {
|
|
for (int jj = 0; jj < width; jj++) {
|
|
src_[ii * stride + jj] = rnd_(limit);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GenExtremeData(int width, int height, int stride) {
|
|
const int msb = 11; // Up to 12 bit input
|
|
const int limit = 1 << (msb + 1);
|
|
const int val = rnd_(2) ? limit - 1 : 0;
|
|
for (int ii = 0; ii < height; ii++) {
|
|
for (int jj = 0; jj < width; jj++) {
|
|
src_[ii * stride + jj] = val;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected:
|
|
TestFuncVar2D params_;
|
|
uint16_t *src_;
|
|
ACMRandom rnd_;
|
|
};
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(Highbd2dVarTest);
|
|
|
|
void Highbd2dVarTest::RunTest(bool is_random) {
|
|
int failed = 0;
|
|
for (int k = 0; k < kNumIterations; k++) {
|
|
const int width = 4 * (rnd_(63) + 1); // Up to 256x256
|
|
const int height = 4 * (rnd_(63) + 1); // Up to 256x256
|
|
int stride = 4 << rnd_(8); // Up to 512 stride
|
|
while (stride < width) { // Make sure it's valid
|
|
stride = 4 << rnd_(8);
|
|
}
|
|
if (is_random) {
|
|
GenRandomData(width, height, stride);
|
|
} else {
|
|
GenExtremeData(width, height, stride);
|
|
}
|
|
|
|
const uint64_t res_ref =
|
|
params_.ref_func(CONVERT_TO_BYTEPTR(src_), stride, width, height);
|
|
uint64_t res_tst;
|
|
API_REGISTER_STATE_CHECK(
|
|
res_tst =
|
|
params_.tst_func(CONVERT_TO_BYTEPTR(src_), stride, width, height));
|
|
|
|
if (!failed) {
|
|
failed = res_ref != res_tst;
|
|
EXPECT_EQ(res_ref, res_tst)
|
|
<< "Error: Sum Squares Test [" << width << "x" << height
|
|
<< "] C output does not match optimized output.";
|
|
}
|
|
}
|
|
}
|
|
|
|
void Highbd2dVarTest::RunSpeedTest() {
|
|
for (int block = 0; block < 2; block++) {
|
|
const int width = test_block_size[block];
|
|
const int height = test_block_size[block];
|
|
int stride = 4 << rnd_(8); // Up to 512 stride
|
|
while (stride < width) { // Make sure it's valid
|
|
stride = 4 << rnd_(8);
|
|
}
|
|
GenExtremeData(width, height, stride);
|
|
const int num_loops = 1000000000 / (width + height);
|
|
aom_usec_timer timer;
|
|
aom_usec_timer_start(&timer);
|
|
|
|
for (int i = 0; i < num_loops; ++i)
|
|
params_.ref_func(CONVERT_TO_BYTEPTR(src_), stride, width, height);
|
|
|
|
aom_usec_timer_mark(&timer);
|
|
const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
|
|
|
|
aom_usec_timer timer1;
|
|
aom_usec_timer_start(&timer1);
|
|
for (int i = 0; i < num_loops; ++i)
|
|
params_.tst_func(CONVERT_TO_BYTEPTR(src_), stride, width, height);
|
|
aom_usec_timer_mark(&timer1);
|
|
const int elapsed_time1 = static_cast<int>(aom_usec_timer_elapsed(&timer1));
|
|
printf("%3dx%-3d: Scaling = %.2f\n", width, height,
|
|
(double)elapsed_time / elapsed_time1);
|
|
}
|
|
}
|
|
|
|
TEST_P(Highbd2dVarTest, OperationCheck) {
|
|
RunTest(true); // GenRandomData
|
|
}
|
|
|
|
TEST_P(Highbd2dVarTest, ExtremeValues) {
|
|
RunTest(false); // GenExtremeData
|
|
}
|
|
|
|
TEST_P(Highbd2dVarTest, DISABLED_Speed) { RunSpeedTest(); }
|
|
|
|
#if HAVE_SSE2
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
SSE2, Highbd2dVarTest,
|
|
::testing::Values(TestFuncVar2D(&aom_var_2d_u16_c, &aom_var_2d_u16_sse2)));
|
|
|
|
#endif // HAVE_SSE2
|
|
|
|
#if HAVE_AVX2
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
AVX2, Highbd2dVarTest,
|
|
::testing::Values(TestFuncVar2D(&aom_var_2d_u16_c, &aom_var_2d_u16_avx2)));
|
|
|
|
#endif // HAVE_SSE2
|
|
|
|
#if HAVE_NEON
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
NEON, Highbd2dVarTest,
|
|
::testing::Values(TestFuncVar2D(&aom_var_2d_u16_c, &aom_var_2d_u16_neon)));
|
|
|
|
#endif // HAVE_NEON
|
|
|
|
#if HAVE_SVE
|
|
|
|
INSTANTIATE_TEST_SUITE_P(SVE, Highbd2dVarTest,
|
|
::testing::Values(TestFuncVar2D(&aom_var_2d_u16_c,
|
|
&aom_var_2d_u16_sve)));
|
|
|
|
#endif // HAVE_SVE
|
|
#endif // CONFIG_AV1_HIGHBITDEPTH
|
|
} // namespace
|