third_party/aom/test/sum_squares_test.cc

   1 /*
   2  * Copyright (c) 2016, Alliance for Open Media. All rights reserved
   3  *
   4  * This source code is subject to the terms of the BSD 2 Clause License and
   5  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
   6  * was not distributed with this source code in the LICENSE file, you can
   7  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
   8  * Media Patent License 1.0 was not distributed with this source code in the
   9  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  10  */
  11
  12 #include <cmath>
  13 #include <cstdlib>
  14 #include <string>
  15 #include <tuple>
  16
  17 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
  18
  19 #include "config/aom_config.h"
  20 #include "config/aom_dsp_rtcd.h"
  21
  22 #include "aom_ports/mem.h"
  23 #include "av1/common/common_data.h"
  24 #include "test/acm_random.h"
  25 #include "test/register_state_check.h"
  26 #include "test/util.h"
  27 #include "test/function_equivalence_test.h"
  28
  29 using libaom_test::ACMRandom;
  30 using libaom_test::FunctionEquivalenceTest;
  31 using ::testing::Combine;
  32 using ::testing::Range;
  33 using ::testing::Values;
  34 using ::testing::ValuesIn;
  35
  36 namespace {
  37 const int kNumIterations = 10000;
  38
  39 static const int16_t kInt13Max = (1 << 12) - 1;
  40
  41 typedef uint64_t (*SSI16Func)(const int16_t *src, int stride, int width,
  42                               int height);
  43 typedef libaom_test::FuncParam<SSI16Func> TestFuncs;
  44
  45 class SumSquaresTest : public ::testing::TestWithParam<TestFuncs> {
  46  public:
  47   ~SumSquaresTest() override = default;
  48   void SetUp() override {
  49     params_ = this->GetParam();
  50     rnd_.Reset(ACMRandom::DeterministicSeed());
  51     src_ = reinterpret_cast<int16_t *>(aom_memalign(16, 256 * 256 * 2));
  52     ASSERT_NE(src_, nullptr);
  53   }
  54
  55   void TearDown() override { aom_free(src_); }
  56   void RunTest(bool is_random);
  57   void RunSpeedTest();
  58
  59   void GenRandomData(int width, int height, int stride) {
  60     const int msb = 11;  // Up to 12 bit input
  61     const int limit = 1 << (msb + 1);
  62     for (int ii = 0; ii < height; ii++) {
  63       for (int jj = 0; jj < width; jj++) {
  64         src_[ii * stride + jj] = rnd_(2) ? rnd_(limit) : -rnd_(limit);
  65       }
  66     }
  67   }
  68
  69   void GenExtremeData(int width, int height, int stride) {
  70     const int msb = 11;  // Up to 12 bit input
  71     const int limit = 1 << (msb + 1);
  72     const int val = rnd_(2) ? limit - 1 : -(limit - 1);
  73     for (int ii = 0; ii < height; ii++) {
  74       for (int jj = 0; jj < width; jj++) {
  75         src_[ii * stride + jj] = val;
  76       }
  77     }
  78   }
  79
  80  protected:
  81   TestFuncs params_;
  82   int16_t *src_;
  83   ACMRandom rnd_;
  84 };
  85 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SumSquaresTest);
  86
  87 void SumSquaresTest::RunTest(bool is_random) {
  88   int failed = 0;
  89   for (int k = 0; k < kNumIterations; k++) {
  90     const int width = 4 * (rnd_(31) + 1);   // Up to 128x128
  91     const int height = 4 * (rnd_(31) + 1);  // Up to 128x128
  92     int stride = 4 << rnd_(7);              // Up to 256 stride
  93     while (stride < width) {                // Make sure it's valid
  94       stride = 4 << rnd_(7);
  95     }
  96     if (is_random) {
  97       GenRandomData(width, height, stride);
  98     } else {
  99       GenExtremeData(width, height, stride);
 100     }
 101     const uint64_t res_ref = params_.ref_func(src_, stride, width, height);
 102     uint64_t res_tst;
 103     API_REGISTER_STATE_CHECK(res_tst =
 104                                  params_.tst_func(src_, stride, width, height));
 105
 106     if (!failed) {
 107       failed = res_ref != res_tst;
 108       EXPECT_EQ(res_ref, res_tst)
 109           << "Error: Sum Squares Test [" << width << "x" << height
 110           << "] C output does not match optimized output.";
 111     }
 112   }
 113 }
 114
 115 void SumSquaresTest::RunSpeedTest() {
 116   for (int block = BLOCK_4X4; block < BLOCK_SIZES_ALL; block++) {
 117     const int width = block_size_wide[block];   // Up to 128x128
 118     const int height = block_size_high[block];  // Up to 128x128
 119     int stride = 4 << rnd_(7);                  // Up to 256 stride
 120     while (stride < width) {                    // Make sure it's valid
 121       stride = 4 << rnd_(7);
 122     }
 123     GenExtremeData(width, height, stride);
 124     const int num_loops = 1000000000 / (width + height);
 125     aom_usec_timer timer;
 126     aom_usec_timer_start(&timer);
 127
 128     for (int i = 0; i < num_loops; ++i)
 129       params_.ref_func(src_, stride, width, height);
 130
 131     aom_usec_timer_mark(&timer);
 132     const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
 133     printf("SumSquaresTest C %3dx%-3d: %7.2f ns\n", width, height,
 134            1000.0 * elapsed_time / num_loops);
 135
 136     aom_usec_timer timer1;
 137     aom_usec_timer_start(&timer1);
 138     for (int i = 0; i < num_loops; ++i)
 139       params_.tst_func(src_, stride, width, height);
 140     aom_usec_timer_mark(&timer1);
 141     const int elapsed_time1 = static_cast<int>(aom_usec_timer_elapsed(&timer1));
 142     printf("SumSquaresTest Test %3dx%-3d: %7.2f ns\n", width, height,
 143            1000.0 * elapsed_time1 / num_loops);
 144   }
 145 }
 146
 147 TEST_P(SumSquaresTest, OperationCheck) {
 148   RunTest(true);  // GenRandomData
 149 }
 150
 151 TEST_P(SumSquaresTest, ExtremeValues) {
 152   RunTest(false);  // GenExtremeData
 153 }
 154
 155 TEST_P(SumSquaresTest, DISABLED_Speed) { RunSpeedTest(); }
 156
 157 #if HAVE_SSE2
 158
 159 INSTANTIATE_TEST_SUITE_P(
 160     SSE2, SumSquaresTest,
 161     ::testing::Values(TestFuncs(&aom_sum_squares_2d_i16_c,
 162                                 &aom_sum_squares_2d_i16_sse2)));
 163
 164 #endif  // HAVE_SSE2
 165
 166 #if HAVE_NEON
 167
 168 INSTANTIATE_TEST_SUITE_P(
 169     NEON, SumSquaresTest,
 170     ::testing::Values(TestFuncs(&aom_sum_squares_2d_i16_c,
 171                                 &aom_sum_squares_2d_i16_neon)));
 172
 173 #endif  // HAVE_NEON
 174
 175 #if HAVE_SVE
 176 INSTANTIATE_TEST_SUITE_P(
 177     SVE, SumSquaresTest,
 178     ::testing::Values(TestFuncs(&aom_sum_squares_2d_i16_c,
 179                                 &aom_sum_squares_2d_i16_sve)));
 180
 181 #endif  // HAVE_SVE
 182
 183 #if HAVE_AVX2
 184 INSTANTIATE_TEST_SUITE_P(
 185     AVX2, SumSquaresTest,
 186     ::testing::Values(TestFuncs(&aom_sum_squares_2d_i16_c,
 187                                 &aom_sum_squares_2d_i16_avx2)));
 188 #endif  // HAVE_AVX2
 189
 190 //////////////////////////////////////////////////////////////////////////////
 191 // 1D version
 192 //////////////////////////////////////////////////////////////////////////////
 193
 194 typedef uint64_t (*F1D)(const int16_t *src, uint32_t n);
 195 typedef libaom_test::FuncParam<F1D> TestFuncs1D;
 196
 197 class SumSquares1DTest : public FunctionEquivalenceTest<F1D> {
 198  protected:
 199   static const int kIterations = 1000;
 200   static const int kMaxSize = 256;
 201 };
 202 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SumSquares1DTest);
 203
 204 TEST_P(SumSquares1DTest, RandomValues) {
 205   DECLARE_ALIGNED(16, int16_t, src[kMaxSize * kMaxSize]);
 206
 207   for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
 208     for (int i = 0; i < kMaxSize * kMaxSize; ++i)
 209       src[i] = rng_(kInt13Max * 2 + 1) - kInt13Max;
 210
 211     // Block size is between 64 and 128 * 128 and is always a multiple of 64.
 212     const int n = (rng_(255) + 1) * 64;
 213
 214     const uint64_t ref_res = params_.ref_func(src, n);
 215     uint64_t tst_res;
 216     API_REGISTER_STATE_CHECK(tst_res = params_.tst_func(src, n));
 217
 218     ASSERT_EQ(ref_res, tst_res);
 219   }
 220 }
 221
 222 TEST_P(SumSquares1DTest, ExtremeValues) {
 223   DECLARE_ALIGNED(16, int16_t, src[kMaxSize * kMaxSize]);
 224
 225   for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
 226     if (rng_(2)) {
 227       for (int i = 0; i < kMaxSize * kMaxSize; ++i) src[i] = kInt13Max;
 228     } else {
 229       for (int i = 0; i < kMaxSize * kMaxSize; ++i) src[i] = -kInt13Max;
 230     }
 231
 232     // Block size is between 64 and 128 * 128 and is always a multiple of 64.
 233     const int n = (rng_(255) + 1) * 64;
 234
 235     const uint64_t ref_res = params_.ref_func(src, n);
 236     uint64_t tst_res;
 237     API_REGISTER_STATE_CHECK(tst_res = params_.tst_func(src, n));
 238
 239     ASSERT_EQ(ref_res, tst_res);
 240   }
 241 }
 242
 243 #if HAVE_SSE2
 244 INSTANTIATE_TEST_SUITE_P(SSE2, SumSquares1DTest,
 245                          ::testing::Values(TestFuncs1D(
 246                              aom_sum_squares_i16_c, aom_sum_squares_i16_sse2)));
 247
 248 #endif  // HAVE_SSE2
 249
 250 #if HAVE_NEON
 251 INSTANTIATE_TEST_SUITE_P(NEON, SumSquares1DTest,
 252                          ::testing::Values(TestFuncs1D(
 253                              aom_sum_squares_i16_c, aom_sum_squares_i16_neon)));
 254
 255 #endif  // HAVE_NEON
 256
 257 #if HAVE_SVE
 258 INSTANTIATE_TEST_SUITE_P(SVE, SumSquares1DTest,
 259                          ::testing::Values(TestFuncs1D(
 260                              aom_sum_squares_i16_c, aom_sum_squares_i16_sve)));
 261
 262 #endif  // HAVE_SVE
 263
 264 typedef int64_t (*SSEFunc)(const uint8_t *a, int a_stride, const uint8_t *b,
 265                            int b_stride, int width, int height);
 266 typedef libaom_test::FuncParam<SSEFunc> TestSSEFuncs;
 267
 268 typedef std::tuple<TestSSEFuncs, int> SSETestParam;
 269
 270 class SSETest : public ::testing::TestWithParam<SSETestParam> {
 271  public:
 272   ~SSETest() override = default;
 273   void SetUp() override {
 274     params_ = GET_PARAM(0);
 275     width_ = GET_PARAM(1);
 276     is_hbd_ =
 277 #if CONFIG_AV1_HIGHBITDEPTH
 278         params_.ref_func == aom_highbd_sse_c;
 279 #else
 280         false;
 281 #endif
 282     rnd_.Reset(ACMRandom::DeterministicSeed());
 283     src_ = reinterpret_cast<uint8_t *>(aom_memalign(32, 256 * 256 * 2));
 284     ref_ = reinterpret_cast<uint8_t *>(aom_memalign(32, 256 * 256 * 2));
 285     ASSERT_NE(src_, nullptr);
 286     ASSERT_NE(ref_, nullptr);
 287   }
 288
 289   void TearDown() override {
 290     aom_free(src_);
 291     aom_free(ref_);
 292   }
 293   void RunTest(bool is_random, int width, int height, int run_times);
 294
 295   void GenRandomData(int width, int height, int stride) {
 296     uint16_t *src16 = reinterpret_cast<uint16_t *>(src_);
 297     uint16_t *ref16 = reinterpret_cast<uint16_t *>(ref_);
 298     const int msb = 11;  // Up to 12 bit input
 299     const int limit = 1 << (msb + 1);
 300     for (int ii = 0; ii < height; ii++) {
 301       for (int jj = 0; jj < width; jj++) {
 302         if (!is_hbd_) {
 303           src_[ii * stride + jj] = rnd_.Rand8();
 304           ref_[ii * stride + jj] = rnd_.Rand8();
 305         } else {
 306           src16[ii * stride + jj] = rnd_(limit);
 307           ref16[ii * stride + jj] = rnd_(limit);
 308         }
 309       }
 310     }
 311   }
 312
 313   void GenExtremeData(int width, int height, int stride, uint8_t *data,
 314                       int16_t val) {
 315     uint16_t *data16 = reinterpret_cast<uint16_t *>(data);
 316     for (int ii = 0; ii < height; ii++) {
 317       for (int jj = 0; jj < width; jj++) {
 318         if (!is_hbd_) {
 319           data[ii * stride + jj] = static_cast<uint8_t>(val);
 320         } else {
 321           data16[ii * stride + jj] = val;
 322         }
 323       }
 324     }
 325   }
 326
 327  protected:
 328   bool is_hbd_;
 329   int width_;
 330   TestSSEFuncs params_;
 331   uint8_t *src_;
 332   uint8_t *ref_;
 333   ACMRandom rnd_;
 334 };
 335 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SSETest);
 336
 337 void SSETest::RunTest(bool is_random, int width, int height, int run_times) {
 338   int failed = 0;
 339   aom_usec_timer ref_timer, test_timer;
 340   for (int k = 0; k < 3; k++) {
 341     int stride = 4 << rnd_(7);  // Up to 256 stride
 342     while (stride < width) {    // Make sure it's valid
 343       stride = 4 << rnd_(7);
 344     }
 345     if (is_random) {
 346       GenRandomData(width, height, stride);
 347     } else {
 348       const int msb = is_hbd_ ? 12 : 8;  // Up to 12 bit input
 349       const int limit = (1 << msb) - 1;
 350       if (k == 0) {
 351         GenExtremeData(width, height, stride, src_, 0);
 352         GenExtremeData(width, height, stride, ref_, limit);
 353       } else {
 354         GenExtremeData(width, height, stride, src_, limit);
 355         GenExtremeData(width, height, stride, ref_, 0);
 356       }
 357     }
 358     int64_t res_ref, res_tst;
 359     uint8_t *src = src_;
 360     uint8_t *ref = ref_;
 361     if (is_hbd_) {
 362       src = CONVERT_TO_BYTEPTR(src_);
 363       ref = CONVERT_TO_BYTEPTR(ref_);
 364     }
 365     res_ref = params_.ref_func(src, stride, ref, stride, width, height);
 366     res_tst = params_.tst_func(src, stride, ref, stride, width, height);
 367     if (run_times > 1) {
 368       aom_usec_timer_start(&ref_timer);
 369       for (int j = 0; j < run_times; j++) {
 370         params_.ref_func(src, stride, ref, stride, width, height);
 371       }
 372       aom_usec_timer_mark(&ref_timer);
 373       const int elapsed_time_c =
 374           static_cast<int>(aom_usec_timer_elapsed(&ref_timer));
 375
 376       aom_usec_timer_start(&test_timer);
 377       for (int j = 0; j < run_times; j++) {
 378         params_.tst_func(src, stride, ref, stride, width, height);
 379       }
 380       aom_usec_timer_mark(&test_timer);
 381       const int elapsed_time_simd =
 382           static_cast<int>(aom_usec_timer_elapsed(&test_timer));
 383
 384       printf(
 385           "c_time=%d \t simd_time=%d \t "
 386           "gain=%d\n",
 387           elapsed_time_c, elapsed_time_simd,
 388           (elapsed_time_c / elapsed_time_simd));
 389     } else {
 390       if (!failed) {
 391         failed = res_ref != res_tst;
 392         EXPECT_EQ(res_ref, res_tst)
 393             << "Error:" << (is_hbd_ ? "hbd " : " ") << k << " SSE Test ["
 394             << width << "x" << height
 395             << "] C output does not match optimized output.";
 396       }
 397     }
 398   }
 399 }
 400
 401 TEST_P(SSETest, OperationCheck) {
 402   for (int height = 4; height <= 128; height += 4) {
 403     RunTest(true, width_, height, 1);  // GenRandomData
 404   }
 405 }
 406
 407 TEST_P(SSETest, ExtremeValues) {
 408   for (int height = 4; height <= 128; height += 4) {
 409     RunTest(false, width_, height, 1);
 410   }
 411 }
 412
 413 TEST_P(SSETest, DISABLED_Speed) {
 414   for (int height = 4; height <= 128; height += 4) {
 415     RunTest(true, width_, height, 100);
 416   }
 417 }
 418
 419 #if HAVE_NEON
 420 TestSSEFuncs sse_neon[] = {
 421   TestSSEFuncs(&aom_sse_c, &aom_sse_neon),
 422 #if CONFIG_AV1_HIGHBITDEPTH
 423   TestSSEFuncs(&aom_highbd_sse_c, &aom_highbd_sse_neon)
 424 #endif
 425 };
 426 INSTANTIATE_TEST_SUITE_P(NEON, SSETest,
 427                          Combine(ValuesIn(sse_neon), Range(4, 129, 4)));
 428 #endif  // HAVE_NEON
 429
 430 #if HAVE_NEON_DOTPROD
 431 TestSSEFuncs sse_neon_dotprod[] = {
 432   TestSSEFuncs(&aom_sse_c, &aom_sse_neon_dotprod),
 433 };
 434 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, SSETest,
 435                          Combine(ValuesIn(sse_neon_dotprod), Range(4, 129, 4)));
 436 #endif  // HAVE_NEON_DOTPROD
 437
 438 #if HAVE_SSE4_1
 439 TestSSEFuncs sse_sse4[] = {
 440   TestSSEFuncs(&aom_sse_c, &aom_sse_sse4_1),
 441 #if CONFIG_AV1_HIGHBITDEPTH
 442   TestSSEFuncs(&aom_highbd_sse_c, &aom_highbd_sse_sse4_1)
 443 #endif
 444 };
 445 INSTANTIATE_TEST_SUITE_P(SSE4_1, SSETest,
 446                          Combine(ValuesIn(sse_sse4), Range(4, 129, 4)));
 447 #endif  // HAVE_SSE4_1
 448
 449 #if HAVE_AVX2
 450
 451 TestSSEFuncs sse_avx2[] = {
 452   TestSSEFuncs(&aom_sse_c, &aom_sse_avx2),
 453 #if CONFIG_AV1_HIGHBITDEPTH
 454   TestSSEFuncs(&aom_highbd_sse_c, &aom_highbd_sse_avx2)
 455 #endif
 456 };
 457 INSTANTIATE_TEST_SUITE_P(AVX2, SSETest,
 458                          Combine(ValuesIn(sse_avx2), Range(4, 129, 4)));
 459 #endif  // HAVE_AVX2
 460
 461 #if HAVE_SVE
 462 #if CONFIG_AV1_HIGHBITDEPTH
 463 TestSSEFuncs sse_sve[] = { TestSSEFuncs(&aom_highbd_sse_c,
 464                                         &aom_highbd_sse_sve) };
 465 INSTANTIATE_TEST_SUITE_P(SVE, SSETest,
 466                          Combine(ValuesIn(sse_sve), Range(4, 129, 4)));
 467 #endif
 468 #endif  // HAVE_SVE
 469
 470 //////////////////////////////////////////////////////////////////////////////
 471 // get_blk sum squares test functions
 472 //////////////////////////////////////////////////////////////////////////////
 473
 474 typedef void (*sse_sum_func)(const int16_t *data, int stride, int bw, int bh,
 475                              int *x_sum, int64_t *x2_sum);
 476 typedef libaom_test::FuncParam<sse_sum_func> TestSSE_SumFuncs;
 477
 478 typedef std::tuple<TestSSE_SumFuncs, TX_SIZE> SSE_SumTestParam;
 479
 480 class SSE_Sum_Test : public ::testing::TestWithParam<SSE_SumTestParam> {
 481  public:
 482   ~SSE_Sum_Test() override = default;
 483   void SetUp() override {
 484     params_ = GET_PARAM(0);
 485     rnd_.Reset(ACMRandom::DeterministicSeed());
 486     src_ = reinterpret_cast<int16_t *>(aom_memalign(32, 256 * 256 * 2));
 487     ASSERT_NE(src_, nullptr);
 488   }
 489
 490   void TearDown() override { aom_free(src_); }
 491   void RunTest(bool is_random, int tx_size, int run_times);
 492
 493   void GenRandomData(int width, int height, int stride) {
 494     const int msb = 11;  // Up to 12 bit input
 495     const int limit = 1 << (msb + 1);
 496     for (int ii = 0; ii < height; ii++) {
 497       for (int jj = 0; jj < width; jj++) {
 498         src_[ii * stride + jj] = rnd_(limit);
 499       }
 500     }
 501   }
 502
 503   void GenExtremeData(int width, int height, int stride, int16_t *data,
 504                       int16_t val) {
 505     for (int ii = 0; ii < height; ii++) {
 506       for (int jj = 0; jj < width; jj++) {
 507         data[ii * stride + jj] = val;
 508       }
 509     }
 510   }
 511
 512  protected:
 513   TestSSE_SumFuncs params_;
 514   int16_t *src_;
 515   ACMRandom rnd_;
 516 };
 517 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(SSE_Sum_Test);
 518
 519 void SSE_Sum_Test::RunTest(bool is_random, int tx_size, int run_times) {
 520   aom_usec_timer ref_timer, test_timer;
 521   int width = tx_size_wide[tx_size];
 522   int height = tx_size_high[tx_size];
 523   for (int k = 0; k < 3; k++) {
 524     int stride = 4 << rnd_(7);  // Up to 256 stride
 525     while (stride < width) {    // Make sure it's valid
 526       stride = 4 << rnd_(7);
 527     }
 528     if (is_random) {
 529       GenRandomData(width, height, stride);
 530     } else {
 531       const int msb = 12;  // Up to 12 bit input
 532       const int limit = (1 << msb) - 1;
 533       if (k == 0) {
 534         GenExtremeData(width, height, stride, src_, limit);
 535       } else {
 536         GenExtremeData(width, height, stride, src_, -limit);
 537       }
 538     }
 539     int sum_c = 0;
 540     int64_t sse_intr = 0;
 541     int sum_intr = 0;
 542     int64_t sse_c = 0;
 543
 544     params_.ref_func(src_, stride, width, height, &sum_c, &sse_c);
 545     params_.tst_func(src_, stride, width, height, &sum_intr, &sse_intr);
 546
 547     if (run_times > 1) {
 548       aom_usec_timer_start(&ref_timer);
 549       for (int j = 0; j < run_times; j++) {
 550         params_.ref_func(src_, stride, width, height, &sum_c, &sse_c);
 551       }
 552       aom_usec_timer_mark(&ref_timer);
 553       const int elapsed_time_c =
 554           static_cast<int>(aom_usec_timer_elapsed(&ref_timer));
 555
 556       aom_usec_timer_start(&test_timer);
 557       for (int j = 0; j < run_times; j++) {
 558         params_.tst_func(src_, stride, width, height, &sum_intr, &sse_intr);
 559       }
 560       aom_usec_timer_mark(&test_timer);
 561       const int elapsed_time_simd =
 562           static_cast<int>(aom_usec_timer_elapsed(&test_timer));
 563
 564       printf(
 565           "c_time=%d \t simd_time=%d \t "
 566           "gain=%f\t width=%d\t height=%d \n",
 567           elapsed_time_c, elapsed_time_simd,
 568           (float)((float)elapsed_time_c / (float)elapsed_time_simd), width,
 569           height);
 570
 571     } else {
 572       EXPECT_EQ(sum_c, sum_intr)
 573           << "Error:" << k << " SSE Sum Test [" << width << "x" << height
 574           << "] C output does not match optimized output.";
 575       EXPECT_EQ(sse_c, sse_intr)
 576           << "Error:" << k << " SSE Sum Test [" << width << "x" << height
 577           << "] C output does not match optimized output.";
 578     }
 579   }
 580 }
 581
 582 TEST_P(SSE_Sum_Test, OperationCheck) {
 583   RunTest(true, GET_PARAM(1), 1);  // GenRandomData
 584 }
 585
 586 TEST_P(SSE_Sum_Test, ExtremeValues) { RunTest(false, GET_PARAM(1), 1); }
 587
 588 TEST_P(SSE_Sum_Test, DISABLED_Speed) { RunTest(true, GET_PARAM(1), 10000); }
 589
 590 #if HAVE_SSE2 || HAVE_AVX2 || HAVE_NEON
 591 const TX_SIZE kValidBlockSize[] = { TX_4X4,   TX_8X8,   TX_16X16, TX_32X32,
 592                                     TX_64X64, TX_4X8,   TX_8X4,   TX_8X16,
 593                                     TX_16X8,  TX_16X32, TX_32X16, TX_64X32,
 594                                     TX_32X64, TX_4X16,  TX_16X4,  TX_8X32,
 595                                     TX_32X8,  TX_16X64, TX_64X16 };
 596 #endif
 597
 598 #if HAVE_SSE2
 599 TestSSE_SumFuncs sse_sum_sse2[] = { TestSSE_SumFuncs(
 600     &aom_get_blk_sse_sum_c, &aom_get_blk_sse_sum_sse2) };
 601 INSTANTIATE_TEST_SUITE_P(SSE2, SSE_Sum_Test,
 602                          Combine(ValuesIn(sse_sum_sse2),
 603                                  ValuesIn(kValidBlockSize)));
 604 #endif  // HAVE_SSE2
 605
 606 #if HAVE_AVX2
 607 TestSSE_SumFuncs sse_sum_avx2[] = { TestSSE_SumFuncs(
 608     &aom_get_blk_sse_sum_c, &aom_get_blk_sse_sum_avx2) };
 609 INSTANTIATE_TEST_SUITE_P(AVX2, SSE_Sum_Test,
 610                          Combine(ValuesIn(sse_sum_avx2),
 611                                  ValuesIn(kValidBlockSize)));
 612 #endif  // HAVE_AVX2
 613
 614 #if HAVE_NEON
 615 TestSSE_SumFuncs sse_sum_neon[] = { TestSSE_SumFuncs(
 616     &aom_get_blk_sse_sum_c, &aom_get_blk_sse_sum_neon) };
 617 INSTANTIATE_TEST_SUITE_P(NEON, SSE_Sum_Test,
 618                          Combine(ValuesIn(sse_sum_neon),
 619                                  ValuesIn(kValidBlockSize)));
 620 #endif  // HAVE_NEON
 621
 622 #if HAVE_SVE
 623 TestSSE_SumFuncs sse_sum_sve[] = { TestSSE_SumFuncs(&aom_get_blk_sse_sum_c,
 624                                                     &aom_get_blk_sse_sum_sve) };
 625 INSTANTIATE_TEST_SUITE_P(SVE, SSE_Sum_Test,
 626                          Combine(ValuesIn(sse_sum_sve),
 627                                  ValuesIn(kValidBlockSize)));
 628 #endif  // HAVE_SVE
 629
 630 //////////////////////////////////////////////////////////////////////////////
 631 // 2D Variance test functions
 632 //////////////////////////////////////////////////////////////////////////////
 633
 634 typedef uint64_t (*Var2DFunc)(uint8_t *src, int stride, int width, int height);
 635 typedef libaom_test::FuncParam<Var2DFunc> TestFuncVar2D;
 636
 637 const uint16_t test_block_size[2] = { 128, 256 };
 638
 639 class Lowbd2dVarTest : public ::testing::TestWithParam<TestFuncVar2D> {
 640  public:
 641   ~Lowbd2dVarTest() override = default;
 642   void SetUp() override {
 643     params_ = this->GetParam();
 644     rnd_.Reset(ACMRandom::DeterministicSeed());
 645     src_ = reinterpret_cast<uint8_t *>(
 646         aom_memalign(16, 512 * 512 * sizeof(uint8_t)));
 647     ASSERT_NE(src_, nullptr);
 648   }
 649
 650   void TearDown() override { aom_free(src_); }
 651   void RunTest(bool is_random);
 652   void RunSpeedTest();
 653
 654   void GenRandomData(int width, int height, int stride) {
 655     const int msb = 7;  // Up to 8 bit input
 656     const int limit = 1 << (msb + 1);
 657     for (int ii = 0; ii < height; ii++) {
 658       for (int jj = 0; jj < width; jj++) {
 659         src_[ii * stride + jj] = rnd_(limit);
 660       }
 661     }
 662   }
 663
 664   void GenExtremeData(int width, int height, int stride) {
 665     const int msb = 7;  // Up to 8 bit input
 666     const int limit = 1 << (msb + 1);
 667     const int val = rnd_(2) ? limit - 1 : 0;
 668     for (int ii = 0; ii < height; ii++) {
 669       for (int jj = 0; jj < width; jj++) {
 670         src_[ii * stride + jj] = val;
 671       }
 672     }
 673   }
 674
 675  protected:
 676   TestFuncVar2D params_;
 677   uint8_t *src_;
 678   ACMRandom rnd_;
 679 };
 680 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(Lowbd2dVarTest);
 681
 682 void Lowbd2dVarTest::RunTest(bool is_random) {
 683   int failed = 0;
 684   for (int k = 0; k < kNumIterations; k++) {
 685     const int width = 4 * (rnd_(63) + 1);   // Up to 256x256
 686     const int height = 4 * (rnd_(63) + 1);  // Up to 256x256
 687     int stride = 4 << rnd_(8);              // Up to 512 stride
 688     while (stride < width) {                // Make sure it's valid
 689       stride = 4 << rnd_(8);
 690     }
 691     if (is_random) {
 692       GenRandomData(width, height, stride);
 693     } else {
 694       GenExtremeData(width, height, stride);
 695     }
 696
 697     const uint64_t res_ref = params_.ref_func(src_, stride, width, height);
 698     uint64_t res_tst;
 699     API_REGISTER_STATE_CHECK(res_tst =
 700                                  params_.tst_func(src_, stride, width, height));
 701
 702     if (!failed) {
 703       failed = res_ref != res_tst;
 704       EXPECT_EQ(res_ref, res_tst)
 705           << "Error: Sum Squares Test [" << width << "x" << height
 706           << "] C output does not match optimized output.";
 707     }
 708   }
 709 }
 710
 711 void Lowbd2dVarTest::RunSpeedTest() {
 712   for (int block = 0; block < 2; block++) {
 713     const int width = test_block_size[block];
 714     const int height = test_block_size[block];
 715     int stride = 4 << rnd_(8);  // Up to 512 stride
 716     while (stride < width) {    // Make sure it's valid
 717       stride = 4 << rnd_(8);
 718     }
 719     GenExtremeData(width, height, stride);
 720     const int num_loops = 1000000000 / (width + height);
 721     aom_usec_timer timer;
 722     aom_usec_timer_start(&timer);
 723
 724     for (int i = 0; i < num_loops; ++i)
 725       params_.ref_func(src_, stride, width, height);
 726
 727     aom_usec_timer_mark(&timer);
 728     const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
 729
 730     aom_usec_timer timer1;
 731     aom_usec_timer_start(&timer1);
 732     for (int i = 0; i < num_loops; ++i)
 733       params_.tst_func(src_, stride, width, height);
 734     aom_usec_timer_mark(&timer1);
 735     const int elapsed_time1 = static_cast<int>(aom_usec_timer_elapsed(&timer1));
 736     printf("%3dx%-3d: Scaling = %.2f\n", width, height,
 737            (double)elapsed_time / elapsed_time1);
 738   }
 739 }
 740
 741 TEST_P(Lowbd2dVarTest, OperationCheck) {
 742   RunTest(true);  // GenRandomData
 743 }
 744
 745 TEST_P(Lowbd2dVarTest, ExtremeValues) {
 746   RunTest(false);  // GenExtremeData
 747 }
 748
 749 TEST_P(Lowbd2dVarTest, DISABLED_Speed) { RunSpeedTest(); }
 750
 751 #if HAVE_SSE2
 752
 753 INSTANTIATE_TEST_SUITE_P(SSE2, Lowbd2dVarTest,
 754                          ::testing::Values(TestFuncVar2D(&aom_var_2d_u8_c,
 755                                                          &aom_var_2d_u8_sse2)));
 756
 757 #endif  // HAVE_SSE2
 758
 759 #if HAVE_AVX2
 760
 761 INSTANTIATE_TEST_SUITE_P(AVX2, Lowbd2dVarTest,
 762                          ::testing::Values(TestFuncVar2D(&aom_var_2d_u8_c,
 763                                                          &aom_var_2d_u8_avx2)));
 764
 765 #endif  // HAVE_SSE2
 766
 767 #if HAVE_NEON
 768
 769 INSTANTIATE_TEST_SUITE_P(NEON, Lowbd2dVarTest,
 770                          ::testing::Values(TestFuncVar2D(&aom_var_2d_u8_c,
 771                                                          &aom_var_2d_u8_neon)));
 772
 773 #endif  // HAVE_NEON
 774
 775 #if HAVE_NEON_DOTPROD
 776
 777 INSTANTIATE_TEST_SUITE_P(NEON_DOTPROD, Lowbd2dVarTest,
 778                          ::testing::Values(TestFuncVar2D(
 779                              &aom_var_2d_u8_c, &aom_var_2d_u8_neon_dotprod)));
 780
 781 #endif  // HAVE_NEON_DOTPROD
 782
 783 class Highbd2dVarTest : public ::testing::TestWithParam<TestFuncVar2D> {
 784  public:
 785   ~Highbd2dVarTest() override = default;
 786   void SetUp() override {
 787     params_ = this->GetParam();
 788     rnd_.Reset(ACMRandom::DeterministicSeed());
 789     src_ = reinterpret_cast<uint16_t *>(
 790         aom_memalign(16, 512 * 512 * sizeof(uint16_t)));
 791     ASSERT_NE(src_, nullptr);
 792   }
 793
 794   void TearDown() override { aom_free(src_); }
 795   void RunTest(bool is_random);
 796   void RunSpeedTest();
 797
 798   void GenRandomData(int width, int height, int stride) {
 799     const int msb = 11;  // Up to 12 bit input
 800     const int limit = 1 << (msb + 1);
 801     for (int ii = 0; ii < height; ii++) {
 802       for (int jj = 0; jj < width; jj++) {
 803         src_[ii * stride + jj] = rnd_(limit);
 804       }
 805     }
 806   }
 807
 808   void GenExtremeData(int width, int height, int stride) {
 809     const int msb = 11;  // Up to 12 bit input
 810     const int limit = 1 << (msb + 1);
 811     const int val = rnd_(2) ? limit - 1 : 0;
 812     for (int ii = 0; ii < height; ii++) {
 813       for (int jj = 0; jj < width; jj++) {
 814         src_[ii * stride + jj] = val;
 815       }
 816     }
 817   }
 818
 819  protected:
 820   TestFuncVar2D params_;
 821   uint16_t *src_;
 822   ACMRandom rnd_;
 823 };
 824 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(Highbd2dVarTest);
 825
 826 void Highbd2dVarTest::RunTest(bool is_random) {
 827   int failed = 0;
 828   for (int k = 0; k < kNumIterations; k++) {
 829     const int width = 4 * (rnd_(63) + 1);   // Up to 256x256
 830     const int height = 4 * (rnd_(63) + 1);  // Up to 256x256
 831     int stride = 4 << rnd_(8);              // Up to 512 stride
 832     while (stride < width) {                // Make sure it's valid
 833       stride = 4 << rnd_(8);
 834     }
 835     if (is_random) {
 836       GenRandomData(width, height, stride);
 837     } else {
 838       GenExtremeData(width, height, stride);
 839     }
 840
 841     const uint64_t res_ref =
 842         params_.ref_func(CONVERT_TO_BYTEPTR(src_), stride, width, height);
 843     uint64_t res_tst;
 844     API_REGISTER_STATE_CHECK(
 845         res_tst =
 846             params_.tst_func(CONVERT_TO_BYTEPTR(src_), stride, width, height));
 847
 848     if (!failed) {
 849       failed = res_ref != res_tst;
 850       EXPECT_EQ(res_ref, res_tst)
 851           << "Error: Sum Squares Test [" << width << "x" << height
 852           << "] C output does not match optimized output.";
 853     }
 854   }
 855 }
 856
 857 void Highbd2dVarTest::RunSpeedTest() {
 858   for (int block = 0; block < 2; block++) {
 859     const int width = test_block_size[block];
 860     const int height = test_block_size[block];
 861     int stride = 4 << rnd_(8);  // Up to 512 stride
 862     while (stride < width) {    // Make sure it's valid
 863       stride = 4 << rnd_(8);
 864     }
 865     GenExtremeData(width, height, stride);
 866     const int num_loops = 1000000000 / (width + height);
 867     aom_usec_timer timer;
 868     aom_usec_timer_start(&timer);
 869
 870     for (int i = 0; i < num_loops; ++i)
 871       params_.ref_func(CONVERT_TO_BYTEPTR(src_), stride, width, height);
 872
 873     aom_usec_timer_mark(&timer);
 874     const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
 875
 876     aom_usec_timer timer1;
 877     aom_usec_timer_start(&timer1);
 878     for (int i = 0; i < num_loops; ++i)
 879       params_.tst_func(CONVERT_TO_BYTEPTR(src_), stride, width, height);
 880     aom_usec_timer_mark(&timer1);
 881     const int elapsed_time1 = static_cast<int>(aom_usec_timer_elapsed(&timer1));
 882     printf("%3dx%-3d: Scaling = %.2f\n", width, height,
 883            (double)elapsed_time / elapsed_time1);
 884   }
 885 }
 886
 887 TEST_P(Highbd2dVarTest, OperationCheck) {
 888   RunTest(true);  // GenRandomData
 889 }
 890
 891 TEST_P(Highbd2dVarTest, ExtremeValues) {
 892   RunTest(false);  // GenExtremeData
 893 }
 894
 895 TEST_P(Highbd2dVarTest, DISABLED_Speed) { RunSpeedTest(); }
 896
 897 #if HAVE_SSE2
 898
 899 INSTANTIATE_TEST_SUITE_P(
 900     SSE2, Highbd2dVarTest,
 901     ::testing::Values(TestFuncVar2D(&aom_var_2d_u16_c, &aom_var_2d_u16_sse2)));
 902
 903 #endif  // HAVE_SSE2
 904
 905 #if HAVE_AVX2
 906
 907 INSTANTIATE_TEST_SUITE_P(
 908     AVX2, Highbd2dVarTest,
 909     ::testing::Values(TestFuncVar2D(&aom_var_2d_u16_c, &aom_var_2d_u16_avx2)));
 910
 911 #endif  // HAVE_SSE2
 912
 913 #if HAVE_NEON
 914
 915 INSTANTIATE_TEST_SUITE_P(
 916     NEON, Highbd2dVarTest,
 917     ::testing::Values(TestFuncVar2D(&aom_var_2d_u16_c, &aom_var_2d_u16_neon)));
 918
 919 #endif  // HAVE_NEON
 920
 921 #if HAVE_SVE
 922
 923 INSTANTIATE_TEST_SUITE_P(SVE, Highbd2dVarTest,
 924                          ::testing::Values(TestFuncVar2D(&aom_var_2d_u16_c,
 925                                                          &aom_var_2d_u16_sve)));
 926
 927 #endif  // HAVE_SVE
 928 }  // namespace