tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

av1_round_shift_array_test.cc (4344B)

      1 /*
      2 * Copyright (c) 2018, 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 <math.h>
     13 #include <stdio.h>
     14 #include <stdlib.h>
     15 #include <tuple>
     16 
     17 #include "config/av1_rtcd.h"
     18 
     19 #include "aom_mem/aom_mem.h"
     20 #include "aom_ports/aom_timer.h"
     21 #include "aom_ports/mem.h"
     22 #include "gtest/gtest.h"
     23 #include "test/acm_random.h"
     24 #include "test/util.h"
     25 
     26 namespace AV1CompRoundShift {
     27 
     28 using comp_round_shift_array_func = void (*)(int32_t *arr, int size, int bit);
     29 
     30 #if HAVE_SSE4_1 || HAVE_NEON
     31 const int kValidBitCheck[] = {
     32  -4, -3, -2, -1, 0, 1, 2, 3, 4,
     33 };
     34 #endif  // HAVE_SSE4_1 || HAVE_NEON
     35 
     36 using CompRoundShiftParam =
     37    std::tuple<comp_round_shift_array_func, BLOCK_SIZE, int>;
     38 
     39 class AV1CompRoundShiftTest
     40    : public ::testing::TestWithParam<CompRoundShiftParam> {
     41 public:
     42  ~AV1CompRoundShiftTest() override;
     43 
     44  void SetUp() override {
     45    rnd_.Reset(libaom_test::ACMRandom::DeterministicSeed());
     46  }
     47 
     48 protected:
     49  void RunCheckOutput(comp_round_shift_array_func test_impl, BLOCK_SIZE bsize,
     50                      int bit);
     51  void RunSpeedTest(comp_round_shift_array_func test_impl, BLOCK_SIZE bsize,
     52                    int bit);
     53 
     54  libaom_test::ACMRandom rnd_;
     55 };
     56 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AV1CompRoundShiftTest);
     57 
     58 AV1CompRoundShiftTest::~AV1CompRoundShiftTest() = default;
     59 
     60 void AV1CompRoundShiftTest::RunCheckOutput(
     61    comp_round_shift_array_func test_impl, BLOCK_SIZE bsize, int bit) {
     62  const int w = block_size_wide[bsize];
     63  const int h = block_size_high[bsize];
     64  const int blk_wd = 64;
     65  DECLARE_ALIGNED(32, int32_t, pred_[blk_wd]);
     66  DECLARE_ALIGNED(32, int32_t, ref_buffer_[blk_wd]);
     67  for (int i = 0; i < (blk_wd); ++i) {
     68    ref_buffer_[i] = pred_[i] = rnd_.Rand31() / 16;
     69  }
     70  av1_round_shift_array_c(ref_buffer_, w, bit);
     71  test_impl(pred_, w, bit);
     72  for (int x = 0; x < w; ++x) {
     73    ASSERT_EQ(ref_buffer_[x], pred_[x]) << w << "x" << h << "mismatch @"
     74                                        << "(" << x << ")";
     75  }
     76 }
     77 
     78 void AV1CompRoundShiftTest::RunSpeedTest(comp_round_shift_array_func test_impl,
     79                                         BLOCK_SIZE bsize, int bit) {
     80  const int w = block_size_wide[bsize];
     81  const int h = block_size_high[bsize];
     82  const int blk_wd = 64;
     83  DECLARE_ALIGNED(32, int32_t, ref_buffer_[blk_wd]);
     84  for (int i = 0; i < (blk_wd); ++i) {
     85    ref_buffer_[i] = rnd_.Rand31();
     86  }
     87 
     88  const int num_loops = 1000000000 / (w + h);
     89  comp_round_shift_array_func funcs[2] = { av1_round_shift_array_c, test_impl };
     90  double elapsed_time[2] = { 0 };
     91  for (int i = 0; i < 2; ++i) {
     92    aom_usec_timer timer;
     93    aom_usec_timer_start(&timer);
     94    comp_round_shift_array_func func = funcs[i];
     95    for (int j = 0; j < num_loops; ++j) {
     96      func(ref_buffer_, w, bit);
     97    }
     98    aom_usec_timer_mark(&timer);
     99    double time = static_cast<double>(aom_usec_timer_elapsed(&timer));
    100    elapsed_time[i] = 1000.0 * time / num_loops;
    101  }
    102  printf("av1_round_shift_array %3dx%-3d: bit : %d %7.2f/%7.2fns", w, h, bit,
    103         elapsed_time[0], elapsed_time[1]);
    104  printf("(%3.2f)\n", elapsed_time[0] / elapsed_time[1]);
    105 }
    106 
    107 TEST_P(AV1CompRoundShiftTest, CheckOutput) {
    108  RunCheckOutput(GET_PARAM(0), GET_PARAM(1), GET_PARAM(2));
    109 }
    110 
    111 TEST_P(AV1CompRoundShiftTest, DISABLED_Speed) {
    112  RunSpeedTest(GET_PARAM(0), GET_PARAM(1), GET_PARAM(2));
    113 }
    114 
    115 #if HAVE_SSE4_1
    116 INSTANTIATE_TEST_SUITE_P(
    117    SSE4_1, AV1CompRoundShiftTest,
    118    ::testing::Combine(::testing::Values(&av1_round_shift_array_sse4_1),
    119                       ::testing::ValuesIn(txsize_to_bsize),
    120                       ::testing::ValuesIn(kValidBitCheck)));
    121 #endif
    122 
    123 #if HAVE_NEON
    124 INSTANTIATE_TEST_SUITE_P(
    125    NEON, AV1CompRoundShiftTest,
    126    ::testing::Combine(::testing::Values(&av1_round_shift_array_neon),
    127                       ::testing::ValuesIn(txsize_to_bsize),
    128                       ::testing::ValuesIn(kValidBitCheck)));
    129 #endif
    130 
    131 }  // namespace AV1CompRoundShift