| /* |
| * 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 <cstdlib> |
| #include <string> |
| |
| #include "third_party/googletest/src/googletest/include/gtest/gtest.h" |
| |
| #include "./aom_config.h" |
| #include "./av1_rtcd.h" |
| #include "aom_ports/aom_timer.h" |
| #include "av1/common/cdef_block.h" |
| #include "test/acm_random.h" |
| #include "test/clear_system_state.h" |
| #include "test/register_state_check.h" |
| #include "test/util.h" |
| |
| using libaom_test::ACMRandom; |
| |
| namespace { |
| |
| typedef std::tr1::tuple<cdef_direction_func, cdef_direction_func, int> |
| dering_dir_param_t; |
| |
| class CDEFDeringDirTest : public ::testing::TestWithParam<dering_dir_param_t> { |
| public: |
| virtual ~CDEFDeringDirTest() {} |
| virtual void SetUp() { |
| dering = GET_PARAM(0); |
| ref_dering = GET_PARAM(1); |
| bsize = GET_PARAM(2); |
| } |
| |
| virtual void TearDown() { libaom_test::ClearSystemState(); } |
| |
| protected: |
| int bsize; |
| cdef_direction_func dering; |
| cdef_direction_func ref_dering; |
| }; |
| |
| typedef CDEFDeringDirTest CDEFDeringSpeedTest; |
| |
| void test_dering(int bsize, int iterations, cdef_direction_func dering, |
| cdef_direction_func ref_dering) { |
| const int size = 8; |
| const int ysize = size + 2 * CDEF_VBORDER; |
| ACMRandom rnd(ACMRandom::DeterministicSeed()); |
| DECLARE_ALIGNED(16, uint16_t, s[ysize * CDEF_BSTRIDE]); |
| DECLARE_ALIGNED(16, static uint16_t, d[size * size]); |
| DECLARE_ALIGNED(16, static uint16_t, ref_d[size * size]); |
| memset(ref_d, 0, sizeof(ref_d)); |
| memset(d, 0, sizeof(d)); |
| |
| int error = 0, threshold = 0, dir; |
| int boundary, damping, depth, bits, level, count, |
| errdepth = 0, errthreshold = 0, errboundary = 0, errdamping = 0; |
| unsigned int pos = 0; |
| |
| for (boundary = 0; boundary < 16; boundary++) { |
| for (depth = 8; depth <= 12; depth += 2) { |
| for (damping = 5 + depth - 8; damping < 7 + depth - 8; damping++) { |
| for (count = 0; count < iterations; count++) { |
| for (level = 0; level < (1 << depth) && !error; |
| level += (1 + 4 * !!boundary) << (depth - 8)) { |
| for (bits = 1; bits <= depth && !error; bits++) { |
| for (unsigned int i = 0; i < sizeof(s) / sizeof(*s); i++) |
| s[i] = clamp((rnd.Rand16() & ((1 << bits) - 1)) + level, 0, |
| (1 << depth) - 1); |
| if (boundary) { |
| if (boundary & 1) { // Left |
| for (int i = 0; i < ysize; i++) |
| for (int j = 0; j < CDEF_HBORDER; j++) |
| s[i * CDEF_BSTRIDE + j] = CDEF_VERY_LARGE; |
| } |
| if (boundary & 2) { // Right |
| for (int i = 0; i < ysize; i++) |
| for (int j = CDEF_HBORDER + size; j < CDEF_BSTRIDE; j++) |
| s[i * CDEF_BSTRIDE + j] = CDEF_VERY_LARGE; |
| } |
| if (boundary & 4) { // Above |
| for (int i = 0; i < CDEF_VBORDER; i++) |
| for (int j = 0; j < CDEF_BSTRIDE; j++) |
| s[i * CDEF_BSTRIDE + j] = CDEF_VERY_LARGE; |
| } |
| if (boundary & 8) { // Below |
| for (int i = CDEF_VBORDER + size; i < ysize; i++) |
| for (int j = 0; j < CDEF_BSTRIDE; j++) |
| s[i * CDEF_BSTRIDE + j] = CDEF_VERY_LARGE; |
| } |
| } |
| for (dir = 0; dir < 8; dir++) { |
| for (threshold = 0; threshold < 64 << (depth - 8) && !error; |
| threshold += (1 + 4 * !!boundary) << (depth - 8)) { |
| ref_dering(ref_d, size, |
| s + CDEF_HBORDER + CDEF_VBORDER * CDEF_BSTRIDE, |
| threshold, dir, damping); |
| // If dering and ref_dering are the same, we're just testing |
| // speed |
| if (dering != ref_dering) |
| ASM_REGISTER_STATE_CHECK(dering( |
| d, size, s + CDEF_HBORDER + CDEF_VBORDER * CDEF_BSTRIDE, |
| threshold, dir, damping)); |
| if (ref_dering != dering) { |
| for (pos = 0; pos < sizeof(d) / sizeof(*d) && !error; |
| pos++) { |
| error = ref_d[pos] != d[pos]; |
| errdepth = depth; |
| errthreshold = threshold; |
| errboundary = boundary; |
| errdamping = damping; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| pos--; |
| EXPECT_EQ(0, error) << "Error: CDEFDeringDirTest, SIMD and C mismatch." |
| << std::endl |
| << "First error at " << pos % size << "," << pos / size |
| << " (" << (int16_t)ref_d[pos] << " : " << (int16_t)d[pos] |
| << ") " << std::endl |
| << "threshold: " << errthreshold << std::endl |
| << "damping: " << errdamping << std::endl |
| << "depth: " << errdepth << std::endl |
| << "size: " << bsize << std::endl |
| << "boundary: " << errboundary << std::endl |
| << std::endl; |
| } |
| |
| void test_dering_speed(int bsize, int iterations, cdef_direction_func dering, |
| cdef_direction_func ref_dering) { |
| aom_usec_timer ref_timer; |
| aom_usec_timer timer; |
| |
| aom_usec_timer_start(&ref_timer); |
| test_dering(bsize, iterations, ref_dering, ref_dering); |
| aom_usec_timer_mark(&ref_timer); |
| int ref_elapsed_time = (int)aom_usec_timer_elapsed(&ref_timer); |
| |
| aom_usec_timer_start(&timer); |
| test_dering(bsize, iterations, dering, dering); |
| aom_usec_timer_mark(&timer); |
| int elapsed_time = (int)aom_usec_timer_elapsed(&timer); |
| |
| #if 0 |
| std::cout << "[ ] C time = " << ref_elapsed_time / 1000 |
| << " ms, SIMD time = " << elapsed_time / 1000 << " ms" << std::endl; |
| #endif |
| |
| EXPECT_GT(ref_elapsed_time, elapsed_time) |
| << "Error: CDEFDeringSpeedTest, SIMD slower than C." << std::endl |
| << "C time: " << ref_elapsed_time << " us" << std::endl |
| << "SIMD time: " << elapsed_time << " us" << std::endl; |
| } |
| |
| typedef int (*find_dir_t)(const uint16_t *img, int stride, int32_t *var, |
| int coeff_shift); |
| |
| typedef std::tr1::tuple<find_dir_t, find_dir_t> find_dir_param_t; |
| |
| class CDEFDeringFindDirTest |
| : public ::testing::TestWithParam<find_dir_param_t> { |
| public: |
| virtual ~CDEFDeringFindDirTest() {} |
| virtual void SetUp() { |
| finddir = GET_PARAM(0); |
| ref_finddir = GET_PARAM(1); |
| } |
| |
| virtual void TearDown() { libaom_test::ClearSystemState(); } |
| |
| protected: |
| find_dir_t finddir; |
| find_dir_t ref_finddir; |
| }; |
| |
| typedef CDEFDeringFindDirTest CDEFDeringFindDirSpeedTest; |
| |
| void test_finddir(int (*finddir)(const uint16_t *img, int stride, int32_t *var, |
| int coeff_shift), |
| int (*ref_finddir)(const uint16_t *img, int stride, |
| int32_t *var, int coeff_shift)) { |
| const int size = 8; |
| ACMRandom rnd(ACMRandom::DeterministicSeed()); |
| DECLARE_ALIGNED(16, uint16_t, s[size * size]); |
| |
| int error = 0; |
| int depth, bits, level, count, errdepth = 0; |
| int ref_res = 0, res = 0; |
| int32_t ref_var = 0, var = 0; |
| |
| for (depth = 8; depth <= 12 && !error; depth += 2) { |
| for (count = 0; count < 512 && !error; count++) { |
| for (level = 0; level < (1 << depth) && !error; |
| level += 1 << (depth - 8)) { |
| for (bits = 1; bits <= depth && !error; bits++) { |
| for (unsigned int i = 0; i < sizeof(s) / sizeof(*s); i++) |
| s[i] = clamp((rnd.Rand16() & ((1 << bits) - 1)) + level, 0, |
| (1 << depth) - 1); |
| for (int c = 0; c < 1 + 9 * (finddir == ref_finddir); c++) |
| ref_res = ref_finddir(s, size, &ref_var, depth - 8); |
| if (finddir != ref_finddir) |
| ASM_REGISTER_STATE_CHECK(res = finddir(s, size, &var, depth - 8)); |
| if (ref_finddir != finddir) { |
| if (res != ref_res || var != ref_var) error = 1; |
| errdepth = depth; |
| } |
| } |
| } |
| } |
| } |
| |
| EXPECT_EQ(0, error) << "Error: CDEFDeringFindDirTest, SIMD and C mismatch." |
| << std::endl |
| << "return: " << res << " : " << ref_res << std::endl |
| << "var: " << var << " : " << ref_var << std::endl |
| << "depth: " << errdepth << std::endl |
| << std::endl; |
| } |
| |
| void test_finddir_speed(int (*finddir)(const uint16_t *img, int stride, |
| int32_t *var, int coeff_shift), |
| int (*ref_finddir)(const uint16_t *img, int stride, |
| int32_t *var, int coeff_shift)) { |
| aom_usec_timer ref_timer; |
| aom_usec_timer timer; |
| |
| aom_usec_timer_start(&ref_timer); |
| test_finddir(ref_finddir, ref_finddir); |
| aom_usec_timer_mark(&ref_timer); |
| int ref_elapsed_time = (int)aom_usec_timer_elapsed(&ref_timer); |
| |
| aom_usec_timer_start(&timer); |
| test_finddir(finddir, finddir); |
| aom_usec_timer_mark(&timer); |
| int elapsed_time = (int)aom_usec_timer_elapsed(&timer); |
| |
| #if 0 |
| std::cout << "[ ] C time = " << ref_elapsed_time / 1000 |
| << " ms, SIMD time = " << elapsed_time / 1000 << " ms" << std::endl; |
| #endif |
| |
| EXPECT_GT(ref_elapsed_time, elapsed_time) |
| << "Error: CDEFDeringFindDirSpeedTest, SIMD slower than C." << std::endl |
| << "C time: " << ref_elapsed_time << " us" << std::endl |
| << "SIMD time: " << elapsed_time << " us" << std::endl; |
| } |
| |
| TEST_P(CDEFDeringDirTest, TestSIMDNoMismatch) { |
| test_dering(bsize, 1, dering, ref_dering); |
| } |
| |
| TEST_P(CDEFDeringSpeedTest, DISABLED_TestSpeed) { |
| test_dering_speed(bsize, 4, dering, ref_dering); |
| } |
| |
| TEST_P(CDEFDeringFindDirTest, TestSIMDNoMismatch) { |
| test_finddir(finddir, ref_finddir); |
| } |
| |
| TEST_P(CDEFDeringFindDirSpeedTest, DISABLED_TestSpeed) { |
| test_finddir_speed(finddir, ref_finddir); |
| } |
| |
| using std::tr1::make_tuple; |
| |
| // VS compiling for 32 bit targets does not support vector types in |
| // structs as arguments, which makes the v256 type of the intrinsics |
| // hard to support, so optimizations for this target are disabled. |
| #if defined(_WIN64) || !defined(_MSC_VER) || defined(__clang__) |
| #if HAVE_SSE2 |
| INSTANTIATE_TEST_CASE_P(SSE2, CDEFDeringDirTest, |
| ::testing::Values(make_tuple(&cdef_direction_4x4_sse2, |
| &cdef_direction_4x4_c, 4), |
| make_tuple(&cdef_direction_8x8_sse2, |
| &cdef_direction_8x8_c, |
| 8))); |
| INSTANTIATE_TEST_CASE_P(SSE2, CDEFDeringFindDirTest, |
| ::testing::Values(make_tuple(&cdef_find_dir_sse2, |
| &cdef_find_dir_c))); |
| #endif |
| #if HAVE_SSSE3 |
| INSTANTIATE_TEST_CASE_P(SSSE3, CDEFDeringDirTest, |
| ::testing::Values(make_tuple(&cdef_direction_4x4_ssse3, |
| &cdef_direction_4x4_c, 4), |
| make_tuple(&cdef_direction_8x8_ssse3, |
| &cdef_direction_8x8_c, |
| 8))); |
| INSTANTIATE_TEST_CASE_P(SSSE3, CDEFDeringFindDirTest, |
| ::testing::Values(make_tuple(&cdef_find_dir_ssse3, |
| &cdef_find_dir_c))); |
| #endif |
| |
| #if HAVE_SSE4_1 |
| INSTANTIATE_TEST_CASE_P(SSE4_1, CDEFDeringDirTest, |
| ::testing::Values(make_tuple(&cdef_direction_4x4_sse4_1, |
| &cdef_direction_4x4_c, 4), |
| make_tuple(&cdef_direction_8x8_sse4_1, |
| &cdef_direction_8x8_c, |
| 8))); |
| INSTANTIATE_TEST_CASE_P(SSE4_1, CDEFDeringFindDirTest, |
| ::testing::Values(make_tuple(&cdef_find_dir_sse4_1, |
| &cdef_find_dir_c))); |
| #endif |
| |
| #if HAVE_NEON |
| INSTANTIATE_TEST_CASE_P(NEON, CDEFDeringDirTest, |
| ::testing::Values(make_tuple(&cdef_direction_4x4_neon, |
| &cdef_direction_4x4_c, 4), |
| make_tuple(&cdef_direction_8x8_neon, |
| &cdef_direction_8x8_c, |
| 8))); |
| INSTANTIATE_TEST_CASE_P(NEON, CDEFDeringFindDirTest, |
| ::testing::Values(make_tuple(&cdef_find_dir_neon, |
| &cdef_find_dir_c))); |
| #endif |
| |
| // Test speed for all supported architectures |
| #if HAVE_SSE2 |
| INSTANTIATE_TEST_CASE_P(SSE2, CDEFDeringSpeedTest, |
| ::testing::Values(make_tuple(&cdef_direction_4x4_sse2, |
| &cdef_direction_4x4_c, 4), |
| make_tuple(&cdef_direction_8x8_sse2, |
| &cdef_direction_8x8_c, |
| 8))); |
| INSTANTIATE_TEST_CASE_P(SSE2, CDEFDeringFindDirSpeedTest, |
| ::testing::Values(make_tuple(&cdef_find_dir_sse2, |
| &cdef_find_dir_c))); |
| #endif |
| |
| #if HAVE_SSSE3 |
| INSTANTIATE_TEST_CASE_P(SSSE3, CDEFDeringSpeedTest, |
| ::testing::Values(make_tuple(&cdef_direction_4x4_ssse3, |
| &cdef_direction_4x4_c, 4), |
| make_tuple(&cdef_direction_8x8_ssse3, |
| &cdef_direction_8x8_c, |
| 8))); |
| INSTANTIATE_TEST_CASE_P(SSSE3, CDEFDeringFindDirSpeedTest, |
| ::testing::Values(make_tuple(&cdef_find_dir_ssse3, |
| &cdef_find_dir_c))); |
| #endif |
| |
| #if HAVE_SSE4_1 |
| INSTANTIATE_TEST_CASE_P(SSE4_1, CDEFDeringSpeedTest, |
| ::testing::Values(make_tuple(&cdef_direction_4x4_sse4_1, |
| &cdef_direction_4x4_c, 4), |
| make_tuple(&cdef_direction_8x8_sse4_1, |
| &cdef_direction_8x8_c, |
| 8))); |
| INSTANTIATE_TEST_CASE_P(SSE4_1, CDEFDeringFindDirSpeedTest, |
| ::testing::Values(make_tuple(&cdef_find_dir_sse4_1, |
| &cdef_find_dir_c))); |
| #endif |
| |
| #if HAVE_NEON |
| INSTANTIATE_TEST_CASE_P(NEON, CDEFDeringSpeedTest, |
| ::testing::Values(make_tuple(&cdef_direction_4x4_neon, |
| &cdef_direction_4x4_c, 4), |
| make_tuple(&cdef_direction_8x8_neon, |
| &cdef_direction_8x8_c, |
| 8))); |
| INSTANTIATE_TEST_CASE_P(NEON, CDEFDeringFindDirSpeedTest, |
| ::testing::Values(make_tuple(&cdef_find_dir_neon, |
| &cdef_find_dir_c))); |
| #endif |
| |
| #endif // defined(_WIN64) || !defined(_MSC_VER) |
| } // namespace |
