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
16 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
17
18 #include "config/aom_config.h"
19 #include "config/aom_dsp_rtcd.h"
20
21 #include "aom_ports/mem.h"
22 #include "test/acm_random.h"
23 #include "test/clear_system_state.h"
24 #include "test/register_state_check.h"
25 #include "test/util.h"
26 #include "test/function_equivalence_test.h"
27
28 using libaom_test::ACMRandom;
29 using libaom_test::FunctionEquivalenceTest;
30 using ::testing::Combine;
31 using ::testing::Range;
32 using ::testing::Values;
33 using ::testing::ValuesIn;
34
35 namespace {
36 const int kNumIterations = 10000;
37
38 static const int16_t kInt13Max = (1 << 12) - 1;
39
40 typedef uint64_t (*SSI16Func)(const int16_t *src, int stride, int width,
41 int height);
42 typedef libaom_test::FuncParam<SSI16Func> TestFuncs;
43
44 class SumSquaresTest : public ::testing::TestWithParam<TestFuncs> {
45 public:
~SumSquaresTest()46 virtual ~SumSquaresTest() {}
SetUp()47 virtual void SetUp() {
48 params_ = this->GetParam();
49 rnd_.Reset(ACMRandom::DeterministicSeed());
50 src_ = reinterpret_cast<int16_t *>(aom_memalign(16, 256 * 256 * 2));
51 ASSERT_TRUE(src_ != NULL);
52 }
53
TearDown()54 virtual void TearDown() {
55 libaom_test::ClearSystemState();
56 aom_free(src_);
57 }
58 void RunTest(int isRandom);
59 void RunSpeedTest();
60
GenRandomData(int width,int height,int stride)61 void GenRandomData(int width, int height, int stride) {
62 const int msb = 11; // Up to 12 bit input
63 const int limit = 1 << (msb + 1);
64 for (int ii = 0; ii < height; ii++) {
65 for (int jj = 0; jj < width; jj++) {
66 src_[ii * stride + jj] = rnd_(2) ? rnd_(limit) : -rnd_(limit);
67 }
68 }
69 }
70
GenExtremeData(int width,int height,int stride)71 void GenExtremeData(int width, int height, int stride) {
72 const int msb = 11; // Up to 12 bit input
73 const int limit = 1 << (msb + 1);
74 const int val = rnd_(2) ? limit - 1 : -(limit - 1);
75 for (int ii = 0; ii < height; ii++) {
76 for (int jj = 0; jj < width; jj++) {
77 src_[ii * stride + jj] = val;
78 }
79 }
80 }
81
82 protected:
83 TestFuncs params_;
84 int16_t *src_;
85 ACMRandom rnd_;
86 };
87
RunTest(int isRandom)88 void SumSquaresTest::RunTest(int isRandom) {
89 int failed = 0;
90 for (int k = 0; k < kNumIterations; k++) {
91 const int width = 4 * (rnd_(31) + 1); // Up to 128x128
92 const int height = 4 * (rnd_(31) + 1); // Up to 128x128
93 int stride = 4 << rnd_(7); // Up to 256 stride
94 while (stride < width) { // Make sure it's valid
95 stride = 4 << rnd_(7);
96 }
97 if (isRandom) {
98 GenRandomData(width, height, stride);
99 } else {
100 GenExtremeData(width, height, stride);
101 }
102 const uint64_t res_ref = params_.ref_func(src_, stride, width, height);
103 uint64_t res_tst;
104 ASM_REGISTER_STATE_CHECK(res_tst =
105 params_.tst_func(src_, stride, width, height));
106
107 if (!failed) {
108 failed = res_ref != res_tst;
109 EXPECT_EQ(res_ref, res_tst)
110 << "Error: Sum Squares Test [" << width << "x" << height
111 << "] C output does not match optimized output.";
112 }
113 }
114 }
115
RunSpeedTest()116 void SumSquaresTest::RunSpeedTest() {
117 for (int block = BLOCK_4X4; block < BLOCK_SIZES_ALL; block++) {
118 const int width = block_size_wide[block]; // Up to 128x128
119 const int height = block_size_high[block]; // Up to 128x128
120 int stride = 4 << rnd_(7); // Up to 256 stride
121 while (stride < width) { // Make sure it's valid
122 stride = 4 << rnd_(7);
123 }
124 GenExtremeData(width, height, stride);
125 const int num_loops = 1000000000 / (width + height);
126 aom_usec_timer timer;
127 aom_usec_timer_start(&timer);
128
129 for (int i = 0; i < num_loops; ++i)
130 params_.ref_func(src_, stride, width, height);
131
132 aom_usec_timer_mark(&timer);
133 const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
134 printf("SumSquaresTest C %3dx%-3d: %7.2f ns\n", width, height,
135 1000.0 * elapsed_time / num_loops);
136
137 aom_usec_timer timer1;
138 aom_usec_timer_start(&timer1);
139 for (int i = 0; i < num_loops; ++i)
140 params_.tst_func(src_, stride, width, height);
141 aom_usec_timer_mark(&timer1);
142 const int elapsed_time1 = static_cast<int>(aom_usec_timer_elapsed(&timer1));
143 printf("SumSquaresTest Test %3dx%-3d: %7.2f ns\n", width, height,
144 1000.0 * elapsed_time1 / num_loops);
145 }
146 }
147
TEST_P(SumSquaresTest,OperationCheck)148 TEST_P(SumSquaresTest, OperationCheck) {
149 RunTest(1); // GenRandomData
150 }
151
TEST_P(SumSquaresTest,ExtremeValues)152 TEST_P(SumSquaresTest, ExtremeValues) {
153 RunTest(0); // GenExtremeData
154 }
155
TEST_P(SumSquaresTest,DISABLED_Speed)156 TEST_P(SumSquaresTest, DISABLED_Speed) { RunSpeedTest(); }
157
158 #if HAVE_SSE2
159
160 INSTANTIATE_TEST_CASE_P(
161 SSE2, SumSquaresTest,
162 ::testing::Values(TestFuncs(&aom_sum_squares_2d_i16_c,
163 &aom_sum_squares_2d_i16_sse2)));
164
165 #endif // HAVE_SSE2
166
167 #if HAVE_AVX2
168 INSTANTIATE_TEST_CASE_P(
169 AVX2, SumSquaresTest,
170 ::testing::Values(TestFuncs(&aom_sum_squares_2d_i16_c,
171 &aom_sum_squares_2d_i16_avx2)));
172 #endif // HAVE_AVX2
173
174 //////////////////////////////////////////////////////////////////////////////
175 // 1D version
176 //////////////////////////////////////////////////////////////////////////////
177
178 typedef uint64_t (*F1D)(const int16_t *src, uint32_t N);
179 typedef libaom_test::FuncParam<F1D> TestFuncs1D;
180
181 class SumSquares1DTest : public FunctionEquivalenceTest<F1D> {
182 protected:
183 static const int kIterations = 1000;
184 static const int kMaxSize = 256;
185 };
186
TEST_P(SumSquares1DTest,RandomValues)187 TEST_P(SumSquares1DTest, RandomValues) {
188 DECLARE_ALIGNED(16, int16_t, src[kMaxSize * kMaxSize]);
189
190 for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
191 for (int i = 0; i < kMaxSize * kMaxSize; ++i)
192 src[i] = rng_(kInt13Max * 2 + 1) - kInt13Max;
193
194 const int N = rng_(2) ? rng_(kMaxSize * kMaxSize + 1 - kMaxSize) + kMaxSize
195 : rng_(kMaxSize) + 1;
196
197 const uint64_t ref_res = params_.ref_func(src, N);
198 uint64_t tst_res;
199 ASM_REGISTER_STATE_CHECK(tst_res = params_.tst_func(src, N));
200
201 ASSERT_EQ(ref_res, tst_res);
202 }
203 }
204
TEST_P(SumSquares1DTest,ExtremeValues)205 TEST_P(SumSquares1DTest, ExtremeValues) {
206 DECLARE_ALIGNED(16, int16_t, src[kMaxSize * kMaxSize]);
207
208 for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
209 if (rng_(2)) {
210 for (int i = 0; i < kMaxSize * kMaxSize; ++i) src[i] = kInt13Max;
211 } else {
212 for (int i = 0; i < kMaxSize * kMaxSize; ++i) src[i] = -kInt13Max;
213 }
214
215 const int N = rng_(2) ? rng_(kMaxSize * kMaxSize + 1 - kMaxSize) + kMaxSize
216 : rng_(kMaxSize) + 1;
217
218 const uint64_t ref_res = params_.ref_func(src, N);
219 uint64_t tst_res;
220 ASM_REGISTER_STATE_CHECK(tst_res = params_.tst_func(src, N));
221
222 ASSERT_EQ(ref_res, tst_res);
223 }
224 }
225
226 #if HAVE_SSE2
227 INSTANTIATE_TEST_CASE_P(SSE2, SumSquares1DTest,
228 ::testing::Values(TestFuncs1D(
229 aom_sum_squares_i16_c, aom_sum_squares_i16_sse2)));
230
231 #endif // HAVE_SSE2
232
233 typedef int64_t (*sse_func)(const uint8_t *a, int a_stride, const uint8_t *b,
234 int b_stride, int width, int height);
235 typedef libaom_test::FuncParam<sse_func> TestSSEFuncs;
236
237 typedef ::testing::tuple<TestSSEFuncs, int> SSETestParam;
238
239 class SSETest : public ::testing::TestWithParam<SSETestParam> {
240 public:
~SSETest()241 virtual ~SSETest() {}
SetUp()242 virtual void SetUp() {
243 params_ = GET_PARAM(0);
244 width_ = GET_PARAM(1);
245 isHbd_ = params_.ref_func == aom_highbd_sse_c;
246 rnd_.Reset(ACMRandom::DeterministicSeed());
247 src_ = reinterpret_cast<uint8_t *>(aom_memalign(32, 256 * 256 * 2));
248 ref_ = reinterpret_cast<uint8_t *>(aom_memalign(32, 256 * 256 * 2));
249 ASSERT_TRUE(src_ != NULL);
250 ASSERT_TRUE(ref_ != NULL);
251 }
252
TearDown()253 virtual void TearDown() {
254 libaom_test::ClearSystemState();
255 aom_free(src_);
256 aom_free(ref_);
257 }
258 void RunTest(int isRandom, int width, int height, int run_times);
259
GenRandomData(int width,int height,int stride)260 void GenRandomData(int width, int height, int stride) {
261 uint16_t *pSrc = (uint16_t *)src_;
262 uint16_t *pRef = (uint16_t *)ref_;
263 const int msb = 11; // Up to 12 bit input
264 const int limit = 1 << (msb + 1);
265 for (int ii = 0; ii < height; ii++) {
266 for (int jj = 0; jj < width; jj++) {
267 if (!isHbd_) {
268 src_[ii * stride + jj] = rnd_.Rand8();
269 ref_[ii * stride + jj] = rnd_.Rand8();
270 } else {
271 pSrc[ii * stride + jj] = rnd_(limit);
272 pRef[ii * stride + jj] = rnd_(limit);
273 }
274 }
275 }
276 }
277
GenExtremeData(int width,int height,int stride,uint8_t * data,int16_t val)278 void GenExtremeData(int width, int height, int stride, uint8_t *data,
279 int16_t val) {
280 uint16_t *pData = (uint16_t *)data;
281 for (int ii = 0; ii < height; ii++) {
282 for (int jj = 0; jj < width; jj++) {
283 if (!isHbd_) {
284 data[ii * stride + jj] = (uint8_t)val;
285 } else {
286 pData[ii * stride + jj] = val;
287 }
288 }
289 }
290 }
291
292 protected:
293 int isHbd_;
294 int width_;
295 TestSSEFuncs params_;
296 uint8_t *src_;
297 uint8_t *ref_;
298 ACMRandom rnd_;
299 };
300
RunTest(int isRandom,int width,int height,int run_times)301 void SSETest::RunTest(int isRandom, int width, int height, int run_times) {
302 int failed = 0;
303 aom_usec_timer ref_timer, test_timer;
304 for (int k = 0; k < 3; k++) {
305 int stride = 4 << rnd_(7); // Up to 256 stride
306 while (stride < width) { // Make sure it's valid
307 stride = 4 << rnd_(7);
308 }
309 if (isRandom) {
310 GenRandomData(width, height, stride);
311 } else {
312 const int msb = isHbd_ ? 12 : 8; // Up to 12 bit input
313 const int limit = (1 << msb) - 1;
314 if (k == 0) {
315 GenExtremeData(width, height, stride, src_, 0);
316 GenExtremeData(width, height, stride, ref_, limit);
317 } else {
318 GenExtremeData(width, height, stride, src_, limit);
319 GenExtremeData(width, height, stride, ref_, 0);
320 }
321 }
322 int64_t res_ref, res_tst;
323 uint8_t *pSrc = src_;
324 uint8_t *pRef = ref_;
325 if (isHbd_) {
326 pSrc = CONVERT_TO_BYTEPTR(src_);
327 pRef = CONVERT_TO_BYTEPTR(ref_);
328 }
329 res_ref = params_.ref_func(pSrc, stride, pRef, stride, width, height);
330 res_tst = params_.tst_func(pSrc, stride, pRef, stride, width, height);
331 if (run_times > 1) {
332 aom_usec_timer_start(&ref_timer);
333 for (int j = 0; j < run_times; j++) {
334 params_.ref_func(pSrc, stride, pRef, stride, width, height);
335 }
336 aom_usec_timer_mark(&ref_timer);
337 const int elapsed_time_c =
338 static_cast<int>(aom_usec_timer_elapsed(&ref_timer));
339
340 aom_usec_timer_start(&test_timer);
341 for (int j = 0; j < run_times; j++) {
342 params_.tst_func(pSrc, stride, pRef, stride, width, height);
343 }
344 aom_usec_timer_mark(&test_timer);
345 const int elapsed_time_simd =
346 static_cast<int>(aom_usec_timer_elapsed(&test_timer));
347
348 printf(
349 "c_time=%d \t simd_time=%d \t "
350 "gain=%d\n",
351 elapsed_time_c, elapsed_time_simd,
352 (elapsed_time_c / elapsed_time_simd));
353 } else {
354 if (!failed) {
355 failed = res_ref != res_tst;
356 EXPECT_EQ(res_ref, res_tst)
357 << "Error:" << (isHbd_ ? "hbd " : " ") << k << " SSE Test ["
358 << width << "x" << height
359 << "] C output does not match optimized output.";
360 }
361 }
362 }
363 }
364
TEST_P(SSETest,OperationCheck)365 TEST_P(SSETest, OperationCheck) {
366 for (int height = 4; height <= 128; height += 4) {
367 RunTest(1, width_, height, 1); // GenRandomData
368 }
369 }
370
TEST_P(SSETest,ExtremeValues)371 TEST_P(SSETest, ExtremeValues) {
372 for (int height = 4; height <= 128; height += 4) {
373 RunTest(0, width_, height, 1);
374 }
375 }
376
TEST_P(SSETest,DISABLED_Speed)377 TEST_P(SSETest, DISABLED_Speed) {
378 for (int height = 4; height <= 128; height += 4) {
379 RunTest(1, width_, height, 100);
380 }
381 }
382 #if HAVE_SSE4_1
383 TestSSEFuncs sse_sse4[] = { TestSSEFuncs(&aom_sse_c, &aom_sse_sse4_1),
384 TestSSEFuncs(&aom_highbd_sse_c,
385 &aom_highbd_sse_sse4_1) };
386 INSTANTIATE_TEST_CASE_P(SSE4_1, SSETest,
387 Combine(ValuesIn(sse_sse4), Range(4, 129, 4)));
388 #endif // HAVE_SSE4_1
389
390 #if HAVE_AVX2
391
392 TestSSEFuncs sse_avx2[] = { TestSSEFuncs(&aom_sse_c, &aom_sse_avx2),
393 TestSSEFuncs(&aom_highbd_sse_c,
394 &aom_highbd_sse_avx2) };
395 INSTANTIATE_TEST_CASE_P(AVX2, SSETest,
396 Combine(ValuesIn(sse_avx2), Range(4, 129, 4)));
397 #endif // HAVE_AVX2
398 } // namespace
399