Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / XNNPACK / refs/heads/odm/rc/qssi/12/fp4 / . / test / average-pooling-nhwc.cc
blob: 345e0746ac8242aec37feacee94704c8978d4e52 [file] [log] [blame]
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1// Copyright (c) Facebook, Inc. and its affiliates.
2// All rights reserved.
3//
4// Copyright 2019 Google LLC
5//
6// This source code is licensed under the BSD-style license found in the
7// LICENSE file in the root directory of this source tree.
8
9#include <gtest/gtest.h>
10
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]11#include <utility>
12
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]13#include <xnnpack/params.h>
14
15#include "average-pooling-operator-tester.h"
16
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]17static std::pair<size_t, size_t> SmallPoolSize(size_t max_elements) {
18 const size_t small_side = size_t(std::floor(std::sqrt(double(max_elements))));
19 const size_t large_side = small_side + 1;
20 if (small_side * large_side < max_elements) {
21 return std::make_pair(small_side, large_side);
22 } else {
23 return std::make_pair(small_side - 1, large_side - 1);
24 }
25}
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]26
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]27static std::pair<size_t, size_t> LargePoolSize(size_t min_elements) {
28 const size_t small_side = size_t(std::ceil(std::sqrt(double(min_elements))));
29 return std::make_pair(small_side, small_side + 1);
30}
31
32/**************************** AVGPOOL path, unipass ****************************/
33
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]34TEST(AVERAGE_POOLING_NHWC_QU8, small_pool) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]35 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]36 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]37 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]38 AveragePoolingOperatorTester()
39 .input_height(pooling_size.first + 3)
40 .input_width(pooling_size.second + 2)
41 .pooling_height(pooling_size.first)
42 .pooling_width(pooling_size.second)
43 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]44 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]45 AveragePoolingOperatorTester()
46 .input_height(pooling_size.second + 3)
47 .input_width(pooling_size.first + 2)
48 .pooling_height(pooling_size.second)
49 .pooling_width(pooling_size.first)
50 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]51 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]52 }
53}
54
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]55TEST(AVERAGE_POOLING_NHWC_QU8, small_pool_with_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]56 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]57 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]58 for (size_t channels = 1; channels <= 100; channels += 15) {
59 for (size_t stride_width = 1; stride_width <= 2; stride_width++) {
60 for (size_t stride_height = 1; stride_height <= 2; stride_height++) {
61 if (stride_width == 1 && stride_height == 1) {
62 continue;
63 }
64
65 AveragePoolingOperatorTester()
66 .input_height(pooling_size.first + 3)
67 .input_width(pooling_size.second + 2)
68 .pooling_height(pooling_size.first)
69 .pooling_width(pooling_size.second)
70 .stride_height(stride_height)
71 .stride_width(stride_width)
72 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]73 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]74 AveragePoolingOperatorTester()
75 .input_height(pooling_size.second + 3)
76 .input_width(pooling_size.first + 2)
77 .pooling_height(pooling_size.second)
78 .pooling_width(pooling_size.first)
79 .stride_height(stride_height)
80 .stride_width(stride_width)
81 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]82 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]83 }
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]84 }
85 }
86}
87
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]88TEST(AVERAGE_POOLING_NHWC_QU8, small_pool_with_width_padding) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]89 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]90 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]91 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]92 for (size_t stride = 1; stride <= 2; stride++) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]93 for (size_t padding_left = 0; padding_left <= 1; padding_left++) {
94 for (size_t padding_right = 0; padding_right <= 1; padding_right++) {
95 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]96 .input_height(pooling_size.first + 3)
97 .input_width(pooling_size.second + 2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]98 .padding_left(padding_left)
99 .padding_right(padding_right)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]100 .pooling_height(pooling_size.first)
101 .pooling_width(pooling_size.second)
102 .stride(stride)
103 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]104 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]105 AveragePoolingOperatorTester()
106 .input_height(pooling_size.second + 3)
107 .input_width(pooling_size.first + 2)
108 .padding_left(padding_left)
109 .padding_right(padding_right)
110 .pooling_height(pooling_size.second)
111 .pooling_width(pooling_size.first)
112 .stride(stride)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]113 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]114 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]115 }
116 }
117 }
118 }
119}
120
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]121TEST(AVERAGE_POOLING_NHWC_QU8, small_pool_with_height_padding) {
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]122 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]123 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]124 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]125 for (size_t stride = 1; stride <= 2; stride++) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]126 for (size_t padding_top = 0; padding_top <= 1; padding_top++) {
127 for (size_t padding_bottom = 0; padding_bottom <= 1; padding_bottom++) {
128 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]129 .input_height(pooling_size.first + 3)
130 .input_width(pooling_size.second + 2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]131 .padding_top(padding_top)
132 .padding_bottom(padding_bottom)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]133 .pooling_height(pooling_size.first)
134 .pooling_width(pooling_size.second)
135 .stride(stride)
136 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]137 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]138 AveragePoolingOperatorTester()
139 .input_height(pooling_size.second + 3)
140 .input_width(pooling_size.first + 2)
141 .padding_top(padding_top)
142 .padding_bottom(padding_bottom)
143 .pooling_height(pooling_size.second)
144 .pooling_width(pooling_size.first)
145 .stride(stride)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]146 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]147 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]148 }
149 }
150 }
151 }
152}
153
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]154TEST(AVERAGE_POOLING_NHWC_QU8, small_pool_with_tf_same_padding) {
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]155 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]156 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]157 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]158 for (size_t stride = 1; stride <= 2; stride++) {
159 for (size_t input_height = pooling_size.first + 3; input_height <= pooling_size.first + 4; input_height++) {
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]160 AveragePoolingOperatorTester()
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]161 .input_height(input_height)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]162 .input_width(pooling_size.second + 2)
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]163 .padding_tf_same(true)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]164 .pooling_height(pooling_size.first)
165 .pooling_width(pooling_size.second)
166 .stride(stride)
167 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]168 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]169 }
170 for (size_t input_width = pooling_size.second + 2; input_width <= pooling_size.second + 3; input_width++) {
171 AveragePoolingOperatorTester()
172 .input_height(pooling_size.first + 3)
173 .input_width(input_width)
174 .padding_tf_same(true)
175 .pooling_height(pooling_size.first)
176 .pooling_width(pooling_size.second)
177 .stride(stride)
178 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]179 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]180 }
181 for (size_t input_height = pooling_size.second + 3; input_height <= pooling_size.second + 4; input_height++) {
182 AveragePoolingOperatorTester()
183 .input_height(input_height)
184 .input_width(pooling_size.first + 2)
185 .padding_tf_same(true)
186 .pooling_height(pooling_size.second)
187 .pooling_width(pooling_size.first)
188 .stride(stride)
189 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]190 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]191 }
192 for (size_t input_width = pooling_size.first + 2; input_width <= pooling_size.first + 3; input_width++) {
193 AveragePoolingOperatorTester()
194 .input_height(pooling_size.second + 3)
195 .input_width(input_width)
196 .padding_tf_same(true)
197 .pooling_height(pooling_size.second)
198 .pooling_width(pooling_size.first)
199 .stride(stride)
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]200 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]201 .TestQU8();
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]202 }
203 }
204 }
205}
206
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]207TEST(AVERAGE_POOLING_NHWC_QU8, small_pool_with_input_stride) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]208 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]209 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]210 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]211 AveragePoolingOperatorTester()
212 .input_height(pooling_size.first + 3)
213 .input_width(pooling_size.second + 2)
214 .pooling_height(pooling_size.first)
215 .pooling_width(pooling_size.second)
216 .channels(channels)
217 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]218 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]219 AveragePoolingOperatorTester()
220 .input_height(pooling_size.second + 3)
221 .input_width(pooling_size.first + 2)
222 .pooling_height(pooling_size.second)
223 .pooling_width(pooling_size.first)
224 .channels(channels)
225 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]226 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]227 }
228}
229
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]230TEST(AVERAGE_POOLING_NHWC_QU8, small_pool_with_output_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]231 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]232 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]233 for (size_t channels = 1; channels <= 100; channels += 15) {
234 AveragePoolingOperatorTester()
235 .input_height(pooling_size.first + 3)
236 .input_width(pooling_size.second + 2)
237 .pooling_height(pooling_size.first)
238 .pooling_width(pooling_size.second)
239 .channels(channels)
240 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]241 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]242 AveragePoolingOperatorTester()
243 .input_height(pooling_size.second + 3)
244 .input_width(pooling_size.first + 2)
245 .pooling_height(pooling_size.second)
246 .pooling_width(pooling_size.first)
247 .channels(channels)
248 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]249 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]250 }
251}
252
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]253TEST(AVERAGE_POOLING_NHWC_QU8, small_pool_with_input_scale) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]254 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]255 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]256 for (size_t channels = 1; channels <= 100; channels += 15) {
257 for (float input_scale = 0.01f; input_scale < 100.0f; input_scale *= 3.14159265f) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]258 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]259 .input_height(pooling_size.first + 3)
260 .input_width(pooling_size.second + 2)
261 .pooling_height(pooling_size.first)
262 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]263 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]264 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]265 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]266 AveragePoolingOperatorTester()
267 .input_height(pooling_size.second + 3)
268 .input_width(pooling_size.first + 2)
269 .pooling_height(pooling_size.second)
270 .pooling_width(pooling_size.first)
271 .channels(channels)
272 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]273 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]274 }
275 }
276}
277
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]278TEST(AVERAGE_POOLING_NHWC_QU8, small_pool_with_input_zero_point) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]279 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]280 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]281 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]282 for (int32_t input_zero_point = 0; input_zero_point <= 255; input_zero_point += 51) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]283 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]284 .input_height(pooling_size.first + 3)
285 .input_width(pooling_size.second + 2)
286 .pooling_height(pooling_size.first)
287 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]288 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]289 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]290 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]291 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]292 .input_height(pooling_size.second + 3)
293 .input_width(pooling_size.first + 2)
294 .pooling_height(pooling_size.second)
295 .pooling_width(pooling_size.first)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]296 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]297 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]298 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]299 }
300 }
301}
302
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]303TEST(AVERAGE_POOLING_NHWC_QU8, small_pool_with_output_scale) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]304 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]305 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]306 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]307 for (float output_scale = 0.01f; output_scale < 100.0f; output_scale *= 3.14159265f) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]308 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]309 .input_height(pooling_size.first + 3)
310 .input_width(pooling_size.second + 2)
311 .pooling_height(pooling_size.first)
312 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]313 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]314 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]315 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]316 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]317 .input_height(pooling_size.second + 3)
318 .input_width(pooling_size.first + 2)
319 .pooling_height(pooling_size.second)
320 .pooling_width(pooling_size.first)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]321 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]322 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]323 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]324 }
325 }
326}
327
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]328TEST(AVERAGE_POOLING_NHWC_QU8, small_pool_with_output_zero_point) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]329 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]330 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]331 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]332 for (int32_t output_zero_point = 0; output_zero_point <= 255; output_zero_point += 51) {
333 AveragePoolingOperatorTester()
334 .input_height(pooling_size.first + 3)
335 .input_width(pooling_size.second + 2)
336 .pooling_height(pooling_size.first)
337 .pooling_width(pooling_size.second)
338 .channels(channels)
339 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]340 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]341 AveragePoolingOperatorTester()
342 .input_height(pooling_size.second + 3)
343 .input_width(pooling_size.first + 2)
344 .pooling_height(pooling_size.second)
345 .pooling_width(pooling_size.first)
346 .channels(channels)
347 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]348 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]349 }
350 }
351}
352
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]353TEST(AVERAGE_POOLING_NHWC_QU8, small_pool_with_qmin) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]354 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]355 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]356 for (size_t channels = 1; channels <= 100; channels += 15) {
357 AveragePoolingOperatorTester()
358 .input_height(pooling_size.first + 3)
359 .input_width(pooling_size.second + 2)
360 .pooling_height(pooling_size.first)
361 .pooling_width(pooling_size.second)
362 .channels(channels)
363 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]364 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]365 AveragePoolingOperatorTester()
366 .input_height(pooling_size.second + 3)
367 .input_width(pooling_size.first + 2)
368 .pooling_height(pooling_size.second)
369 .pooling_width(pooling_size.first)
370 .channels(channels)
371 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]372 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]373 }
374}
375
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]376TEST(AVERAGE_POOLING_NHWC_QU8, small_pool_with_qmax) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]377 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]378 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]379 for (size_t channels = 1; channels <= 100; channels += 15) {
380 AveragePoolingOperatorTester()
381 .input_height(pooling_size.first + 3)
382 .input_width(pooling_size.second + 2)
383 .pooling_height(pooling_size.first)
384 .pooling_width(pooling_size.second)
385 .channels(channels)
386 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]387 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]388 AveragePoolingOperatorTester()
389 .input_height(pooling_size.second + 3)
390 .input_width(pooling_size.first + 2)
391 .pooling_height(pooling_size.second)
392 .pooling_width(pooling_size.first)
393 .channels(channels)
394 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]395 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]396 }
397}
398
399/**************************** AVGPOOL path, unipass, batched ****************************/
400
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]401TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]402 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]403 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]404 for (size_t channels = 1; channels <= 100; channels += 15) {
405 AveragePoolingOperatorTester()
406 .batch_size(2)
407 .input_height(pooling_size.first + 3)
408 .input_width(pooling_size.second + 2)
409 .pooling_height(pooling_size.first)
410 .pooling_width(pooling_size.second)
411 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]412 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]413 AveragePoolingOperatorTester()
414 .batch_size(2)
415 .input_height(pooling_size.second + 3)
416 .input_width(pooling_size.first + 2)
417 .pooling_height(pooling_size.second)
418 .pooling_width(pooling_size.first)
419 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]420 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]421 }
422}
423
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]424TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool_with_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]425 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]426 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]427 for (size_t channels = 1; channels <= 100; channels += 15) {
428 for (size_t stride_width = 1; stride_width <= 2; stride_width++) {
429 for (size_t stride_height = 1; stride_height <= 2; stride_height++) {
430 if (stride_width == 1 && stride_height == 1) {
431 continue;
432 }
433
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]434 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]435 .batch_size(2)
436 .input_height(pooling_size.first + 3)
437 .input_width(pooling_size.second + 2)
438 .pooling_height(pooling_size.first)
439 .pooling_width(pooling_size.second)
440 .stride_height(stride_height)
441 .stride_width(stride_width)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]442 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]443 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]444 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]445 .batch_size(2)
446 .input_height(pooling_size.second + 3)
447 .input_width(pooling_size.first + 2)
448 .pooling_height(pooling_size.second)
449 .pooling_width(pooling_size.first)
450 .stride_height(stride_height)
451 .stride_width(stride_width)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]452 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]453 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]454 }
455 }
456 }
457}
458
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]459TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool_with_width_padding) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]460 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]461 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]462 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]463 for (size_t stride = 1; stride <= 2; stride++) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]464 for (size_t padding_left = 0; padding_left <= 1; padding_left++) {
465 for (size_t padding_right = 0; padding_right <= 1; padding_right++) {
466 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]467 .batch_size(2)
468 .input_height(pooling_size.first + 3)
469 .input_width(pooling_size.second + 2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]470 .padding_left(padding_left)
471 .padding_right(padding_right)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]472 .pooling_height(pooling_size.first)
473 .pooling_width(pooling_size.second)
474 .stride(stride)
475 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]476 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]477 AveragePoolingOperatorTester()
478 .batch_size(2)
479 .input_height(pooling_size.second + 3)
480 .input_width(pooling_size.first + 2)
481 .padding_left(padding_left)
482 .padding_right(padding_right)
483 .pooling_height(pooling_size.second)
484 .pooling_width(pooling_size.first)
485 .stride(stride)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]486 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]487 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]488 }
489 }
490 }
491 }
492}
493
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]494TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool_with_height_padding) {
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]495 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]496 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]497 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]498 for (size_t stride = 1; stride <= 2; stride++) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]499 for (size_t padding_top = 0; padding_top <= 1; padding_top++) {
500 for (size_t padding_bottom = 0; padding_bottom <= 1; padding_bottom++) {
501 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]502 .batch_size(2)
503 .input_height(pooling_size.first + 3)
504 .input_width(pooling_size.second + 2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]505 .padding_top(padding_top)
506 .padding_bottom(padding_bottom)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]507 .pooling_height(pooling_size.first)
508 .pooling_width(pooling_size.second)
509 .stride(stride)
510 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]511 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]512 AveragePoolingOperatorTester()
513 .batch_size(2)
514 .input_height(pooling_size.second + 3)
515 .input_width(pooling_size.first + 2)
516 .padding_top(padding_top)
517 .padding_bottom(padding_bottom)
518 .pooling_height(pooling_size.second)
519 .pooling_width(pooling_size.first)
520 .stride(stride)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]521 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]522 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]523 }
524 }
525 }
526 }
527}
528
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]529TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool_with_tf_same_padding) {
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]530 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]531 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]532 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]533 for (size_t stride = 1; stride <= 2; stride++) {
534 for (size_t input_height = pooling_size.first + 3; input_height <= pooling_size.first + 4; input_height++) {
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]535 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]536 .batch_size(2)
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]537 .input_height(input_height)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]538 .input_width(pooling_size.second + 2)
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]539 .padding_tf_same(true)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]540 .pooling_height(pooling_size.first)
541 .pooling_width(pooling_size.second)
542 .stride(stride)
543 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]544 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]545 }
546 for (size_t input_width = pooling_size.second + 2; input_width <= pooling_size.second + 3; input_width++) {
547 AveragePoolingOperatorTester()
548 .batch_size(2)
549 .input_height(pooling_size.first + 3)
550 .input_width(input_width)
551 .padding_tf_same(true)
552 .pooling_height(pooling_size.first)
553 .pooling_width(pooling_size.second)
554 .stride(stride)
555 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]556 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]557 }
558 for (size_t input_height = pooling_size.second + 3; input_height <= pooling_size.second + 4; input_height++) {
559 AveragePoolingOperatorTester()
560 .batch_size(2)
561 .input_height(input_height)
562 .input_width(pooling_size.first + 2)
563 .padding_tf_same(true)
564 .pooling_height(pooling_size.second)
565 .pooling_width(pooling_size.first)
566 .stride(stride)
567 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]568 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]569 }
570 for (size_t input_width = pooling_size.first + 2; input_width <= pooling_size.first + 3; input_width++) {
571 AveragePoolingOperatorTester()
572 .batch_size(2)
573 .input_height(pooling_size.second + 3)
574 .input_width(input_width)
575 .padding_tf_same(true)
576 .pooling_height(pooling_size.second)
577 .pooling_width(pooling_size.first)
578 .stride(stride)
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]579 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]580 .TestQU8();
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]581 }
582 }
583 }
584}
585
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]586TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool_with_input_stride) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]587 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]588 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]589 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]590 AveragePoolingOperatorTester()
591 .batch_size(2)
592 .input_height(pooling_size.first + 3)
593 .input_width(pooling_size.second + 2)
594 .pooling_height(pooling_size.first)
595 .pooling_width(pooling_size.second)
596 .channels(channels)
597 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]598 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]599 AveragePoolingOperatorTester()
600 .batch_size(2)
601 .input_height(pooling_size.second + 3)
602 .input_width(pooling_size.first + 2)
603 .pooling_height(pooling_size.second)
604 .pooling_width(pooling_size.first)
605 .channels(channels)
606 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]607 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]608 }
609}
610
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]611TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool_with_output_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]612 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]613 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]614 for (size_t channels = 1; channels <= 100; channels += 15) {
615 AveragePoolingOperatorTester()
616 .batch_size(2)
617 .input_height(pooling_size.first + 3)
618 .input_width(pooling_size.second + 2)
619 .pooling_height(pooling_size.first)
620 .pooling_width(pooling_size.second)
621 .channels(channels)
622 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]623 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]624 AveragePoolingOperatorTester()
625 .batch_size(2)
626 .input_height(pooling_size.second + 3)
627 .input_width(pooling_size.first + 2)
628 .pooling_height(pooling_size.second)
629 .pooling_width(pooling_size.first)
630 .channels(channels)
631 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]632 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]633 }
634}
635
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]636TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool_with_input_scale) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]637 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]638 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]639 for (size_t channels = 1; channels <= 100; channels += 15) {
640 for (float input_scale = 0.01f; input_scale < 100.0f; input_scale *= 3.14159265f) {
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]641 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]642 .batch_size(2)
643 .input_height(pooling_size.first + 3)
644 .input_width(pooling_size.second + 2)
645 .pooling_height(pooling_size.first)
646 .pooling_width(pooling_size.second)
Marat Dukhan466da752020-02-28 02:00:49 -0800[diff] [blame]647 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]648 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]649 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]650 AveragePoolingOperatorTester()
651 .batch_size(2)
652 .input_height(pooling_size.second + 3)
653 .input_width(pooling_size.first + 2)
654 .pooling_height(pooling_size.second)
655 .pooling_width(pooling_size.first)
656 .channels(channels)
657 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]658 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]659 }
660 }
661}
662
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]663TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool_with_input_zero_point) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]664 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]665 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]666 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]667 for (int32_t input_zero_point = 0; input_zero_point <= 255; input_zero_point += 51) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]668 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]669 .batch_size(2)
670 .input_height(pooling_size.first + 3)
671 .input_width(pooling_size.second + 2)
672 .pooling_height(pooling_size.first)
673 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]674 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]675 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]676 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]677 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]678 .batch_size(2)
679 .input_height(pooling_size.second + 3)
680 .input_width(pooling_size.first + 2)
681 .pooling_height(pooling_size.second)
682 .pooling_width(pooling_size.first)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]683 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]684 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]685 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]686 }
687 }
688}
689
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]690TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool_with_output_scale) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]691 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]692 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]693 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]694 for (float output_scale = 0.01f; output_scale < 100.0f; output_scale *= 3.14159265f) {
695 AveragePoolingOperatorTester()
696 .batch_size(2)
697 .input_height(pooling_size.first + 3)
698 .input_width(pooling_size.second + 2)
699 .pooling_height(pooling_size.first)
700 .pooling_width(pooling_size.second)
701 .channels(channels)
702 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]703 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]704 AveragePoolingOperatorTester()
705 .batch_size(2)
706 .input_height(pooling_size.second + 3)
707 .input_width(pooling_size.first + 2)
708 .pooling_height(pooling_size.second)
709 .pooling_width(pooling_size.first)
710 .channels(channels)
711 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]712 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]713 }
714 }
715}
716
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]717TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool_with_output_zero_point) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]718 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]719 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]720 for (size_t channels = 1; channels <= 100; channels += 15) {
721 for (int32_t output_zero_point = 0; output_zero_point <= 255; output_zero_point += 51) {
722 AveragePoolingOperatorTester()
723 .batch_size(2)
724 .input_height(pooling_size.first + 3)
725 .input_width(pooling_size.second + 2)
726 .pooling_height(pooling_size.first)
727 .pooling_width(pooling_size.second)
728 .channels(channels)
729 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]730 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]731 AveragePoolingOperatorTester()
732 .batch_size(2)
733 .input_height(pooling_size.second + 3)
734 .input_width(pooling_size.first + 2)
735 .pooling_height(pooling_size.second)
736 .pooling_width(pooling_size.first)
737 .channels(channels)
738 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]739 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]740 }
741 }
742}
743
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]744TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool_with_qmin) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]745 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]746 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]747 for (size_t channels = 1; channels <= 100; channels += 15) {
748 AveragePoolingOperatorTester()
749 .batch_size(2)
750 .input_height(pooling_size.first + 3)
751 .input_width(pooling_size.second + 2)
752 .pooling_height(pooling_size.first)
753 .pooling_width(pooling_size.second)
754 .channels(channels)
755 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]756 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]757 AveragePoolingOperatorTester()
758 .batch_size(2)
759 .input_height(pooling_size.second + 3)
760 .input_width(pooling_size.first + 2)
761 .pooling_height(pooling_size.second)
762 .pooling_width(pooling_size.first)
763 .channels(channels)
764 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]765 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]766 }
767}
768
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]769TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_pool_with_qmax) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]770 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]771 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.avgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]772 for (size_t channels = 1; channels <= 100; channels += 15) {
773 AveragePoolingOperatorTester()
774 .batch_size(2)
775 .input_height(pooling_size.first + 3)
776 .input_width(pooling_size.second + 2)
777 .pooling_height(pooling_size.first)
778 .pooling_width(pooling_size.second)
779 .channels(channels)
780 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]781 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]782 AveragePoolingOperatorTester()
783 .batch_size(2)
784 .input_height(pooling_size.second + 3)
785 .input_width(pooling_size.first + 2)
786 .pooling_height(pooling_size.second)
787 .pooling_width(pooling_size.first)
788 .channels(channels)
789 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]790 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]791 }
792}
793
794/**************************** AVGPOOL path, multipass ****************************/
795
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]796TEST(AVERAGE_POOLING_NHWC_QU8, large_pool) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]797 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]798 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.avgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]799 for (size_t channels = 1; channels <= 100; channels += 15) {
800 AveragePoolingOperatorTester()
801 .input_height(pooling_size.first + 3)
802 .input_width(pooling_size.second + 2)
803 .pooling_height(pooling_size.first)
804 .pooling_width(pooling_size.second)
805 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]806 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]807 AveragePoolingOperatorTester()
808 .input_height(pooling_size.second + 3)
809 .input_width(pooling_size.first + 2)
810 .pooling_height(pooling_size.second)
811 .pooling_width(pooling_size.first)
812 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]813 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]814 }
815}
816
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]817TEST(AVERAGE_POOLING_NHWC_QU8, large_pool_with_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]818 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]819 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]820 for (size_t channels = 1; channels <= 100; channels += 15) {
821 for (size_t stride_width = 1; stride_width <= 2; stride_width++) {
822 for (size_t stride_height = 1; stride_height <= 2; stride_height++) {
823 if (stride_width == 1 && stride_height == 1) {
824 continue;
825 }
826
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]827 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]828 .input_height(pooling_size.first + 3)
829 .input_width(pooling_size.second + 2)
830 .pooling_height(pooling_size.first)
831 .pooling_width(pooling_size.second)
832 .stride_height(stride_height)
833 .stride_width(stride_width)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]834 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]835 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]836 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]837 .input_height(pooling_size.second + 3)
838 .input_width(pooling_size.first + 2)
839 .pooling_height(pooling_size.second)
840 .pooling_width(pooling_size.first)
841 .stride_height(stride_height)
842 .stride_width(stride_width)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]843 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]844 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]845 }
846 }
847 }
848}
849
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]850TEST(AVERAGE_POOLING_NHWC_QU8, large_pool_with_width_padding) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]851 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]852 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]853 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]854 for (size_t stride = 1; stride <= 2; stride++) {
855 for (size_t padding_left = 0; padding_left <= 1; padding_left++) {
856 for (size_t padding_right = 0; padding_right <= 1; padding_right++) {
857 AveragePoolingOperatorTester()
858 .input_height(pooling_size.first + 3)
859 .input_width(pooling_size.second + 2)
860 .padding_left(padding_left)
861 .padding_right(padding_right)
862 .pooling_height(pooling_size.first)
863 .pooling_width(pooling_size.second)
864 .stride(stride)
865 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]866 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]867 AveragePoolingOperatorTester()
868 .input_height(pooling_size.second + 3)
869 .input_width(pooling_size.first + 2)
870 .padding_left(padding_left)
871 .padding_right(padding_right)
872 .pooling_height(pooling_size.second)
873 .pooling_width(pooling_size.first)
874 .stride(stride)
875 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]876 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]877 }
878 }
879 }
880 }
881}
882
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]883TEST(AVERAGE_POOLING_NHWC_QU8, large_pool_with_height_padding) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]884 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]885 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]886 for (size_t channels = 1; channels <= 100; channels += 15) {
887 for (size_t stride = 1; stride <= 2; stride++) {
888 for (size_t padding_top = 0; padding_top <= 1; padding_top++) {
889 for (size_t padding_bottom = 0; padding_bottom <= 1; padding_bottom++) {
890 AveragePoolingOperatorTester()
891 .input_height(pooling_size.first + 3)
892 .input_width(pooling_size.second + 2)
893 .padding_top(padding_top)
894 .padding_bottom(padding_bottom)
895 .pooling_height(pooling_size.first)
896 .pooling_width(pooling_size.second)
897 .stride(stride)
898 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]899 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]900 AveragePoolingOperatorTester()
901 .input_height(pooling_size.second + 3)
902 .input_width(pooling_size.first + 2)
903 .padding_top(padding_top)
904 .padding_bottom(padding_bottom)
905 .pooling_height(pooling_size.second)
906 .pooling_width(pooling_size.first)
907 .stride(stride)
908 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]909 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]910 }
911 }
912 }
913 }
914}
915
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]916TEST(AVERAGE_POOLING_NHWC_QU8, large_pool_with_tf_same_padding) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]917 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]918 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]919 for (size_t channels = 1; channels <= 100; channels += 15) {
920 for (size_t stride = 1; stride <= 2; stride++) {
921 for (size_t input_height = pooling_size.first + 3; input_height <= pooling_size.first + 4; input_height++) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]922 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]923 .input_height(input_height)
924 .input_width(pooling_size.second + 2)
925 .padding_tf_same(true)
926 .pooling_height(pooling_size.first)
927 .pooling_width(pooling_size.second)
928 .stride(stride)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]929 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]930 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]931 }
932 for (size_t input_width = pooling_size.second + 2; input_width <= pooling_size.second + 3; input_width++) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]933 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]934 .input_height(pooling_size.first + 3)
935 .input_width(input_width)
936 .padding_tf_same(true)
937 .pooling_height(pooling_size.first)
938 .pooling_width(pooling_size.second)
939 .stride(stride)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]940 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]941 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]942 }
943 for (size_t input_height = pooling_size.second + 3; input_height <= pooling_size.second + 4; input_height++) {
944 AveragePoolingOperatorTester()
945 .input_height(input_height)
946 .input_width(pooling_size.first + 2)
947 .padding_tf_same(true)
948 .pooling_height(pooling_size.second)
949 .pooling_width(pooling_size.first)
950 .stride(stride)
951 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]952 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]953 }
954 for (size_t input_width = pooling_size.first + 2; input_width <= pooling_size.first + 3; input_width++) {
955 AveragePoolingOperatorTester()
956 .input_height(pooling_size.second + 3)
957 .input_width(input_width)
958 .padding_tf_same(true)
959 .pooling_height(pooling_size.second)
960 .pooling_width(pooling_size.first)
961 .stride(stride)
962 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]963 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]964 }
965 }
966 }
967}
968
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]969TEST(AVERAGE_POOLING_NHWC_QU8, large_pool_with_input_stride) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]970 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]971 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]972 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]973 AveragePoolingOperatorTester()
974 .input_height(pooling_size.first + 3)
975 .input_width(pooling_size.second + 2)
976 .pooling_height(pooling_size.first)
977 .pooling_width(pooling_size.second)
978 .channels(channels)
979 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]980 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]981 AveragePoolingOperatorTester()
982 .input_height(pooling_size.second + 3)
983 .input_width(pooling_size.first + 2)
984 .pooling_height(pooling_size.second)
985 .pooling_width(pooling_size.first)
986 .channels(channels)
987 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]988 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]989 }
990}
991
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]992TEST(AVERAGE_POOLING_NHWC_QU8, large_pool_with_output_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]993 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]994 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]995 for (size_t channels = 1; channels <= 100; channels += 15) {
996 AveragePoolingOperatorTester()
997 .input_height(pooling_size.first + 3)
998 .input_width(pooling_size.second + 2)
999 .pooling_height(pooling_size.first)
1000 .pooling_width(pooling_size.second)
1001 .channels(channels)
1002 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1003 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1004 AveragePoolingOperatorTester()
1005 .input_height(pooling_size.second + 3)
1006 .input_width(pooling_size.first + 2)
1007 .pooling_height(pooling_size.second)
1008 .pooling_width(pooling_size.first)
1009 .channels(channels)
1010 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1011 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1012 }
1013}
1014
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1015TEST(AVERAGE_POOLING_NHWC_QU8, large_pool_with_input_scale) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1016 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1017 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1018 for (size_t channels = 1; channels <= 100; channels += 15) {
1019 for (float input_scale = 0.01f; input_scale < 100.0f; input_scale *= 3.14159265f) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1020 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1021 .input_height(pooling_size.first + 3)
1022 .input_width(pooling_size.second + 2)
1023 .pooling_height(pooling_size.first)
1024 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1025 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1026 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1027 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1028 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1029 .input_height(pooling_size.second + 3)
1030 .input_width(pooling_size.first + 2)
1031 .pooling_height(pooling_size.second)
1032 .pooling_width(pooling_size.first)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1033 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1034 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1035 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1036 }
1037 }
1038}
1039
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1040TEST(AVERAGE_POOLING_NHWC_QU8, large_pool_with_input_zero_point) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]1041 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1042 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1043 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1044 for (int32_t input_zero_point = 0; input_zero_point <= 255; input_zero_point += 51) {
1045 AveragePoolingOperatorTester()
1046 .input_height(pooling_size.first + 3)
1047 .input_width(pooling_size.second + 2)
1048 .pooling_height(pooling_size.first)
1049 .pooling_width(pooling_size.second)
1050 .channels(channels)
1051 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1052 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1053 AveragePoolingOperatorTester()
1054 .input_height(pooling_size.second + 3)
1055 .input_width(pooling_size.first + 2)
1056 .pooling_height(pooling_size.second)
1057 .pooling_width(pooling_size.first)
1058 .channels(channels)
1059 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1060 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1061 }
1062 }
1063}
1064
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1065TEST(AVERAGE_POOLING_NHWC_QU8, large_pool_with_output_scale) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1066 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1067 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1068 for (size_t channels = 1; channels <= 100; channels += 15) {
1069 for (float output_scale = 0.01f; output_scale < 100.0f; output_scale *= 3.14159265f) {
1070 AveragePoolingOperatorTester()
1071 .input_height(pooling_size.first + 3)
1072 .input_width(pooling_size.second + 2)
1073 .pooling_height(pooling_size.first)
1074 .pooling_width(pooling_size.second)
1075 .channels(channels)
1076 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1077 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1078 AveragePoolingOperatorTester()
1079 .input_height(pooling_size.second + 3)
1080 .input_width(pooling_size.first + 2)
1081 .pooling_height(pooling_size.second)
1082 .pooling_width(pooling_size.first)
1083 .channels(channels)
1084 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1085 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1086 }
1087 }
1088}
1089
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1090TEST(AVERAGE_POOLING_NHWC_QU8, large_pool_with_output_zero_point) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1091 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1092 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1093 for (size_t channels = 1; channels <= 100; channels += 15) {
1094 for (int32_t output_zero_point = 0; output_zero_point <= 255; output_zero_point += 51) {
1095 AveragePoolingOperatorTester()
1096 .input_height(pooling_size.first + 3)
1097 .input_width(pooling_size.second + 2)
1098 .pooling_height(pooling_size.first)
1099 .pooling_width(pooling_size.second)
1100 .channels(channels)
1101 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1102 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1103 AveragePoolingOperatorTester()
1104 .input_height(pooling_size.second + 3)
1105 .input_width(pooling_size.first + 2)
1106 .pooling_height(pooling_size.second)
1107 .pooling_width(pooling_size.first)
1108 .channels(channels)
1109 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1110 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1111 }
1112 }
1113}
1114
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1115TEST(AVERAGE_POOLING_NHWC_QU8, large_pool_with_qmin) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1116 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1117 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1118 for (size_t channels = 1; channels <= 100; channels += 15) {
1119 AveragePoolingOperatorTester()
1120 .input_height(pooling_size.first + 3)
1121 .input_width(pooling_size.second + 2)
1122 .pooling_height(pooling_size.first)
1123 .pooling_width(pooling_size.second)
1124 .channels(channels)
1125 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1126 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1127 AveragePoolingOperatorTester()
1128 .input_height(pooling_size.second + 3)
1129 .input_width(pooling_size.first + 2)
1130 .pooling_height(pooling_size.second)
1131 .pooling_width(pooling_size.first)
1132 .channels(channels)
1133 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1134 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1135 }
1136}
1137
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1138TEST(AVERAGE_POOLING_NHWC_QU8, large_pool_with_qmax) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1139 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1140 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1141 for (size_t channels = 1; channels <= 100; channels += 15) {
1142 AveragePoolingOperatorTester()
1143 .input_height(pooling_size.first + 3)
1144 .input_width(pooling_size.second + 2)
1145 .pooling_height(pooling_size.first)
1146 .pooling_width(pooling_size.second)
1147 .channels(channels)
1148 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1149 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1150 AveragePoolingOperatorTester()
1151 .input_height(pooling_size.second + 3)
1152 .input_width(pooling_size.first + 2)
1153 .pooling_height(pooling_size.second)
1154 .pooling_width(pooling_size.first)
1155 .channels(channels)
1156 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1157 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1158 }
1159}
1160
1161/**************************** AVGPOOL path, multipass, batched ****************************/
1162
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1163TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1164 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1165 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.avgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1166 for (size_t channels = 1; channels <= 100; channels += 15) {
1167 AveragePoolingOperatorTester()
1168 .batch_size(2)
1169 .input_height(pooling_size.first + 3)
1170 .input_width(pooling_size.second + 2)
1171 .pooling_height(pooling_size.first)
1172 .pooling_width(pooling_size.second)
1173 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1174 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1175 AveragePoolingOperatorTester()
1176 .batch_size(2)
1177 .input_height(pooling_size.second + 3)
1178 .input_width(pooling_size.first + 2)
1179 .pooling_height(pooling_size.second)
1180 .pooling_width(pooling_size.first)
1181 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1182 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1183 }
1184}
1185
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1186TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool_with_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1187 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1188 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1189 for (size_t channels = 1; channels <= 100; channels += 15) {
1190 for (size_t stride_width = 1; stride_width <= 2; stride_width++) {
1191 for (size_t stride_height = 1; stride_height <= 2; stride_height++) {
1192 if (stride_width == 1 && stride_height == 1) {
1193 continue;
1194 }
1195
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1196 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1197 .batch_size(2)
1198 .input_height(pooling_size.first + 3)
1199 .input_width(pooling_size.second + 2)
1200 .pooling_height(pooling_size.first)
1201 .pooling_width(pooling_size.second)
1202 .stride_height(stride_height)
1203 .stride_width(stride_width)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1204 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1205 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1206 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1207 .batch_size(2)
1208 .input_height(pooling_size.second + 3)
1209 .input_width(pooling_size.first + 2)
1210 .pooling_height(pooling_size.second)
1211 .pooling_width(pooling_size.first)
1212 .stride_height(stride_height)
1213 .stride_width(stride_width)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1214 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1215 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1216 }
1217 }
1218 }
1219}
1220
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1221TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool_with_width_padding) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]1222 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1223 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1224 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1225 for (size_t stride = 1; stride <= 2; stride++) {
1226 for (size_t padding_left = 0; padding_left <= 1; padding_left++) {
1227 for (size_t padding_right = 0; padding_right <= 1; padding_right++) {
1228 AveragePoolingOperatorTester()
1229 .batch_size(2)
1230 .input_height(pooling_size.first + 3)
1231 .input_width(pooling_size.second + 2)
1232 .padding_left(padding_left)
1233 .padding_right(padding_right)
1234 .pooling_height(pooling_size.first)
1235 .pooling_width(pooling_size.second)
1236 .stride(stride)
1237 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1238 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1239 AveragePoolingOperatorTester()
1240 .batch_size(2)
1241 .input_height(pooling_size.second + 3)
1242 .input_width(pooling_size.first + 2)
1243 .padding_left(padding_left)
1244 .padding_right(padding_right)
1245 .pooling_height(pooling_size.second)
1246 .pooling_width(pooling_size.first)
1247 .stride(stride)
1248 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1249 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1250 }
1251 }
1252 }
1253 }
1254}
1255
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1256TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool_with_height_padding) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1257 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1258 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1259 for (size_t channels = 1; channels <= 100; channels += 15) {
1260 for (size_t stride = 1; stride <= 2; stride++) {
1261 for (size_t padding_top = 0; padding_top <= 1; padding_top++) {
1262 for (size_t padding_bottom = 0; padding_bottom <= 1; padding_bottom++) {
1263 AveragePoolingOperatorTester()
1264 .batch_size(2)
1265 .input_height(pooling_size.first + 3)
1266 .input_width(pooling_size.second + 2)
1267 .padding_top(padding_top)
1268 .padding_bottom(padding_bottom)
1269 .pooling_height(pooling_size.first)
1270 .pooling_width(pooling_size.second)
1271 .stride(stride)
1272 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1273 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1274 AveragePoolingOperatorTester()
1275 .batch_size(2)
1276 .input_height(pooling_size.second + 3)
1277 .input_width(pooling_size.first + 2)
1278 .padding_top(padding_top)
1279 .padding_bottom(padding_bottom)
1280 .pooling_height(pooling_size.second)
1281 .pooling_width(pooling_size.first)
1282 .stride(stride)
1283 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1284 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1285 }
1286 }
1287 }
1288 }
1289}
1290
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1291TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool_with_tf_same_padding) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1292 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1293 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1294 for (size_t channels = 1; channels <= 100; channels += 15) {
1295 for (size_t stride = 1; stride <= 2; stride++) {
1296 for (size_t input_height = pooling_size.first + 3; input_height <= pooling_size.first + 4; input_height++) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1297 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1298 .batch_size(2)
1299 .input_height(input_height)
1300 .input_width(pooling_size.second + 2)
1301 .padding_tf_same(true)
1302 .pooling_height(pooling_size.first)
1303 .pooling_width(pooling_size.second)
1304 .stride(stride)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1305 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1306 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1307 }
1308 for (size_t input_width = pooling_size.second + 2; input_width <= pooling_size.second + 3; input_width++) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1309 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1310 .batch_size(2)
1311 .input_height(pooling_size.first + 3)
1312 .input_width(input_width)
1313 .padding_tf_same(true)
1314 .pooling_height(pooling_size.first)
1315 .pooling_width(pooling_size.second)
1316 .stride(stride)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1317 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1318 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1319 }
1320 for (size_t input_height = pooling_size.second + 3; input_height <= pooling_size.second + 4; input_height++) {
1321 AveragePoolingOperatorTester()
1322 .batch_size(2)
1323 .input_height(input_height)
1324 .input_width(pooling_size.first + 2)
1325 .padding_tf_same(true)
1326 .pooling_height(pooling_size.second)
1327 .pooling_width(pooling_size.first)
1328 .stride(stride)
1329 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1330 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1331 }
1332 for (size_t input_width = pooling_size.first + 2; input_width <= pooling_size.first + 3; input_width++) {
1333 AveragePoolingOperatorTester()
1334 .batch_size(2)
1335 .input_height(pooling_size.second + 3)
1336 .input_width(input_width)
1337 .padding_tf_same(true)
1338 .pooling_height(pooling_size.second)
1339 .pooling_width(pooling_size.first)
1340 .stride(stride)
1341 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1342 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1343 }
1344 }
1345 }
1346}
1347
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1348TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool_with_input_stride) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]1349 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1350 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1351 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1352 AveragePoolingOperatorTester()
1353 .batch_size(2)
1354 .input_height(pooling_size.first + 3)
1355 .input_width(pooling_size.second + 2)
1356 .pooling_height(pooling_size.first)
1357 .pooling_width(pooling_size.second)
1358 .channels(channels)
1359 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1360 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1361 AveragePoolingOperatorTester()
1362 .batch_size(2)
1363 .input_height(pooling_size.second + 3)
1364 .input_width(pooling_size.first + 2)
1365 .pooling_height(pooling_size.second)
1366 .pooling_width(pooling_size.first)
1367 .channels(channels)
1368 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1369 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1370 }
1371}
1372
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1373TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool_with_output_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1374 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1375 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1376 for (size_t channels = 1; channels <= 100; channels += 15) {
1377 AveragePoolingOperatorTester()
1378 .batch_size(2)
1379 .input_height(pooling_size.first + 3)
1380 .input_width(pooling_size.second + 2)
1381 .pooling_height(pooling_size.first)
1382 .pooling_width(pooling_size.second)
1383 .channels(channels)
1384 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1385 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1386 AveragePoolingOperatorTester()
1387 .batch_size(2)
1388 .input_height(pooling_size.second + 3)
1389 .input_width(pooling_size.first + 2)
1390 .pooling_height(pooling_size.second)
1391 .pooling_width(pooling_size.first)
1392 .channels(channels)
1393 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1394 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1395 }
1396}
1397
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1398TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool_with_input_scale) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1399 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1400 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1401 for (size_t channels = 1; channels <= 100; channels += 15) {
1402 for (float input_scale = 0.01f; input_scale < 100.0f; input_scale *= 3.14159265f) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1403 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1404 .batch_size(2)
1405 .input_height(pooling_size.first + 3)
1406 .input_width(pooling_size.second + 2)
1407 .pooling_height(pooling_size.first)
1408 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1409 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1410 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1411 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1412 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1413 .batch_size(2)
1414 .input_height(pooling_size.second + 3)
1415 .input_width(pooling_size.first + 2)
1416 .pooling_height(pooling_size.second)
1417 .pooling_width(pooling_size.first)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1418 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1419 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1420 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1421 }
1422 }
1423}
1424
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1425TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool_with_input_zero_point) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]1426 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1427 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1428 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1429 for (int32_t input_zero_point = 0; input_zero_point <= 255; input_zero_point += 51) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1430 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1431 .batch_size(2)
1432 .input_height(pooling_size.first + 3)
1433 .input_width(pooling_size.second + 2)
1434 .pooling_height(pooling_size.first)
1435 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1436 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1437 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1438 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1439 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1440 .batch_size(2)
1441 .input_height(pooling_size.second + 3)
1442 .input_width(pooling_size.first + 2)
1443 .pooling_height(pooling_size.second)
1444 .pooling_width(pooling_size.first)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1445 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1446 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1447 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1448 }
1449 }
1450}
1451
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1452TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool_with_output_scale) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]1453 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1454 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1455 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1456 for (float output_scale = 0.01f; output_scale < 100.0f; output_scale *= 3.14159265f) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1457 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1458 .batch_size(2)
1459 .input_height(pooling_size.first + 3)
1460 .input_width(pooling_size.second + 2)
1461 .pooling_height(pooling_size.first)
1462 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1463 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1464 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1465 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1466 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1467 .batch_size(2)
1468 .input_height(pooling_size.second + 3)
1469 .input_width(pooling_size.first + 2)
1470 .pooling_height(pooling_size.second)
1471 .pooling_width(pooling_size.first)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1472 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1473 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1474 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1475 }
1476 }
1477}
1478
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1479TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool_with_output_zero_point) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]1480 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1481 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1482 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1483 for (int32_t output_zero_point = 0; output_zero_point <= 255; output_zero_point += 51) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1484 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1485 .batch_size(2)
1486 .input_height(pooling_size.first + 3)
1487 .input_width(pooling_size.second + 2)
1488 .pooling_height(pooling_size.first)
1489 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1490 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1491 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1492 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1493 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1494 .batch_size(2)
1495 .input_height(pooling_size.second + 3)
1496 .input_width(pooling_size.first + 2)
1497 .pooling_height(pooling_size.second)
1498 .pooling_width(pooling_size.first)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1499 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1500 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1501 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1502 }
1503 }
1504}
1505
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1506TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool_with_qmin) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]1507 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1508 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1509 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1510 AveragePoolingOperatorTester()
1511 .batch_size(2)
1512 .input_height(pooling_size.first + 3)
1513 .input_width(pooling_size.second + 2)
1514 .pooling_height(pooling_size.first)
1515 .pooling_width(pooling_size.second)
1516 .channels(channels)
1517 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1518 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1519 AveragePoolingOperatorTester()
1520 .batch_size(2)
1521 .input_height(pooling_size.second + 3)
1522 .input_width(pooling_size.first + 2)
1523 .pooling_height(pooling_size.second)
1524 .pooling_width(pooling_size.first)
1525 .channels(channels)
1526 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1527 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1528 }
1529}
1530
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1531TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_pool_with_qmax) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1532 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1533 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1534 for (size_t channels = 1; channels <= 100; channels += 15) {
1535 AveragePoolingOperatorTester()
1536 .batch_size(2)
1537 .input_height(pooling_size.first + 3)
1538 .input_width(pooling_size.second + 2)
1539 .pooling_height(pooling_size.first)
1540 .pooling_width(pooling_size.second)
1541 .channels(channels)
1542 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1543 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1544 AveragePoolingOperatorTester()
1545 .batch_size(2)
1546 .input_height(pooling_size.second + 3)
1547 .input_width(pooling_size.first + 2)
1548 .pooling_height(pooling_size.second)
1549 .pooling_width(pooling_size.first)
1550 .channels(channels)
1551 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1552 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1553 }
1554}
1555
1556/**************************** GAVGPOOL path, unipass ****************************/
1557
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1558TEST(AVERAGE_POOLING_NHWC_QU8, small_image) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1559 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1560 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1561 for (size_t channels = 1; channels <= 100; channels += 15) {
1562 AveragePoolingOperatorTester()
1563 .input_height(pooling_size.first)
1564 .input_width(pooling_size.second)
1565 .pooling_height(pooling_size.first)
1566 .pooling_width(pooling_size.second)
1567 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1568 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1569 AveragePoolingOperatorTester()
1570 .input_height(pooling_size.second)
1571 .input_width(pooling_size.first)
1572 .pooling_height(pooling_size.second)
1573 .pooling_width(pooling_size.first)
1574 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1575 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1576 }
1577}
1578
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1579TEST(AVERAGE_POOLING_NHWC_QU8, small_image_with_width_padding) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1580 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
1581 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
1582 for (size_t channels = 1; channels <= 100; channels += 15) {
1583 /* With left padding */
1584 AveragePoolingOperatorTester()
1585 .input_height(pooling_size.first)
1586 .input_width(pooling_size.second - 1)
1587 .padding_left(1)
1588 .pooling_height(pooling_size.first)
1589 .pooling_width(pooling_size.second)
1590 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1591 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1592 AveragePoolingOperatorTester()
1593 .input_height(pooling_size.second)
1594 .input_width(pooling_size.first - 1)
1595 .padding_left(1)
1596 .pooling_height(pooling_size.second)
1597 .pooling_width(pooling_size.first)
1598 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1599 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1600
1601 /* With right padding */
1602 AveragePoolingOperatorTester()
1603 .input_height(pooling_size.first)
1604 .input_width(pooling_size.second - 1)
1605 .padding_right(1)
1606 .pooling_height(pooling_size.first)
1607 .pooling_width(pooling_size.second)
1608 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1609 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1610 AveragePoolingOperatorTester()
1611 .input_height(pooling_size.second)
1612 .input_width(pooling_size.first - 1)
1613 .padding_right(1)
1614 .pooling_height(pooling_size.second)
1615 .pooling_width(pooling_size.first)
1616 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1617 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1618 }
1619}
1620
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1621TEST(AVERAGE_POOLING_NHWC_QU8, small_image_with_height_padding) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1622 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1623 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1624 for (size_t channels = 1; channels <= 100; channels += 15) {
1625 /* With top padding */
1626 AveragePoolingOperatorTester()
1627 .input_height(pooling_size.first - 1)
1628 .input_width(pooling_size.second)
1629 .padding_top(1)
1630 .pooling_height(pooling_size.first)
1631 .pooling_width(pooling_size.second)
1632 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1633 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1634 AveragePoolingOperatorTester()
1635 .input_height(pooling_size.second - 1)
1636 .input_width(pooling_size.first)
1637 .padding_top(1)
1638 .pooling_height(pooling_size.second)
1639 .pooling_width(pooling_size.first)
1640 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1641 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1642
1643 /* With bottom padding */
1644 AveragePoolingOperatorTester()
1645 .input_height(pooling_size.first - 1)
1646 .input_width(pooling_size.second)
1647 .padding_bottom(1)
1648 .pooling_height(pooling_size.first)
1649 .pooling_width(pooling_size.second)
1650 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1651 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1652 AveragePoolingOperatorTester()
1653 .input_height(pooling_size.second - 1)
1654 .input_width(pooling_size.first)
1655 .padding_bottom(1)
1656 .pooling_height(pooling_size.second)
1657 .pooling_width(pooling_size.first)
1658 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1659 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1660 }
1661}
1662
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1663TEST(AVERAGE_POOLING_NHWC_QU8, small_image_with_input_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1664 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1665 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1666 for (size_t channels = 1; channels <= 100; channels += 15) {
1667 AveragePoolingOperatorTester()
1668 .input_height(pooling_size.first)
1669 .input_width(pooling_size.second)
1670 .pooling_height(pooling_size.first)
1671 .pooling_width(pooling_size.second)
1672 .channels(channels)
1673 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1674 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1675 AveragePoolingOperatorTester()
1676 .input_height(pooling_size.second)
1677 .input_width(pooling_size.first)
1678 .pooling_height(pooling_size.second)
1679 .pooling_width(pooling_size.first)
1680 .channels(channels)
1681 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1682 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1683 }
1684}
1685
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1686TEST(AVERAGE_POOLING_NHWC_QU8, small_image_with_output_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1687 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1688 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1689 for (size_t channels = 1; channels <= 100; channels += 15) {
1690 AveragePoolingOperatorTester()
1691 .input_height(pooling_size.first)
1692 .input_width(pooling_size.second)
1693 .pooling_height(pooling_size.first)
1694 .pooling_width(pooling_size.second)
1695 .channels(channels)
1696 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1697 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1698 AveragePoolingOperatorTester()
1699 .input_height(pooling_size.second)
1700 .input_width(pooling_size.first)
1701 .pooling_height(pooling_size.second)
1702 .pooling_width(pooling_size.first)
1703 .channels(channels)
1704 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1705 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1706 }
1707}
1708
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1709TEST(AVERAGE_POOLING_NHWC_QU8, small_image_with_input_scale) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1710 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1711 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1712 for (size_t channels = 1; channels <= 100; channels += 15) {
1713 for (float input_scale = 0.01f; input_scale < 100.0f; input_scale *= 3.14159265f) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1714 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1715 .input_height(pooling_size.first)
1716 .input_width(pooling_size.second)
1717 .pooling_height(pooling_size.first)
1718 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1719 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1720 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1721 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1722 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1723 .input_height(pooling_size.second)
1724 .input_width(pooling_size.first)
1725 .pooling_height(pooling_size.second)
1726 .pooling_width(pooling_size.first)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1727 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1728 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1729 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1730 }
1731 }
1732}
1733
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1734TEST(AVERAGE_POOLING_NHWC_QU8, small_image_with_input_zero_point) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]1735 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1736 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1737 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1738 for (int32_t input_zero_point = 0; input_zero_point <= 255; input_zero_point += 51) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1739 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1740 .input_height(pooling_size.first)
1741 .input_width(pooling_size.second)
1742 .pooling_height(pooling_size.first)
1743 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1744 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1745 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1746 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1747 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1748 .input_height(pooling_size.second)
1749 .input_width(pooling_size.first)
1750 .pooling_height(pooling_size.second)
1751 .pooling_width(pooling_size.first)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1752 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1753 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1754 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1755 }
1756 }
1757}
1758
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1759TEST(AVERAGE_POOLING_NHWC_QU8, small_image_with_output_scale) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]1760 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1761 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1762 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1763 for (float output_scale = 0.01f; output_scale < 100.0f; output_scale *= 3.14159265f) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1764 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1765 .input_height(pooling_size.first)
1766 .input_width(pooling_size.second)
1767 .pooling_height(pooling_size.first)
1768 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1769 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1770 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1771 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1772 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1773 .input_height(pooling_size.second)
1774 .input_width(pooling_size.first)
1775 .pooling_height(pooling_size.second)
1776 .pooling_width(pooling_size.first)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1777 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1778 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1779 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1780 }
1781 }
1782}
1783
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1784TEST(AVERAGE_POOLING_NHWC_QU8, small_image_with_output_zero_point) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]1785 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1786 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1787 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1788 for (int32_t output_zero_point = 0; output_zero_point <= 255; output_zero_point += 51) {
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1789 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1790 .input_height(pooling_size.first)
1791 .input_width(pooling_size.second)
1792 .pooling_height(pooling_size.first)
1793 .pooling_width(pooling_size.second)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1794 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1795 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1796 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1797 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1798 .input_height(pooling_size.second)
1799 .input_width(pooling_size.first)
1800 .pooling_height(pooling_size.second)
1801 .pooling_width(pooling_size.first)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1802 .channels(channels)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1803 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1804 .TestQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]1805 }
1806 }
1807}
1808
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1809TEST(AVERAGE_POOLING_NHWC_QU8, small_image_with_qmin) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1810 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1811 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1812 for (size_t channels = 1; channels <= 100; channels += 15) {
1813 AveragePoolingOperatorTester()
1814 .input_height(pooling_size.first)
1815 .input_width(pooling_size.second)
1816 .pooling_height(pooling_size.first)
1817 .pooling_width(pooling_size.second)
1818 .channels(channels)
1819 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1820 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1821 AveragePoolingOperatorTester()
1822 .input_height(pooling_size.second)
1823 .input_width(pooling_size.first)
1824 .pooling_height(pooling_size.second)
1825 .pooling_width(pooling_size.first)
1826 .channels(channels)
1827 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1828 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1829 }
1830}
1831
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1832TEST(AVERAGE_POOLING_NHWC_QU8, small_image_with_qmax) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1833 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1834 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1835 for (size_t channels = 1; channels <= 100; channels += 15) {
1836 AveragePoolingOperatorTester()
1837 .input_height(pooling_size.first)
1838 .input_width(pooling_size.second)
1839 .pooling_height(pooling_size.first)
1840 .pooling_width(pooling_size.second)
1841 .channels(channels)
1842 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1843 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1844 AveragePoolingOperatorTester()
1845 .input_height(pooling_size.second)
1846 .input_width(pooling_size.first)
1847 .pooling_height(pooling_size.second)
1848 .pooling_width(pooling_size.first)
1849 .channels(channels)
1850 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1851 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1852 }
1853}
1854
1855/**************************** GAVGPOOL path, unipass, batched ****************************/
1856
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1857TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_image) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1858 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1859 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1860 for (size_t channels = 1; channels <= 100; channels += 15) {
1861 AveragePoolingOperatorTester()
1862 .batch_size(2)
1863 .input_height(pooling_size.first)
1864 .input_width(pooling_size.second)
1865 .pooling_height(pooling_size.first)
1866 .pooling_width(pooling_size.second)
1867 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1868 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1869 AveragePoolingOperatorTester()
1870 .batch_size(2)
1871 .input_height(pooling_size.second)
1872 .input_width(pooling_size.first)
1873 .pooling_height(pooling_size.second)
1874 .pooling_width(pooling_size.first)
1875 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1876 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1877 }
1878}
1879
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1880TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_image_with_width_padding) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1881 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
1882 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
1883 for (size_t channels = 1; channels <= 100; channels += 15) {
1884 /* With left padding */
1885 AveragePoolingOperatorTester()
1886 .batch_size(2)
1887 .input_height(pooling_size.first)
1888 .input_width(pooling_size.second - 1)
1889 .padding_left(1)
1890 .pooling_height(pooling_size.first)
1891 .pooling_width(pooling_size.second)
1892 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1893 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1894 AveragePoolingOperatorTester()
1895 .batch_size(2)
1896 .input_height(pooling_size.second)
1897 .input_width(pooling_size.first - 1)
1898 .padding_left(1)
1899 .pooling_height(pooling_size.second)
1900 .pooling_width(pooling_size.first)
1901 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1902 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1903
1904 /* With right padding */
1905 AveragePoolingOperatorTester()
1906 .batch_size(2)
1907 .input_height(pooling_size.first)
1908 .input_width(pooling_size.second - 1)
1909 .padding_right(1)
1910 .pooling_height(pooling_size.first)
1911 .pooling_width(pooling_size.second)
1912 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1913 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1914 AveragePoolingOperatorTester()
1915 .batch_size(2)
1916 .input_height(pooling_size.second)
1917 .input_width(pooling_size.first - 1)
1918 .padding_right(1)
1919 .pooling_height(pooling_size.second)
1920 .pooling_width(pooling_size.first)
1921 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1922 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1923 }
1924}
1925
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1926TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_image_with_height_padding) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1927 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1928 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1929 for (size_t channels = 1; channels <= 100; channels += 15) {
1930 /* With top padding */
1931 AveragePoolingOperatorTester()
1932 .batch_size(2)
1933 .input_height(pooling_size.first - 1)
1934 .input_width(pooling_size.second)
1935 .padding_top(1)
1936 .pooling_height(pooling_size.first)
1937 .pooling_width(pooling_size.second)
1938 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1939 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1940 AveragePoolingOperatorTester()
1941 .batch_size(2)
1942 .input_height(pooling_size.second - 1)
1943 .input_width(pooling_size.first)
1944 .padding_top(1)
1945 .pooling_height(pooling_size.second)
1946 .pooling_width(pooling_size.first)
1947 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1948 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1949
1950 /* With bottom padding */
1951 AveragePoolingOperatorTester()
1952 .batch_size(2)
1953 .input_height(pooling_size.first - 1)
1954 .input_width(pooling_size.second)
1955 .padding_bottom(1)
1956 .pooling_height(pooling_size.first)
1957 .pooling_width(pooling_size.second)
1958 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1959 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1960 AveragePoolingOperatorTester()
1961 .batch_size(2)
1962 .input_height(pooling_size.second - 1)
1963 .input_width(pooling_size.first)
1964 .padding_bottom(1)
1965 .pooling_height(pooling_size.second)
1966 .pooling_width(pooling_size.first)
1967 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1968 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1969 }
1970}
1971
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1972TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_image_with_input_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1973 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1974 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1975 for (size_t channels = 1; channels <= 100; channels += 15) {
1976 AveragePoolingOperatorTester()
1977 .batch_size(2)
1978 .input_height(pooling_size.first)
1979 .input_width(pooling_size.second)
1980 .pooling_height(pooling_size.first)
1981 .pooling_width(pooling_size.second)
1982 .channels(channels)
1983 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1984 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1985 AveragePoolingOperatorTester()
1986 .batch_size(2)
1987 .input_height(pooling_size.second)
1988 .input_width(pooling_size.first)
1989 .pooling_height(pooling_size.second)
1990 .pooling_width(pooling_size.first)
1991 .channels(channels)
1992 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1993 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1994 }
1995}
1996
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1997TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_image_with_output_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]1998 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]1999 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2000 for (size_t channels = 1; channels <= 100; channels += 15) {
2001 AveragePoolingOperatorTester()
2002 .batch_size(2)
2003 .input_height(pooling_size.first)
2004 .input_width(pooling_size.second)
2005 .pooling_height(pooling_size.first)
2006 .pooling_width(pooling_size.second)
2007 .channels(channels)
2008 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2009 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2010 AveragePoolingOperatorTester()
2011 .batch_size(2)
2012 .input_height(pooling_size.second)
2013 .input_width(pooling_size.first)
2014 .pooling_height(pooling_size.second)
2015 .pooling_width(pooling_size.first)
2016 .channels(channels)
2017 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2018 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2019 }
2020}
2021
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2022TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_image_with_input_scale) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2023 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2024 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2025 for (size_t channels = 1; channels <= 100; channels += 15) {
2026 for (float input_scale = 0.01f; input_scale < 100.0f; input_scale *= 3.14159265f) {
2027 AveragePoolingOperatorTester()
2028 .batch_size(2)
2029 .input_height(pooling_size.first)
2030 .input_width(pooling_size.second)
2031 .pooling_height(pooling_size.first)
2032 .pooling_width(pooling_size.second)
2033 .channels(channels)
2034 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2035 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2036 AveragePoolingOperatorTester()
2037 .batch_size(2)
2038 .input_height(pooling_size.second)
2039 .input_width(pooling_size.first)
2040 .pooling_height(pooling_size.second)
2041 .pooling_width(pooling_size.first)
2042 .channels(channels)
2043 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2044 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2045 }
2046 }
2047}
2048
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2049TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_image_with_input_zero_point) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2050 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2051 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2052 for (size_t channels = 1; channels <= 100; channels += 15) {
2053 for (int32_t input_zero_point = 0; input_zero_point <= 255; input_zero_point += 51) {
2054 AveragePoolingOperatorTester()
2055 .batch_size(2)
2056 .input_height(pooling_size.first)
2057 .input_width(pooling_size.second)
2058 .pooling_height(pooling_size.first)
2059 .pooling_width(pooling_size.second)
2060 .channels(channels)
2061 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2062 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2063 AveragePoolingOperatorTester()
2064 .batch_size(2)
2065 .input_height(pooling_size.second)
2066 .input_width(pooling_size.first)
2067 .pooling_height(pooling_size.second)
2068 .pooling_width(pooling_size.first)
2069 .channels(channels)
2070 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2071 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2072 }
2073 }
2074}
2075
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2076TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_image_with_output_scale) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2077 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2078 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2079 for (size_t channels = 1; channels <= 100; channels += 15) {
2080 for (float output_scale = 0.01f; output_scale < 100.0f; output_scale *= 3.14159265f) {
2081 AveragePoolingOperatorTester()
2082 .batch_size(2)
2083 .input_height(pooling_size.first)
2084 .input_width(pooling_size.second)
2085 .pooling_height(pooling_size.first)
2086 .pooling_width(pooling_size.second)
2087 .channels(channels)
2088 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2089 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2090 AveragePoolingOperatorTester()
2091 .batch_size(2)
2092 .input_height(pooling_size.second)
2093 .input_width(pooling_size.first)
2094 .pooling_height(pooling_size.second)
2095 .pooling_width(pooling_size.first)
2096 .channels(channels)
2097 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2098 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2099 }
2100 }
2101}
2102
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2103TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_image_with_output_zero_point) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2104 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2105 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2106 for (size_t channels = 1; channels <= 100; channels += 15) {
2107 for (int32_t output_zero_point = 0; output_zero_point <= 255; output_zero_point += 51) {
2108 AveragePoolingOperatorTester()
2109 .batch_size(2)
2110 .input_height(pooling_size.first)
2111 .input_width(pooling_size.second)
2112 .pooling_height(pooling_size.first)
2113 .pooling_width(pooling_size.second)
2114 .channels(channels)
2115 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2116 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2117 AveragePoolingOperatorTester()
2118 .batch_size(2)
2119 .input_height(pooling_size.second)
2120 .input_width(pooling_size.first)
2121 .pooling_height(pooling_size.second)
2122 .pooling_width(pooling_size.first)
2123 .channels(channels)
2124 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2125 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2126 }
2127 }
2128}
2129
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2130TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_image_with_qmin) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2131 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2132 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2133 for (size_t channels = 1; channels <= 100; channels += 15) {
2134 AveragePoolingOperatorTester()
2135 .batch_size(2)
2136 .input_height(pooling_size.first)
2137 .input_width(pooling_size.second)
2138 .pooling_height(pooling_size.first)
2139 .pooling_width(pooling_size.second)
2140 .channels(channels)
2141 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2142 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2143 AveragePoolingOperatorTester()
2144 .batch_size(2)
2145 .input_height(pooling_size.second)
2146 .input_width(pooling_size.first)
2147 .pooling_height(pooling_size.second)
2148 .pooling_width(pooling_size.first)
2149 .channels(channels)
2150 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2151 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2152 }
2153}
2154
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2155TEST(AVERAGE_POOLING_NHWC_QU8, batched_small_image_with_qmax) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2156 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2157 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.qu8.gavgpool.mr);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2158 for (size_t channels = 1; channels <= 100; channels += 15) {
2159 AveragePoolingOperatorTester()
2160 .batch_size(2)
2161 .input_height(pooling_size.first)
2162 .input_width(pooling_size.second)
2163 .pooling_height(pooling_size.first)
2164 .pooling_width(pooling_size.second)
2165 .channels(channels)
2166 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2167 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2168 AveragePoolingOperatorTester()
2169 .batch_size(2)
2170 .input_height(pooling_size.second)
2171 .input_width(pooling_size.first)
2172 .pooling_height(pooling_size.second)
2173 .pooling_width(pooling_size.first)
2174 .channels(channels)
2175 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2176 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2177 }
2178}
2179
2180/**************************** GAVGPOOL path, multipass ****************************/
2181
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2182TEST(AVERAGE_POOLING_NHWC_QU8, large_image) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2183 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2184 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2185 for (size_t channels = 1; channels <= 100; channels += 15) {
2186 AveragePoolingOperatorTester()
2187 .input_height(pooling_size.first)
2188 .input_width(pooling_size.second)
2189 .pooling_height(pooling_size.first)
2190 .pooling_width(pooling_size.second)
2191 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2192 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2193 AveragePoolingOperatorTester()
2194 .input_height(pooling_size.second)
2195 .input_width(pooling_size.first)
2196 .pooling_height(pooling_size.second)
2197 .pooling_width(pooling_size.first)
2198 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2199 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2200 }
2201}
2202
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2203TEST(AVERAGE_POOLING_NHWC_QU8, large_image_with_width_padding) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2204 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2205 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2206 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2207 for (size_t padding_left = 1; padding_left <= 2; padding_left++) {
2208 AveragePoolingOperatorTester()
2209 .input_height(pooling_size.first)
2210 .input_width(pooling_size.second - padding_left)
2211 .padding_left(padding_left)
2212 .pooling_height(pooling_size.first)
2213 .pooling_width(pooling_size.second)
2214 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2215 .TestQU8();
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2216 AveragePoolingOperatorTester()
2217 .input_height(pooling_size.second)
2218 .input_width(pooling_size.first - padding_left)
2219 .padding_left(padding_left)
2220 .pooling_height(pooling_size.second)
2221 .pooling_width(pooling_size.first)
2222 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2223 .TestQU8();
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2224 }
2225 for (size_t padding_right = 1; padding_right <= 2; padding_right++) {
2226 AveragePoolingOperatorTester()
2227 .input_height(pooling_size.first)
2228 .input_width(pooling_size.second - padding_right)
2229 .padding_right(padding_right)
2230 .pooling_height(pooling_size.first)
2231 .pooling_width(pooling_size.second)
2232 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2233 .TestQU8();
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2234 AveragePoolingOperatorTester()
2235 .input_height(pooling_size.second)
2236 .input_width(pooling_size.first - padding_right)
2237 .padding_right(padding_right)
2238 .pooling_height(pooling_size.second)
2239 .pooling_width(pooling_size.first)
2240 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2241 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2242 }
2243 }
2244}
2245
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2246TEST(AVERAGE_POOLING_NHWC_QU8, large_image_with_height_padding) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2247 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2248 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2249 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2250 for (size_t padding_top = 1; padding_top <= 2; padding_top++) {
2251 AveragePoolingOperatorTester()
2252 .input_height(pooling_size.first - padding_top)
2253 .input_width(pooling_size.second)
2254 .padding_top(padding_top)
2255 .pooling_height(pooling_size.first)
2256 .pooling_width(pooling_size.second)
2257 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2258 .TestQU8();
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2259 AveragePoolingOperatorTester()
2260 .input_height(pooling_size.second - padding_top)
2261 .input_width(pooling_size.first)
2262 .padding_top(padding_top)
2263 .pooling_height(pooling_size.second)
2264 .pooling_width(pooling_size.first)
2265 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2266 .TestQU8();
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2267 }
2268 for (size_t padding_bottom = 0; padding_bottom <= 1; padding_bottom++) {
2269 AveragePoolingOperatorTester()
2270 .input_height(pooling_size.first - padding_bottom)
2271 .input_width(pooling_size.second)
2272 .padding_bottom(padding_bottom)
2273 .pooling_height(pooling_size.first)
2274 .pooling_width(pooling_size.second)
2275 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2276 .TestQU8();
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2277 AveragePoolingOperatorTester()
2278 .input_height(pooling_size.second - padding_bottom)
2279 .input_width(pooling_size.first)
2280 .padding_bottom(padding_bottom)
2281 .pooling_height(pooling_size.second)
2282 .pooling_width(pooling_size.first)
2283 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2284 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2285 }
2286 }
2287}
2288
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2289TEST(AVERAGE_POOLING_NHWC_QU8, large_image_with_input_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2290 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2291 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2292 for (size_t channels = 1; channels <= 100; channels += 15) {
2293 AveragePoolingOperatorTester()
2294 .input_height(pooling_size.first)
2295 .input_width(pooling_size.second)
2296 .pooling_height(pooling_size.first)
2297 .pooling_width(pooling_size.second)
2298 .channels(channels)
2299 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2300 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2301 AveragePoolingOperatorTester()
2302 .input_height(pooling_size.second)
2303 .input_width(pooling_size.first)
2304 .pooling_height(pooling_size.second)
2305 .pooling_width(pooling_size.first)
2306 .channels(channels)
2307 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2308 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2309 }
2310}
2311
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2312TEST(AVERAGE_POOLING_NHWC_QU8, large_image_with_output_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2313 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2314 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2315 for (size_t channels = 1; channels <= 100; channels += 15) {
2316 AveragePoolingOperatorTester()
2317 .input_height(pooling_size.first)
2318 .input_width(pooling_size.second)
2319 .pooling_height(pooling_size.first)
2320 .pooling_width(pooling_size.second)
2321 .channels(channels)
2322 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2323 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2324 AveragePoolingOperatorTester()
2325 .input_height(pooling_size.second)
2326 .input_width(pooling_size.first)
2327 .pooling_height(pooling_size.second)
2328 .pooling_width(pooling_size.first)
2329 .channels(channels)
2330 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2331 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2332 }
2333}
2334
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2335TEST(AVERAGE_POOLING_NHWC_QU8, large_image_with_input_scale) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2336 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2337 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2338 for (size_t channels = 1; channels <= 100; channels += 15) {
2339 for (float input_scale = 0.01f; input_scale < 100.0f; input_scale *= 3.14159265f) {
2340 AveragePoolingOperatorTester()
2341 .input_height(pooling_size.first)
2342 .input_width(pooling_size.second)
2343 .pooling_height(pooling_size.first)
2344 .pooling_width(pooling_size.second)
2345 .channels(channels)
2346 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2347 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2348 AveragePoolingOperatorTester()
2349 .input_height(pooling_size.second)
2350 .input_width(pooling_size.first)
2351 .pooling_height(pooling_size.second)
2352 .pooling_width(pooling_size.first)
2353 .channels(channels)
2354 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2355 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2356 }
2357 }
2358}
2359
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2360TEST(AVERAGE_POOLING_NHWC_QU8, large_image_with_input_zero_point) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2361 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2362 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2363 for (size_t channels = 1; channels <= 100; channels += 15) {
2364 for (int32_t input_zero_point = 0; input_zero_point <= 255; input_zero_point += 51) {
2365 AveragePoolingOperatorTester()
2366 .input_height(pooling_size.first)
2367 .input_width(pooling_size.second)
2368 .pooling_height(pooling_size.first)
2369 .pooling_width(pooling_size.second)
2370 .channels(channels)
2371 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2372 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2373 AveragePoolingOperatorTester()
2374 .input_height(pooling_size.second)
2375 .input_width(pooling_size.first)
2376 .pooling_height(pooling_size.second)
2377 .pooling_width(pooling_size.first)
2378 .channels(channels)
2379 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2380 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2381 }
2382 }
2383}
2384
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2385TEST(AVERAGE_POOLING_NHWC_QU8, large_image_with_output_scale) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2386 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2387 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2388 for (size_t channels = 1; channels <= 100; channels += 15) {
2389 for (float output_scale = 0.01f; output_scale < 100.0f; output_scale *= 3.14159265f) {
2390 AveragePoolingOperatorTester()
2391 .input_height(pooling_size.first)
2392 .input_width(pooling_size.second)
2393 .pooling_height(pooling_size.first)
2394 .pooling_width(pooling_size.second)
2395 .channels(channels)
2396 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2397 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2398 AveragePoolingOperatorTester()
2399 .input_height(pooling_size.second)
2400 .input_width(pooling_size.first)
2401 .pooling_height(pooling_size.second)
2402 .pooling_width(pooling_size.first)
2403 .channels(channels)
2404 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2405 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2406 }
2407 }
2408}
2409
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2410TEST(AVERAGE_POOLING_NHWC_QU8, large_image_with_output_zero_point) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2411 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2412 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2413 for (size_t channels = 1; channels <= 100; channels += 15) {
2414 for (int32_t output_zero_point = 0; output_zero_point <= 255; output_zero_point += 51) {
2415 AveragePoolingOperatorTester()
2416 .input_height(pooling_size.first)
2417 .input_width(pooling_size.second)
2418 .pooling_height(pooling_size.first)
2419 .pooling_width(pooling_size.second)
2420 .channels(channels)
2421 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2422 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2423 AveragePoolingOperatorTester()
2424 .input_height(pooling_size.second)
2425 .input_width(pooling_size.first)
2426 .pooling_height(pooling_size.second)
2427 .pooling_width(pooling_size.first)
2428 .channels(channels)
2429 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2430 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2431 }
2432 }
2433}
2434
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2435TEST(AVERAGE_POOLING_NHWC_QU8, large_image_with_qmin) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2436 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2437 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2438 for (size_t channels = 1; channels <= 100; channels += 15) {
2439 AveragePoolingOperatorTester()
2440 .input_height(pooling_size.first)
2441 .input_width(pooling_size.second)
2442 .pooling_height(pooling_size.first)
2443 .pooling_width(pooling_size.second)
2444 .channels(channels)
2445 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2446 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2447 AveragePoolingOperatorTester()
2448 .input_height(pooling_size.second)
2449 .input_width(pooling_size.first)
2450 .pooling_height(pooling_size.second)
2451 .pooling_width(pooling_size.first)
2452 .channels(channels)
2453 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2454 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2455 }
2456}
2457
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2458TEST(AVERAGE_POOLING_NHWC_QU8, large_image_with_qmax) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2459 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2460 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2461 for (size_t channels = 1; channels <= 100; channels += 15) {
2462 AveragePoolingOperatorTester()
2463 .input_height(pooling_size.first)
2464 .input_width(pooling_size.second)
2465 .pooling_height(pooling_size.first)
2466 .pooling_width(pooling_size.second)
2467 .channels(channels)
2468 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2469 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2470 AveragePoolingOperatorTester()
2471 .input_height(pooling_size.second)
2472 .input_width(pooling_size.first)
2473 .pooling_height(pooling_size.second)
2474 .pooling_width(pooling_size.first)
2475 .channels(channels)
2476 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2477 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2478 }
2479}
2480
2481/**************************** GAVGPOOL path, multipass, batched ****************************/
2482
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2483TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_image) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2484 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2485 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2486 for (size_t channels = 1; channels <= 100; channels += 15) {
2487 AveragePoolingOperatorTester()
2488 .batch_size(2)
2489 .input_height(pooling_size.first)
2490 .input_width(pooling_size.second)
2491 .pooling_height(pooling_size.first)
2492 .pooling_width(pooling_size.second)
2493 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2494 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2495 AveragePoolingOperatorTester()
2496 .batch_size(2)
2497 .input_height(pooling_size.second)
2498 .input_width(pooling_size.first)
2499 .pooling_height(pooling_size.second)
2500 .pooling_width(pooling_size.first)
2501 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2502 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2503 }
2504}
2505
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2506TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_image_with_width_padding) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2507 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2508 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2509 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2510 for (size_t padding_left = 1; padding_left <= 2; padding_left++) {
2511 AveragePoolingOperatorTester()
2512 .batch_size(2)
2513 .input_height(pooling_size.first)
2514 .input_width(pooling_size.second - padding_left)
2515 .padding_left(padding_left)
2516 .pooling_height(pooling_size.first)
2517 .pooling_width(pooling_size.second)
2518 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2519 .TestQU8();
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2520 AveragePoolingOperatorTester()
2521 .batch_size(2)
2522 .input_height(pooling_size.second)
2523 .input_width(pooling_size.first - padding_left)
2524 .padding_left(padding_left)
2525 .pooling_height(pooling_size.second)
2526 .pooling_width(pooling_size.first)
2527 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2528 .TestQU8();
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2529 }
2530 for (size_t padding_right = 1; padding_right <= 2; padding_right++) {
2531 AveragePoolingOperatorTester()
2532 .batch_size(2)
2533 .input_height(pooling_size.first)
2534 .input_width(pooling_size.second - padding_right)
2535 .padding_right(padding_right)
2536 .pooling_height(pooling_size.first)
2537 .pooling_width(pooling_size.second)
2538 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2539 .TestQU8();
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2540 AveragePoolingOperatorTester()
2541 .batch_size(2)
2542 .input_height(pooling_size.second)
2543 .input_width(pooling_size.first - padding_right)
2544 .padding_right(padding_right)
2545 .pooling_height(pooling_size.second)
2546 .pooling_width(pooling_size.first)
2547 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2548 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2549 }
2550 }
2551}
2552
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2553TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_image_with_height_padding) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2554 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2555 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2556 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2557 for (size_t padding_top = 1; padding_top <= 2; padding_top++) {
2558 AveragePoolingOperatorTester()
2559 .batch_size(2)
2560 .input_height(pooling_size.first - padding_top)
2561 .input_width(pooling_size.second)
2562 .padding_top(padding_top)
2563 .pooling_height(pooling_size.first)
2564 .pooling_width(pooling_size.second)
2565 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2566 .TestQU8();
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2567 AveragePoolingOperatorTester()
2568 .batch_size(2)
2569 .input_height(pooling_size.second - padding_top)
2570 .input_width(pooling_size.first)
2571 .padding_top(padding_top)
2572 .pooling_height(pooling_size.second)
2573 .pooling_width(pooling_size.first)
2574 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2575 .TestQU8();
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2576 }
2577 for (size_t padding_bottom = 1; padding_bottom <= 2; padding_bottom++) {
2578 AveragePoolingOperatorTester()
2579 .batch_size(2)
2580 .input_height(pooling_size.first - padding_bottom)
2581 .input_width(pooling_size.second)
2582 .padding_bottom(padding_bottom)
2583 .pooling_height(pooling_size.first)
2584 .pooling_width(pooling_size.second)
2585 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2586 .TestQU8();
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]2587 AveragePoolingOperatorTester()
2588 .batch_size(2)
2589 .input_height(pooling_size.second - padding_bottom)
2590 .input_width(pooling_size.first)
2591 .padding_bottom(padding_bottom)
2592 .pooling_height(pooling_size.second)
2593 .pooling_width(pooling_size.first)
2594 .channels(channels)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2595 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2596 }
2597 }
2598}
2599
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2600TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_image_with_input_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2601 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2602 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2603 for (size_t channels = 1; channels <= 100; channels += 15) {
2604 AveragePoolingOperatorTester()
2605 .batch_size(2)
2606 .input_height(pooling_size.first)
2607 .input_width(pooling_size.second)
2608 .pooling_height(pooling_size.first)
2609 .pooling_width(pooling_size.second)
2610 .channels(channels)
2611 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2612 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2613 AveragePoolingOperatorTester()
2614 .batch_size(2)
2615 .input_height(pooling_size.second)
2616 .input_width(pooling_size.first)
2617 .pooling_height(pooling_size.second)
2618 .pooling_width(pooling_size.first)
2619 .channels(channels)
2620 .input_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2621 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2622 }
2623}
2624
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2625TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_image_with_output_stride) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2626 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2627 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2628 for (size_t channels = 1; channels <= 100; channels += 15) {
2629 AveragePoolingOperatorTester()
2630 .batch_size(2)
2631 .input_height(pooling_size.first)
2632 .input_width(pooling_size.second)
2633 .pooling_height(pooling_size.first)
2634 .pooling_width(pooling_size.second)
2635 .channels(channels)
2636 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2637 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2638 AveragePoolingOperatorTester()
2639 .batch_size(2)
2640 .input_height(pooling_size.second)
2641 .input_width(pooling_size.first)
2642 .pooling_height(pooling_size.second)
2643 .pooling_width(pooling_size.first)
2644 .channels(channels)
2645 .output_pixel_stride(2 * channels + 3)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2646 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2647 }
2648}
2649
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2650TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_image_with_input_scale) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2651 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2652 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2653 for (size_t channels = 1; channels <= 100; channels += 15) {
2654 for (float input_scale = 0.01f; input_scale < 100.0f; input_scale *= 3.14159265f) {
2655 AveragePoolingOperatorTester()
2656 .batch_size(2)
2657 .input_height(pooling_size.first)
2658 .input_width(pooling_size.second)
2659 .pooling_height(pooling_size.first)
2660 .pooling_width(pooling_size.second)
2661 .channels(channels)
2662 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2663 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2664 AveragePoolingOperatorTester()
2665 .batch_size(2)
2666 .input_height(pooling_size.second)
2667 .input_width(pooling_size.first)
2668 .pooling_height(pooling_size.second)
2669 .pooling_width(pooling_size.first)
2670 .channels(channels)
2671 .input_scale(input_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2672 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2673 }
2674 }
2675}
2676
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2677TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_image_with_input_zero_point) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2678 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2679 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2680 for (size_t channels = 1; channels <= 100; channels += 15) {
2681 for (int32_t input_zero_point = 0; input_zero_point <= 255; input_zero_point += 51) {
2682 AveragePoolingOperatorTester()
2683 .batch_size(2)
2684 .input_height(pooling_size.first)
2685 .input_width(pooling_size.second)
2686 .pooling_height(pooling_size.first)
2687 .pooling_width(pooling_size.second)
2688 .channels(channels)
2689 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2690 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2691 AveragePoolingOperatorTester()
2692 .batch_size(2)
2693 .input_height(pooling_size.second)
2694 .input_width(pooling_size.first)
2695 .pooling_height(pooling_size.second)
2696 .pooling_width(pooling_size.first)
2697 .channels(channels)
2698 .input_zero_point(uint8_t(input_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2699 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2700 }
2701 }
2702}
2703
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2704TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_image_with_output_scale) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2705 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2706 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2707 for (size_t channels = 1; channels <= 100; channels += 15) {
2708 for (float output_scale = 0.01f; output_scale < 100.0f; output_scale *= 3.14159265f) {
2709 AveragePoolingOperatorTester()
2710 .batch_size(2)
2711 .input_height(pooling_size.first)
2712 .input_width(pooling_size.second)
2713 .pooling_height(pooling_size.first)
2714 .pooling_width(pooling_size.second)
2715 .channels(channels)
2716 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2717 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2718 AveragePoolingOperatorTester()
2719 .batch_size(2)
2720 .input_height(pooling_size.second)
2721 .input_width(pooling_size.first)
2722 .pooling_height(pooling_size.second)
2723 .pooling_width(pooling_size.first)
2724 .channels(channels)
2725 .output_scale(output_scale)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2726 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2727 }
2728 }
2729}
2730
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2731TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_image_with_output_zero_point) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2732 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2733 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2734 for (size_t channels = 1; channels <= 100; channels += 15) {
2735 for (int32_t output_zero_point = 0; output_zero_point <= 255; output_zero_point += 51) {
2736 AveragePoolingOperatorTester()
2737 .batch_size(2)
2738 .input_height(pooling_size.first)
2739 .input_width(pooling_size.second)
2740 .pooling_height(pooling_size.first)
2741 .pooling_width(pooling_size.second)
2742 .channels(channels)
2743 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2744 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2745 AveragePoolingOperatorTester()
2746 .batch_size(2)
2747 .input_height(pooling_size.second)
2748 .input_width(pooling_size.first)
2749 .pooling_height(pooling_size.second)
2750 .pooling_width(pooling_size.first)
2751 .channels(channels)
2752 .output_zero_point(uint8_t(output_zero_point))
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2753 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2754 }
2755 }
2756}
2757
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2758TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_image_with_qmin) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2759 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2760 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2761 for (size_t channels = 1; channels <= 100; channels += 15) {
2762 AveragePoolingOperatorTester()
2763 .batch_size(2)
2764 .input_height(pooling_size.first)
2765 .input_width(pooling_size.second)
2766 .pooling_height(pooling_size.first)
2767 .pooling_width(pooling_size.second)
2768 .channels(channels)
2769 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2770 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2771 AveragePoolingOperatorTester()
2772 .batch_size(2)
2773 .input_height(pooling_size.second)
2774 .input_width(pooling_size.first)
2775 .pooling_height(pooling_size.second)
2776 .pooling_width(pooling_size.first)
2777 .channels(channels)
2778 .qmin(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2779 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2780 }
2781}
2782
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2783TEST(AVERAGE_POOLING_NHWC_QU8, batched_large_image_with_qmax) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2784 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2785 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.qu8.gavgpool.mr * 2);
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2786 for (size_t channels = 1; channels <= 100; channels += 15) {
2787 AveragePoolingOperatorTester()
2788 .batch_size(2)
2789 .input_height(pooling_size.first)
2790 .input_width(pooling_size.second)
2791 .pooling_height(pooling_size.first)
2792 .pooling_width(pooling_size.second)
2793 .channels(channels)
2794 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2795 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2796 AveragePoolingOperatorTester()
2797 .batch_size(2)
2798 .input_height(pooling_size.second)
2799 .input_width(pooling_size.first)
2800 .pooling_height(pooling_size.second)
2801 .pooling_width(pooling_size.first)
2802 .channels(channels)
2803 .qmax(128)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2804 .TestQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2805 }
2806}
2807
2808/**************************** AVGPOOL path, setup ****************************/
2809
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2810TEST(AVERAGE_POOLING_NHWC_QU8, setup_increasing_batch) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]2811 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2812 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2813 .batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2814 .next_batch_size(5)
2815 .input_height(8)
2816 .input_width(8)
2817 .pooling_height(5)
2818 .pooling_width(3)
2819 .channels(24)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2820 .TestSetupQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2821}
2822
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2823TEST(AVERAGE_POOLING_NHWC_QU8, setup_decreasing_batch) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]2824 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2825 AveragePoolingOperatorTester()
2826 .batch_size(5)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2827 .next_batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2828 .input_height(8)
2829 .input_width(8)
2830 .pooling_height(5)
2831 .pooling_width(3)
2832 .channels(24)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2833 .TestSetupQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2834}
2835
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2836TEST(AVERAGE_POOLING_NHWC_QU8, setup_changing_height) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]2837 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2838 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2839 .batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2840 .input_height(8)
2841 .input_width(8)
2842 .next_input_height(9)
2843 .pooling_height(5)
2844 .pooling_width(3)
2845 .channels(24)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2846 .TestSetupQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2847 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2848 .batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2849 .input_height(8)
2850 .input_width(8)
2851 .next_input_height(7)
2852 .pooling_height(5)
2853 .pooling_width(3)
2854 .channels(24)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2855 .TestSetupQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2856}
2857
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2858TEST(AVERAGE_POOLING_NHWC_QU8, setup_changing_width) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]2859 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2860 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2861 .batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2862 .input_height(8)
2863 .input_width(8)
2864 .next_input_width(9)
2865 .pooling_height(5)
2866 .pooling_width(3)
2867 .channels(24)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2868 .TestSetupQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2869 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2870 .batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2871 .input_height(8)
2872 .input_width(8)
2873 .next_input_width(7)
2874 .pooling_height(5)
2875 .pooling_width(3)
2876 .channels(24)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2877 .TestSetupQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2878}
2879
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2880TEST(AVERAGE_POOLING_NHWC_QU8, setup_swap_height_and_width) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]2881 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2882 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2883 .batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2884 .input_height(9)
2885 .input_width(8)
2886 .next_input_height(8)
2887 .next_input_width(9)
2888 .pooling_height(5)
2889 .pooling_width(3)
2890 .channels(24)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2891 .TestSetupQU8();
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2892}
2893
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2894TEST(AVERAGE_POOLING_NHWC_QU8, setup_local_to_global) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]2895 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]2896 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2897 .batch_size(2)
2898 .input_height(6)
2899 .input_width(5)
2900 .next_input_height(5)
2901 .next_input_width(3)
2902 .pooling_height(5)
2903 .pooling_width(3)
2904 .channels(24)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2905 .TestSetupQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2906}
2907
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2908TEST(AVERAGE_POOLING_NHWC_QU8, setup_global_to_local) {
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2909 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
2910 AveragePoolingOperatorTester()
2911 .batch_size(2)
2912 .input_height(5)
2913 .input_width(3)
2914 .next_input_height(6)
2915 .next_input_width(5)
2916 .pooling_height(5)
2917 .pooling_width(3)
2918 .channels(24)
Marat Dukhan08b7a972020-07-14 18:17:29 -0700[diff] [blame]2919 .TestSetupQU8();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]2920}
2921
2922/**************************** AVGPOOL path, unipass ****************************/
2923
2924TEST(AVERAGE_POOLING_NHWC_F32, small_pool) {
2925 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
2926 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
2927 for (size_t channels = 1; channels <= 100; channels += 15) {
2928 AveragePoolingOperatorTester()
2929 .input_height(pooling_size.first + 3)
2930 .input_width(pooling_size.second + 2)
2931 .pooling_height(pooling_size.first)
2932 .pooling_width(pooling_size.second)
2933 .channels(channels)
2934 .TestF32();
2935 AveragePoolingOperatorTester()
2936 .input_height(pooling_size.second + 3)
2937 .input_width(pooling_size.first + 2)
2938 .pooling_height(pooling_size.second)
2939 .pooling_width(pooling_size.first)
2940 .channels(channels)
2941 .TestF32();
2942 }
2943}
2944
2945TEST(AVERAGE_POOLING_NHWC_F32, small_pool_with_stride) {
2946 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
2947 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
2948 for (size_t channels = 1; channels <= 100; channels += 15) {
2949 for (size_t stride_width = 1; stride_width <= 2; stride_width++) {
2950 for (size_t stride_height = 1; stride_height <= 2; stride_height++) {
2951 if (stride_width == 1 && stride_height == 1) {
2952 continue;
2953 }
2954
2955 AveragePoolingOperatorTester()
2956 .input_height(pooling_size.first + 3)
2957 .input_width(pooling_size.second + 2)
2958 .pooling_height(pooling_size.first)
2959 .pooling_width(pooling_size.second)
2960 .stride_height(stride_height)
2961 .stride_width(stride_width)
2962 .channels(channels)
2963 .TestF32();
2964 AveragePoolingOperatorTester()
2965 .input_height(pooling_size.second + 3)
2966 .input_width(pooling_size.first + 2)
2967 .pooling_height(pooling_size.second)
2968 .pooling_width(pooling_size.first)
2969 .stride_height(stride_height)
2970 .stride_width(stride_width)
2971 .channels(channels)
2972 .TestF32();
2973 }
2974 }
2975 }
2976}
2977
2978TEST(AVERAGE_POOLING_NHWC_F32, small_pool_with_width_padding) {
2979 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
2980 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
2981 for (size_t channels = 1; channels <= 100; channels += 15) {
2982 for (size_t stride = 1; stride <= 2; stride++) {
2983 for (size_t padding_left = 0; padding_left <= 1; padding_left++) {
2984 for (size_t padding_right = 0; padding_right <= 1; padding_right++) {
2985 AveragePoolingOperatorTester()
2986 .input_height(pooling_size.first + 3)
2987 .input_width(pooling_size.second + 2)
2988 .padding_left(padding_left)
2989 .padding_right(padding_right)
2990 .pooling_height(pooling_size.first)
2991 .pooling_width(pooling_size.second)
2992 .stride(stride)
2993 .channels(channels)
2994 .TestF32();
2995 AveragePoolingOperatorTester()
2996 .input_height(pooling_size.second + 3)
2997 .input_width(pooling_size.first + 2)
2998 .padding_left(padding_left)
2999 .padding_right(padding_right)
3000 .pooling_height(pooling_size.second)
3001 .pooling_width(pooling_size.first)
3002 .stride(stride)
3003 .channels(channels)
3004 .TestF32();
3005 }
3006 }
3007 }
3008 }
3009}
3010
3011TEST(AVERAGE_POOLING_NHWC_F32, small_pool_with_height_padding) {
3012 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3013 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3014 for (size_t channels = 1; channels <= 100; channels += 15) {
3015 for (size_t stride = 1; stride <= 2; stride++) {
3016 for (size_t padding_top = 0; padding_top <= 1; padding_top++) {
3017 for (size_t padding_bottom = 0; padding_bottom <= 1; padding_bottom++) {
3018 AveragePoolingOperatorTester()
3019 .input_height(pooling_size.first + 3)
3020 .input_width(pooling_size.second + 2)
3021 .padding_top(padding_top)
3022 .padding_bottom(padding_bottom)
3023 .pooling_height(pooling_size.first)
3024 .pooling_width(pooling_size.second)
3025 .stride(stride)
3026 .channels(channels)
3027 .TestF32();
3028 AveragePoolingOperatorTester()
3029 .input_height(pooling_size.second + 3)
3030 .input_width(pooling_size.first + 2)
3031 .padding_top(padding_top)
3032 .padding_bottom(padding_bottom)
3033 .pooling_height(pooling_size.second)
3034 .pooling_width(pooling_size.first)
3035 .stride(stride)
3036 .channels(channels)
3037 .TestF32();
3038 }
3039 }
3040 }
3041 }
3042}
3043
3044TEST(AVERAGE_POOLING_NHWC_F32, small_pool_with_tf_same_padding) {
3045 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3046 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3047 for (size_t channels = 1; channels <= 100; channels += 15) {
3048 for (size_t stride = 1; stride <= 2; stride++) {
3049 for (size_t input_height = pooling_size.first + 3; input_height <= pooling_size.first + 4; input_height++) {
3050 AveragePoolingOperatorTester()
3051 .input_height(input_height)
3052 .input_width(pooling_size.second + 2)
3053 .padding_tf_same(true)
3054 .pooling_height(pooling_size.first)
3055 .pooling_width(pooling_size.second)
3056 .stride(stride)
3057 .channels(channels)
3058 .TestF32();
3059 }
3060 for (size_t input_width = pooling_size.second + 2; input_width <= pooling_size.second + 3; input_width++) {
3061 AveragePoolingOperatorTester()
3062 .input_height(pooling_size.first + 3)
3063 .input_width(input_width)
3064 .padding_tf_same(true)
3065 .pooling_height(pooling_size.first)
3066 .pooling_width(pooling_size.second)
3067 .stride(stride)
3068 .channels(channels)
3069 .TestF32();
3070 }
3071 for (size_t input_height = pooling_size.second + 3; input_height <= pooling_size.second + 4; input_height++) {
3072 AveragePoolingOperatorTester()
3073 .input_height(input_height)
3074 .input_width(pooling_size.first + 2)
3075 .padding_tf_same(true)
3076 .pooling_height(pooling_size.second)
3077 .pooling_width(pooling_size.first)
3078 .stride(stride)
3079 .channels(channels)
3080 .TestF32();
3081 }
3082 for (size_t input_width = pooling_size.first + 2; input_width <= pooling_size.first + 3; input_width++) {
3083 AveragePoolingOperatorTester()
3084 .input_height(pooling_size.second + 3)
3085 .input_width(input_width)
3086 .padding_tf_same(true)
3087 .pooling_height(pooling_size.second)
3088 .pooling_width(pooling_size.first)
3089 .stride(stride)
3090 .channels(channels)
3091 .TestF32();
3092 }
3093 }
3094 }
3095}
3096
3097TEST(AVERAGE_POOLING_NHWC_F32, small_pool_with_input_stride) {
3098 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3099 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3100 for (size_t channels = 1; channels <= 100; channels += 15) {
3101 AveragePoolingOperatorTester()
3102 .input_height(pooling_size.first + 3)
3103 .input_width(pooling_size.second + 2)
3104 .pooling_height(pooling_size.first)
3105 .pooling_width(pooling_size.second)
3106 .channels(channels)
3107 .input_pixel_stride(2 * channels + 3)
3108 .TestF32();
3109 AveragePoolingOperatorTester()
3110 .input_height(pooling_size.second + 3)
3111 .input_width(pooling_size.first + 2)
3112 .pooling_height(pooling_size.second)
3113 .pooling_width(pooling_size.first)
3114 .channels(channels)
3115 .input_pixel_stride(2 * channels + 3)
3116 .TestF32();
3117 }
3118}
3119
3120TEST(AVERAGE_POOLING_NHWC_F32, small_pool_with_output_stride) {
3121 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3122 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3123 for (size_t channels = 1; channels <= 100; channels += 15) {
3124 AveragePoolingOperatorTester()
3125 .input_height(pooling_size.first + 3)
3126 .input_width(pooling_size.second + 2)
3127 .pooling_height(pooling_size.first)
3128 .pooling_width(pooling_size.second)
3129 .channels(channels)
3130 .output_pixel_stride(2 * channels + 3)
3131 .TestF32();
3132 AveragePoolingOperatorTester()
3133 .input_height(pooling_size.second + 3)
3134 .input_width(pooling_size.first + 2)
3135 .pooling_height(pooling_size.second)
3136 .pooling_width(pooling_size.first)
3137 .channels(channels)
3138 .output_pixel_stride(2 * channels + 3)
3139 .TestF32();
3140 }
3141}
3142
3143TEST(AVERAGE_POOLING_NHWC_F32, small_pool_with_qmin) {
3144 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3145 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3146 for (size_t channels = 1; channels <= 100; channels += 15) {
3147 AveragePoolingOperatorTester()
3148 .input_height(pooling_size.first + 3)
3149 .input_width(pooling_size.second + 2)
3150 .pooling_height(pooling_size.first)
3151 .pooling_width(pooling_size.second)
3152 .channels(channels)
3153 .qmin(128)
3154 .TestF32();
3155 AveragePoolingOperatorTester()
3156 .input_height(pooling_size.second + 3)
3157 .input_width(pooling_size.first + 2)
3158 .pooling_height(pooling_size.second)
3159 .pooling_width(pooling_size.first)
3160 .channels(channels)
3161 .qmin(128)
3162 .TestF32();
3163 }
3164}
3165
3166TEST(AVERAGE_POOLING_NHWC_F32, small_pool_with_qmax) {
3167 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3168 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3169 for (size_t channels = 1; channels <= 100; channels += 15) {
3170 AveragePoolingOperatorTester()
3171 .input_height(pooling_size.first + 3)
3172 .input_width(pooling_size.second + 2)
3173 .pooling_height(pooling_size.first)
3174 .pooling_width(pooling_size.second)
3175 .channels(channels)
3176 .qmax(128)
3177 .TestF32();
3178 AveragePoolingOperatorTester()
3179 .input_height(pooling_size.second + 3)
3180 .input_width(pooling_size.first + 2)
3181 .pooling_height(pooling_size.second)
3182 .pooling_width(pooling_size.first)
3183 .channels(channels)
3184 .qmax(128)
3185 .TestF32();
3186 }
3187}
3188
3189/**************************** AVGPOOL path, unipass, batched ****************************/
3190
3191TEST(AVERAGE_POOLING_NHWC_F32, batched_small_pool) {
3192 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3193 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3194 for (size_t channels = 1; channels <= 100; channels += 15) {
3195 AveragePoolingOperatorTester()
3196 .batch_size(2)
3197 .input_height(pooling_size.first + 3)
3198 .input_width(pooling_size.second + 2)
3199 .pooling_height(pooling_size.first)
3200 .pooling_width(pooling_size.second)
3201 .channels(channels)
3202 .TestF32();
3203 AveragePoolingOperatorTester()
3204 .batch_size(2)
3205 .input_height(pooling_size.second + 3)
3206 .input_width(pooling_size.first + 2)
3207 .pooling_height(pooling_size.second)
3208 .pooling_width(pooling_size.first)
3209 .channels(channels)
3210 .TestF32();
3211 }
3212}
3213
3214TEST(AVERAGE_POOLING_NHWC_F32, batched_small_pool_with_stride) {
3215 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3216 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3217 for (size_t channels = 1; channels <= 100; channels += 15) {
3218 for (size_t stride_width = 1; stride_width <= 2; stride_width++) {
3219 for (size_t stride_height = 1; stride_height <= 2; stride_height++) {
3220 if (stride_width == 1 && stride_height == 1) {
3221 continue;
3222 }
3223
3224 AveragePoolingOperatorTester()
3225 .batch_size(2)
3226 .input_height(pooling_size.first + 3)
3227 .input_width(pooling_size.second + 2)
3228 .pooling_height(pooling_size.first)
3229 .pooling_width(pooling_size.second)
3230 .stride_height(stride_height)
3231 .stride_width(stride_width)
3232 .channels(channels)
3233 .TestF32();
3234 AveragePoolingOperatorTester()
3235 .batch_size(2)
3236 .input_height(pooling_size.second + 3)
3237 .input_width(pooling_size.first + 2)
3238 .pooling_height(pooling_size.second)
3239 .pooling_width(pooling_size.first)
3240 .stride_height(stride_height)
3241 .stride_width(stride_width)
3242 .channels(channels)
3243 .TestF32();
3244 }
3245 }
3246 }
3247}
3248
3249TEST(AVERAGE_POOLING_NHWC_F32, batched_small_pool_with_width_padding) {
3250 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3251 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3252 for (size_t channels = 1; channels <= 100; channels += 15) {
3253 for (size_t stride = 1; stride <= 2; stride++) {
3254 for (size_t padding_left = 0; padding_left <= 1; padding_left++) {
3255 for (size_t padding_right = 0; padding_right <= 1; padding_right++) {
3256 AveragePoolingOperatorTester()
3257 .batch_size(2)
3258 .input_height(pooling_size.first + 3)
3259 .input_width(pooling_size.second + 2)
3260 .padding_left(padding_left)
3261 .padding_right(padding_right)
3262 .pooling_height(pooling_size.first)
3263 .pooling_width(pooling_size.second)
3264 .stride(stride)
3265 .channels(channels)
3266 .TestF32();
3267 AveragePoolingOperatorTester()
3268 .batch_size(2)
3269 .input_height(pooling_size.second + 3)
3270 .input_width(pooling_size.first + 2)
3271 .padding_left(padding_left)
3272 .padding_right(padding_right)
3273 .pooling_height(pooling_size.second)
3274 .pooling_width(pooling_size.first)
3275 .stride(stride)
3276 .channels(channels)
3277 .TestF32();
3278 }
3279 }
3280 }
3281 }
3282}
3283
3284TEST(AVERAGE_POOLING_NHWC_F32, batched_small_pool_with_height_padding) {
3285 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3286 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3287 for (size_t channels = 1; channels <= 100; channels += 15) {
3288 for (size_t stride = 1; stride <= 2; stride++) {
3289 for (size_t padding_top = 0; padding_top <= 1; padding_top++) {
3290 for (size_t padding_bottom = 0; padding_bottom <= 1; padding_bottom++) {
3291 AveragePoolingOperatorTester()
3292 .batch_size(2)
3293 .input_height(pooling_size.first + 3)
3294 .input_width(pooling_size.second + 2)
3295 .padding_top(padding_top)
3296 .padding_bottom(padding_bottom)
3297 .pooling_height(pooling_size.first)
3298 .pooling_width(pooling_size.second)
3299 .stride(stride)
3300 .channels(channels)
3301 .TestF32();
3302 AveragePoolingOperatorTester()
3303 .batch_size(2)
3304 .input_height(pooling_size.second + 3)
3305 .input_width(pooling_size.first + 2)
3306 .padding_top(padding_top)
3307 .padding_bottom(padding_bottom)
3308 .pooling_height(pooling_size.second)
3309 .pooling_width(pooling_size.first)
3310 .stride(stride)
3311 .channels(channels)
3312 .TestF32();
3313 }
3314 }
3315 }
3316 }
3317}
3318
3319TEST(AVERAGE_POOLING_NHWC_F32, batched_small_pool_with_tf_same_padding) {
3320 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3321 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3322 for (size_t channels = 1; channels <= 100; channels += 15) {
3323 for (size_t stride = 1; stride <= 2; stride++) {
3324 for (size_t input_height = pooling_size.first + 3; input_height <= pooling_size.first + 4; input_height++) {
3325 AveragePoolingOperatorTester()
3326 .batch_size(2)
3327 .input_height(input_height)
3328 .input_width(pooling_size.second + 2)
3329 .padding_tf_same(true)
3330 .pooling_height(pooling_size.first)
3331 .pooling_width(pooling_size.second)
3332 .stride(stride)
3333 .channels(channels)
3334 .TestF32();
3335 }
3336 for (size_t input_width = pooling_size.second + 2; input_width <= pooling_size.second + 3; input_width++) {
3337 AveragePoolingOperatorTester()
3338 .batch_size(2)
3339 .input_height(pooling_size.first + 3)
3340 .input_width(input_width)
3341 .padding_tf_same(true)
3342 .pooling_height(pooling_size.first)
3343 .pooling_width(pooling_size.second)
3344 .stride(stride)
3345 .channels(channels)
3346 .TestF32();
3347 }
3348 for (size_t input_height = pooling_size.second + 3; input_height <= pooling_size.second + 4; input_height++) {
3349 AveragePoolingOperatorTester()
3350 .batch_size(2)
3351 .input_height(input_height)
3352 .input_width(pooling_size.first + 2)
3353 .padding_tf_same(true)
3354 .pooling_height(pooling_size.second)
3355 .pooling_width(pooling_size.first)
3356 .stride(stride)
3357 .channels(channels)
3358 .TestF32();
3359 }
3360 for (size_t input_width = pooling_size.first + 2; input_width <= pooling_size.first + 3; input_width++) {
3361 AveragePoolingOperatorTester()
3362 .batch_size(2)
3363 .input_height(pooling_size.second + 3)
3364 .input_width(input_width)
3365 .padding_tf_same(true)
3366 .pooling_height(pooling_size.second)
3367 .pooling_width(pooling_size.first)
3368 .stride(stride)
3369 .channels(channels)
3370 .TestF32();
3371 }
3372 }
3373 }
3374}
3375
3376TEST(AVERAGE_POOLING_NHWC_F32, batched_small_pool_with_input_stride) {
3377 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3378 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3379 for (size_t channels = 1; channels <= 100; channels += 15) {
3380 AveragePoolingOperatorTester()
3381 .batch_size(2)
3382 .input_height(pooling_size.first + 3)
3383 .input_width(pooling_size.second + 2)
3384 .pooling_height(pooling_size.first)
3385 .pooling_width(pooling_size.second)
3386 .channels(channels)
3387 .input_pixel_stride(2 * channels + 3)
3388 .TestF32();
3389 AveragePoolingOperatorTester()
3390 .batch_size(2)
3391 .input_height(pooling_size.second + 3)
3392 .input_width(pooling_size.first + 2)
3393 .pooling_height(pooling_size.second)
3394 .pooling_width(pooling_size.first)
3395 .channels(channels)
3396 .input_pixel_stride(2 * channels + 3)
3397 .TestF32();
3398 }
3399}
3400
3401TEST(AVERAGE_POOLING_NHWC_F32, batched_small_pool_with_output_stride) {
3402 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3403 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3404 for (size_t channels = 1; channels <= 100; channels += 15) {
3405 AveragePoolingOperatorTester()
3406 .batch_size(2)
3407 .input_height(pooling_size.first + 3)
3408 .input_width(pooling_size.second + 2)
3409 .pooling_height(pooling_size.first)
3410 .pooling_width(pooling_size.second)
3411 .channels(channels)
3412 .output_pixel_stride(2 * channels + 3)
3413 .TestF32();
3414 AveragePoolingOperatorTester()
3415 .batch_size(2)
3416 .input_height(pooling_size.second + 3)
3417 .input_width(pooling_size.first + 2)
3418 .pooling_height(pooling_size.second)
3419 .pooling_width(pooling_size.first)
3420 .channels(channels)
3421 .output_pixel_stride(2 * channels + 3)
3422 .TestF32();
3423 }
3424}
3425
3426TEST(AVERAGE_POOLING_NHWC_F32, batched_small_pool_with_qmin) {
3427 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3428 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3429 for (size_t channels = 1; channels <= 100; channels += 15) {
3430 AveragePoolingOperatorTester()
3431 .batch_size(2)
3432 .input_height(pooling_size.first + 3)
3433 .input_width(pooling_size.second + 2)
3434 .pooling_height(pooling_size.first)
3435 .pooling_width(pooling_size.second)
3436 .channels(channels)
3437 .qmin(128)
3438 .TestF32();
3439 AveragePoolingOperatorTester()
3440 .batch_size(2)
3441 .input_height(pooling_size.second + 3)
3442 .input_width(pooling_size.first + 2)
3443 .pooling_height(pooling_size.second)
3444 .pooling_width(pooling_size.first)
3445 .channels(channels)
3446 .qmin(128)
3447 .TestF32();
3448 }
3449}
3450
3451TEST(AVERAGE_POOLING_NHWC_F32, batched_small_pool_with_qmax) {
3452 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3453 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.avgpool.mr);
3454 for (size_t channels = 1; channels <= 100; channels += 15) {
3455 AveragePoolingOperatorTester()
3456 .batch_size(2)
3457 .input_height(pooling_size.first + 3)
3458 .input_width(pooling_size.second + 2)
3459 .pooling_height(pooling_size.first)
3460 .pooling_width(pooling_size.second)
3461 .channels(channels)
3462 .qmax(128)
3463 .TestF32();
3464 AveragePoolingOperatorTester()
3465 .batch_size(2)
3466 .input_height(pooling_size.second + 3)
3467 .input_width(pooling_size.first + 2)
3468 .pooling_height(pooling_size.second)
3469 .pooling_width(pooling_size.first)
3470 .channels(channels)
3471 .qmax(128)
3472 .TestF32();
3473 }
3474}
3475
3476/**************************** AVGPOOL path, multipass ****************************/
3477
3478TEST(AVERAGE_POOLING_NHWC_F32, large_pool) {
3479 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3480 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.avgpool.mr * 2);
3481 for (size_t channels = 1; channels <= 100; channels += 15) {
3482 AveragePoolingOperatorTester()
3483 .input_height(pooling_size.first + 3)
3484 .input_width(pooling_size.second + 2)
3485 .pooling_height(pooling_size.first)
3486 .pooling_width(pooling_size.second)
3487 .channels(channels)
3488 .TestF32();
3489 AveragePoolingOperatorTester()
3490 .input_height(pooling_size.second + 3)
3491 .input_width(pooling_size.first + 2)
3492 .pooling_height(pooling_size.second)
3493 .pooling_width(pooling_size.first)
3494 .channels(channels)
3495 .TestF32();
3496 }
3497}
3498
3499TEST(AVERAGE_POOLING_NHWC_F32, large_pool_with_stride) {
3500 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3501 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3502 for (size_t channels = 1; channels <= 100; channels += 15) {
3503 for (size_t stride_width = 1; stride_width <= 2; stride_width++) {
3504 for (size_t stride_height = 1; stride_height <= 2; stride_height++) {
3505 if (stride_width == 1 && stride_height == 1) {
3506 continue;
3507 }
3508
3509 AveragePoolingOperatorTester()
3510 .input_height(pooling_size.first + 3)
3511 .input_width(pooling_size.second + 2)
3512 .pooling_height(pooling_size.first)
3513 .pooling_width(pooling_size.second)
3514 .stride_height(stride_height)
3515 .stride_width(stride_width)
3516 .channels(channels)
3517 .TestF32();
3518 AveragePoolingOperatorTester()
3519 .input_height(pooling_size.second + 3)
3520 .input_width(pooling_size.first + 2)
3521 .pooling_height(pooling_size.second)
3522 .pooling_width(pooling_size.first)
3523 .stride_height(stride_height)
3524 .stride_width(stride_width)
3525 .channels(channels)
3526 .TestF32();
3527 }
3528 }
3529 }
3530}
3531
3532TEST(AVERAGE_POOLING_NHWC_F32, large_pool_with_width_padding) {
3533 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3534 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3535 for (size_t channels = 1; channels <= 100; channels += 15) {
3536 for (size_t stride = 1; stride <= 2; stride++) {
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]3537 for (size_t padding_left = 1; padding_left <= 2; padding_left++) {
3538 AveragePoolingOperatorTester()
3539 .input_height(pooling_size.first + 3)
3540 .input_width(pooling_size.second + 2)
3541 .padding_left(padding_left)
3542 .pooling_height(pooling_size.first)
3543 .pooling_width(pooling_size.second)
3544 .stride(stride)
3545 .channels(channels)
3546 .TestF32();
3547 AveragePoolingOperatorTester()
3548 .input_height(pooling_size.second + 3)
3549 .input_width(pooling_size.first + 2)
3550 .padding_left(padding_left)
3551 .pooling_height(pooling_size.second)
3552 .pooling_width(pooling_size.first)
3553 .stride(stride)
3554 .channels(channels)
3555 .TestF32();
3556 }
3557 for (size_t padding_right = 1; padding_right <= 2; padding_right++) {
3558 AveragePoolingOperatorTester()
3559 .input_height(pooling_size.first + 3)
3560 .input_width(pooling_size.second + 2)
3561 .padding_right(padding_right)
3562 .pooling_height(pooling_size.first)
3563 .pooling_width(pooling_size.second)
3564 .stride(stride)
3565 .channels(channels)
3566 .TestF32();
3567 AveragePoolingOperatorTester()
3568 .input_height(pooling_size.second + 3)
3569 .input_width(pooling_size.first + 2)
3570 .padding_right(padding_right)
3571 .pooling_height(pooling_size.second)
3572 .pooling_width(pooling_size.first)
3573 .stride(stride)
3574 .channels(channels)
3575 .TestF32();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]3576 }
3577 }
3578 }
3579}
3580
3581TEST(AVERAGE_POOLING_NHWC_F32, large_pool_with_height_padding) {
3582 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3583 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3584 for (size_t channels = 1; channels <= 100; channels += 15) {
3585 for (size_t stride = 1; stride <= 2; stride++) {
3586 for (size_t padding_top = 0; padding_top <= 1; padding_top++) {
3587 for (size_t padding_bottom = 0; padding_bottom <= 1; padding_bottom++) {
3588 AveragePoolingOperatorTester()
3589 .input_height(pooling_size.first + 3)
3590 .input_width(pooling_size.second + 2)
3591 .padding_top(padding_top)
3592 .padding_bottom(padding_bottom)
3593 .pooling_height(pooling_size.first)
3594 .pooling_width(pooling_size.second)
3595 .stride(stride)
3596 .channels(channels)
3597 .TestF32();
3598 AveragePoolingOperatorTester()
3599 .input_height(pooling_size.second + 3)
3600 .input_width(pooling_size.first + 2)
3601 .padding_top(padding_top)
3602 .padding_bottom(padding_bottom)
3603 .pooling_height(pooling_size.second)
3604 .pooling_width(pooling_size.first)
3605 .stride(stride)
3606 .channels(channels)
3607 .TestF32();
3608 }
3609 }
3610 }
3611 }
3612}
3613
3614TEST(AVERAGE_POOLING_NHWC_F32, large_pool_with_tf_same_padding) {
3615 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3616 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3617 for (size_t channels = 1; channels <= 100; channels += 15) {
3618 for (size_t stride = 1; stride <= 2; stride++) {
3619 for (size_t input_height = pooling_size.first + 3; input_height <= pooling_size.first + 4; input_height++) {
3620 AveragePoolingOperatorTester()
3621 .input_height(input_height)
3622 .input_width(pooling_size.second + 2)
3623 .padding_tf_same(true)
3624 .pooling_height(pooling_size.first)
3625 .pooling_width(pooling_size.second)
3626 .stride(stride)
3627 .channels(channels)
3628 .TestF32();
3629 }
3630 for (size_t input_width = pooling_size.second + 2; input_width <= pooling_size.second + 3; input_width++) {
3631 AveragePoolingOperatorTester()
3632 .input_height(pooling_size.first + 3)
3633 .input_width(input_width)
3634 .padding_tf_same(true)
3635 .pooling_height(pooling_size.first)
3636 .pooling_width(pooling_size.second)
3637 .stride(stride)
3638 .channels(channels)
3639 .TestF32();
3640 }
3641 for (size_t input_height = pooling_size.second + 3; input_height <= pooling_size.second + 4; input_height++) {
3642 AveragePoolingOperatorTester()
3643 .input_height(input_height)
3644 .input_width(pooling_size.first + 2)
3645 .padding_tf_same(true)
3646 .pooling_height(pooling_size.second)
3647 .pooling_width(pooling_size.first)
3648 .stride(stride)
3649 .channels(channels)
3650 .TestF32();
3651 }
3652 for (size_t input_width = pooling_size.first + 2; input_width <= pooling_size.first + 3; input_width++) {
3653 AveragePoolingOperatorTester()
3654 .input_height(pooling_size.second + 3)
3655 .input_width(input_width)
3656 .padding_tf_same(true)
3657 .pooling_height(pooling_size.second)
3658 .pooling_width(pooling_size.first)
3659 .stride(stride)
3660 .channels(channels)
3661 .TestF32();
3662 }
3663 }
3664 }
3665}
3666
3667TEST(AVERAGE_POOLING_NHWC_F32, large_pool_with_input_stride) {
3668 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3669 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3670 for (size_t channels = 1; channels <= 100; channels += 15) {
3671 AveragePoolingOperatorTester()
3672 .input_height(pooling_size.first + 3)
3673 .input_width(pooling_size.second + 2)
3674 .pooling_height(pooling_size.first)
3675 .pooling_width(pooling_size.second)
3676 .channels(channels)
3677 .input_pixel_stride(2 * channels + 3)
3678 .TestF32();
3679 AveragePoolingOperatorTester()
3680 .input_height(pooling_size.second + 3)
3681 .input_width(pooling_size.first + 2)
3682 .pooling_height(pooling_size.second)
3683 .pooling_width(pooling_size.first)
3684 .channels(channels)
3685 .input_pixel_stride(2 * channels + 3)
3686 .TestF32();
3687 }
3688}
3689
3690TEST(AVERAGE_POOLING_NHWC_F32, large_pool_with_output_stride) {
3691 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3692 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3693 for (size_t channels = 1; channels <= 100; channels += 15) {
3694 AveragePoolingOperatorTester()
3695 .input_height(pooling_size.first + 3)
3696 .input_width(pooling_size.second + 2)
3697 .pooling_height(pooling_size.first)
3698 .pooling_width(pooling_size.second)
3699 .channels(channels)
3700 .output_pixel_stride(2 * channels + 3)
3701 .TestF32();
3702 AveragePoolingOperatorTester()
3703 .input_height(pooling_size.second + 3)
3704 .input_width(pooling_size.first + 2)
3705 .pooling_height(pooling_size.second)
3706 .pooling_width(pooling_size.first)
3707 .channels(channels)
3708 .output_pixel_stride(2 * channels + 3)
3709 .TestF32();
3710 }
3711}
3712
3713TEST(AVERAGE_POOLING_NHWC_F32, large_pool_with_qmin) {
3714 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3715 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3716 for (size_t channels = 1; channels <= 100; channels += 15) {
3717 AveragePoolingOperatorTester()
3718 .input_height(pooling_size.first + 3)
3719 .input_width(pooling_size.second + 2)
3720 .pooling_height(pooling_size.first)
3721 .pooling_width(pooling_size.second)
3722 .channels(channels)
3723 .qmin(128)
3724 .TestF32();
3725 AveragePoolingOperatorTester()
3726 .input_height(pooling_size.second + 3)
3727 .input_width(pooling_size.first + 2)
3728 .pooling_height(pooling_size.second)
3729 .pooling_width(pooling_size.first)
3730 .channels(channels)
3731 .qmin(128)
3732 .TestF32();
3733 }
3734}
3735
3736TEST(AVERAGE_POOLING_NHWC_F32, large_pool_with_qmax) {
3737 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3738 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3739 for (size_t channels = 1; channels <= 100; channels += 15) {
3740 AveragePoolingOperatorTester()
3741 .input_height(pooling_size.first + 3)
3742 .input_width(pooling_size.second + 2)
3743 .pooling_height(pooling_size.first)
3744 .pooling_width(pooling_size.second)
3745 .channels(channels)
3746 .qmax(128)
3747 .TestF32();
3748 AveragePoolingOperatorTester()
3749 .input_height(pooling_size.second + 3)
3750 .input_width(pooling_size.first + 2)
3751 .pooling_height(pooling_size.second)
3752 .pooling_width(pooling_size.first)
3753 .channels(channels)
3754 .qmax(128)
3755 .TestF32();
3756 }
3757}
3758
3759/**************************** AVGPOOL path, multipass, batched ****************************/
3760
3761TEST(AVERAGE_POOLING_NHWC_F32, batched_large_pool) {
3762 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3763 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.avgpool.mr * 2);
3764 for (size_t channels = 1; channels <= 100; channels += 15) {
3765 AveragePoolingOperatorTester()
3766 .batch_size(2)
3767 .input_height(pooling_size.first + 3)
3768 .input_width(pooling_size.second + 2)
3769 .pooling_height(pooling_size.first)
3770 .pooling_width(pooling_size.second)
3771 .channels(channels)
3772 .TestF32();
3773 AveragePoolingOperatorTester()
3774 .batch_size(2)
3775 .input_height(pooling_size.second + 3)
3776 .input_width(pooling_size.first + 2)
3777 .pooling_height(pooling_size.second)
3778 .pooling_width(pooling_size.first)
3779 .channels(channels)
3780 .TestF32();
3781 }
3782}
3783
3784TEST(AVERAGE_POOLING_NHWC_F32, batched_large_pool_with_stride) {
3785 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3786 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3787 for (size_t channels = 1; channels <= 100; channels += 15) {
3788 for (size_t stride_width = 1; stride_width <= 2; stride_width++) {
3789 for (size_t stride_height = 1; stride_height <= 2; stride_height++) {
3790 if (stride_width == 1 && stride_height == 1) {
3791 continue;
3792 }
3793
3794 AveragePoolingOperatorTester()
3795 .batch_size(2)
3796 .input_height(pooling_size.first + 3)
3797 .input_width(pooling_size.second + 2)
3798 .pooling_height(pooling_size.first)
3799 .pooling_width(pooling_size.second)
3800 .stride_height(stride_height)
3801 .stride_width(stride_width)
3802 .channels(channels)
3803 .TestF32();
3804 AveragePoolingOperatorTester()
3805 .batch_size(2)
3806 .input_height(pooling_size.second + 3)
3807 .input_width(pooling_size.first + 2)
3808 .pooling_height(pooling_size.second)
3809 .pooling_width(pooling_size.first)
3810 .stride_height(stride_height)
3811 .stride_width(stride_width)
3812 .channels(channels)
3813 .TestF32();
3814 }
3815 }
3816 }
3817}
3818
3819TEST(AVERAGE_POOLING_NHWC_F32, batched_large_pool_with_width_padding) {
3820 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3821 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3822 for (size_t channels = 1; channels <= 100; channels += 15) {
3823 for (size_t stride = 1; stride <= 2; stride++) {
3824 for (size_t padding_left = 0; padding_left <= 1; padding_left++) {
3825 for (size_t padding_right = 0; padding_right <= 1; padding_right++) {
3826 AveragePoolingOperatorTester()
3827 .batch_size(2)
3828 .input_height(pooling_size.first + 3)
3829 .input_width(pooling_size.second + 2)
3830 .padding_left(padding_left)
3831 .padding_right(padding_right)
3832 .pooling_height(pooling_size.first)
3833 .pooling_width(pooling_size.second)
3834 .stride(stride)
3835 .channels(channels)
3836 .TestF32();
3837 AveragePoolingOperatorTester()
3838 .batch_size(2)
3839 .input_height(pooling_size.second + 3)
3840 .input_width(pooling_size.first + 2)
3841 .padding_left(padding_left)
3842 .padding_right(padding_right)
3843 .pooling_height(pooling_size.second)
3844 .pooling_width(pooling_size.first)
3845 .stride(stride)
3846 .channels(channels)
3847 .TestF32();
3848 }
3849 }
3850 }
3851 }
3852}
3853
3854TEST(AVERAGE_POOLING_NHWC_F32, batched_large_pool_with_height_padding) {
3855 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3856 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3857 for (size_t channels = 1; channels <= 100; channels += 15) {
3858 for (size_t stride = 1; stride <= 2; stride++) {
3859 for (size_t padding_top = 0; padding_top <= 1; padding_top++) {
3860 for (size_t padding_bottom = 0; padding_bottom <= 1; padding_bottom++) {
3861 AveragePoolingOperatorTester()
3862 .batch_size(2)
3863 .input_height(pooling_size.first + 3)
3864 .input_width(pooling_size.second + 2)
3865 .padding_top(padding_top)
3866 .padding_bottom(padding_bottom)
3867 .pooling_height(pooling_size.first)
3868 .pooling_width(pooling_size.second)
3869 .stride(stride)
3870 .channels(channels)
3871 .TestF32();
3872 AveragePoolingOperatorTester()
3873 .batch_size(2)
3874 .input_height(pooling_size.second + 3)
3875 .input_width(pooling_size.first + 2)
3876 .padding_top(padding_top)
3877 .padding_bottom(padding_bottom)
3878 .pooling_height(pooling_size.second)
3879 .pooling_width(pooling_size.first)
3880 .stride(stride)
3881 .channels(channels)
3882 .TestF32();
3883 }
3884 }
3885 }
3886 }
3887}
3888
3889TEST(AVERAGE_POOLING_NHWC_F32, batched_large_pool_with_tf_same_padding) {
3890 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3891 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3892 for (size_t channels = 1; channels <= 100; channels += 15) {
3893 for (size_t stride = 1; stride <= 2; stride++) {
3894 for (size_t input_height = pooling_size.first + 3; input_height <= pooling_size.first + 4; input_height++) {
3895 AveragePoolingOperatorTester()
3896 .batch_size(2)
3897 .input_height(input_height)
3898 .input_width(pooling_size.second + 2)
3899 .padding_tf_same(true)
3900 .pooling_height(pooling_size.first)
3901 .pooling_width(pooling_size.second)
3902 .stride(stride)
3903 .channels(channels)
3904 .TestF32();
3905 }
3906 for (size_t input_width = pooling_size.second + 2; input_width <= pooling_size.second + 3; input_width++) {
3907 AveragePoolingOperatorTester()
3908 .batch_size(2)
3909 .input_height(pooling_size.first + 3)
3910 .input_width(input_width)
3911 .padding_tf_same(true)
3912 .pooling_height(pooling_size.first)
3913 .pooling_width(pooling_size.second)
3914 .stride(stride)
3915 .channels(channels)
3916 .TestF32();
3917 }
3918 for (size_t input_height = pooling_size.second + 3; input_height <= pooling_size.second + 4; input_height++) {
3919 AveragePoolingOperatorTester()
3920 .batch_size(2)
3921 .input_height(input_height)
3922 .input_width(pooling_size.first + 2)
3923 .padding_tf_same(true)
3924 .pooling_height(pooling_size.second)
3925 .pooling_width(pooling_size.first)
3926 .stride(stride)
3927 .channels(channels)
3928 .TestF32();
3929 }
3930 for (size_t input_width = pooling_size.first + 2; input_width <= pooling_size.first + 3; input_width++) {
3931 AveragePoolingOperatorTester()
3932 .batch_size(2)
3933 .input_height(pooling_size.second + 3)
3934 .input_width(input_width)
3935 .padding_tf_same(true)
3936 .pooling_height(pooling_size.second)
3937 .pooling_width(pooling_size.first)
3938 .stride(stride)
3939 .channels(channels)
3940 .TestF32();
3941 }
3942 }
3943 }
3944}
3945
3946TEST(AVERAGE_POOLING_NHWC_F32, batched_large_pool_with_input_stride) {
3947 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3948 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3949 for (size_t channels = 1; channels <= 100; channels += 15) {
3950 AveragePoolingOperatorTester()
3951 .batch_size(2)
3952 .input_height(pooling_size.first + 3)
3953 .input_width(pooling_size.second + 2)
3954 .pooling_height(pooling_size.first)
3955 .pooling_width(pooling_size.second)
3956 .channels(channels)
3957 .input_pixel_stride(2 * channels + 3)
3958 .TestF32();
3959 AveragePoolingOperatorTester()
3960 .batch_size(2)
3961 .input_height(pooling_size.second + 3)
3962 .input_width(pooling_size.first + 2)
3963 .pooling_height(pooling_size.second)
3964 .pooling_width(pooling_size.first)
3965 .channels(channels)
3966 .input_pixel_stride(2 * channels + 3)
3967 .TestF32();
3968 }
3969}
3970
3971TEST(AVERAGE_POOLING_NHWC_F32, batched_large_pool_with_output_stride) {
3972 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3973 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3974 for (size_t channels = 1; channels <= 100; channels += 15) {
3975 AveragePoolingOperatorTester()
3976 .batch_size(2)
3977 .input_height(pooling_size.first + 3)
3978 .input_width(pooling_size.second + 2)
3979 .pooling_height(pooling_size.first)
3980 .pooling_width(pooling_size.second)
3981 .channels(channels)
3982 .output_pixel_stride(2 * channels + 3)
3983 .TestF32();
3984 AveragePoolingOperatorTester()
3985 .batch_size(2)
3986 .input_height(pooling_size.second + 3)
3987 .input_width(pooling_size.first + 2)
3988 .pooling_height(pooling_size.second)
3989 .pooling_width(pooling_size.first)
3990 .channels(channels)
3991 .output_pixel_stride(2 * channels + 3)
3992 .TestF32();
3993 }
3994}
3995
3996TEST(AVERAGE_POOLING_NHWC_F32, batched_large_pool_with_qmin) {
3997 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
3998 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
3999 for (size_t channels = 1; channels <= 100; channels += 15) {
4000 AveragePoolingOperatorTester()
4001 .batch_size(2)
4002 .input_height(pooling_size.first + 3)
4003 .input_width(pooling_size.second + 2)
4004 .pooling_height(pooling_size.first)
4005 .pooling_width(pooling_size.second)
4006 .channels(channels)
4007 .qmin(128)
4008 .TestF32();
4009 AveragePoolingOperatorTester()
4010 .batch_size(2)
4011 .input_height(pooling_size.second + 3)
4012 .input_width(pooling_size.first + 2)
4013 .pooling_height(pooling_size.second)
4014 .pooling_width(pooling_size.first)
4015 .channels(channels)
4016 .qmin(128)
4017 .TestF32();
4018 }
4019}
4020
4021TEST(AVERAGE_POOLING_NHWC_F32, batched_large_pool_with_qmax) {
4022 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4023 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4024 for (size_t channels = 1; channels <= 100; channels += 15) {
4025 AveragePoolingOperatorTester()
4026 .batch_size(2)
4027 .input_height(pooling_size.first + 3)
4028 .input_width(pooling_size.second + 2)
4029 .pooling_height(pooling_size.first)
4030 .pooling_width(pooling_size.second)
4031 .channels(channels)
4032 .qmax(128)
4033 .TestF32();
4034 AveragePoolingOperatorTester()
4035 .batch_size(2)
4036 .input_height(pooling_size.second + 3)
4037 .input_width(pooling_size.first + 2)
4038 .pooling_height(pooling_size.second)
4039 .pooling_width(pooling_size.first)
4040 .channels(channels)
4041 .qmax(128)
4042 .TestF32();
4043 }
4044}
4045
4046/**************************** GAVGPOOL path, unipass ****************************/
4047
4048TEST(AVERAGE_POOLING_NHWC_F32, small_image) {
4049 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4050 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4051 for (size_t channels = 1; channels <= 100; channels += 15) {
4052 AveragePoolingOperatorTester()
4053 .input_height(pooling_size.first)
4054 .input_width(pooling_size.second)
4055 .pooling_height(pooling_size.first)
4056 .pooling_width(pooling_size.second)
4057 .channels(channels)
4058 .TestF32();
4059 AveragePoolingOperatorTester()
4060 .input_height(pooling_size.second)
4061 .input_width(pooling_size.first)
4062 .pooling_height(pooling_size.second)
4063 .pooling_width(pooling_size.first)
4064 .channels(channels)
4065 .TestF32();
4066 }
4067}
4068
4069TEST(AVERAGE_POOLING_NHWC_F32, small_image_with_width_padding) {
4070 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4071 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4072 for (size_t channels = 1; channels <= 100; channels += 15) {
4073 /* With left padding */
4074 AveragePoolingOperatorTester()
4075 .input_height(pooling_size.first)
4076 .input_width(pooling_size.second - 1)
4077 .padding_left(1)
4078 .pooling_height(pooling_size.first)
4079 .pooling_width(pooling_size.second)
4080 .channels(channels)
4081 .TestF32();
4082 AveragePoolingOperatorTester()
4083 .input_height(pooling_size.second)
4084 .input_width(pooling_size.first - 1)
4085 .padding_left(1)
4086 .pooling_height(pooling_size.second)
4087 .pooling_width(pooling_size.first)
4088 .channels(channels)
4089 .TestF32();
4090
4091 /* With right padding */
4092 AveragePoolingOperatorTester()
4093 .input_height(pooling_size.first)
4094 .input_width(pooling_size.second - 1)
4095 .padding_right(1)
4096 .pooling_height(pooling_size.first)
4097 .pooling_width(pooling_size.second)
4098 .channels(channels)
4099 .TestF32();
4100 AveragePoolingOperatorTester()
4101 .input_height(pooling_size.second)
4102 .input_width(pooling_size.first - 1)
4103 .padding_right(1)
4104 .pooling_height(pooling_size.second)
4105 .pooling_width(pooling_size.first)
4106 .channels(channels)
4107 .TestF32();
4108 }
4109}
4110
4111TEST(AVERAGE_POOLING_NHWC_F32, small_image_with_height_padding) {
4112 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4113 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4114 for (size_t channels = 1; channels <= 100; channels += 15) {
4115 /* With top padding */
4116 AveragePoolingOperatorTester()
4117 .input_height(pooling_size.first - 1)
4118 .input_width(pooling_size.second)
4119 .padding_top(1)
4120 .pooling_height(pooling_size.first)
4121 .pooling_width(pooling_size.second)
4122 .channels(channels)
4123 .TestF32();
4124 AveragePoolingOperatorTester()
4125 .input_height(pooling_size.second - 1)
4126 .input_width(pooling_size.first)
4127 .padding_top(1)
4128 .pooling_height(pooling_size.second)
4129 .pooling_width(pooling_size.first)
4130 .channels(channels)
4131 .TestF32();
4132
4133 /* With bottom padding */
4134 AveragePoolingOperatorTester()
4135 .input_height(pooling_size.first - 1)
4136 .input_width(pooling_size.second)
4137 .padding_bottom(1)
4138 .pooling_height(pooling_size.first)
4139 .pooling_width(pooling_size.second)
4140 .channels(channels)
4141 .TestF32();
4142 AveragePoolingOperatorTester()
4143 .input_height(pooling_size.second - 1)
4144 .input_width(pooling_size.first)
4145 .padding_bottom(1)
4146 .pooling_height(pooling_size.second)
4147 .pooling_width(pooling_size.first)
4148 .channels(channels)
4149 .TestF32();
4150 }
4151}
4152
4153TEST(AVERAGE_POOLING_NHWC_F32, small_image_with_input_stride) {
4154 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4155 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4156 for (size_t channels = 1; channels <= 100; channels += 15) {
4157 AveragePoolingOperatorTester()
4158 .input_height(pooling_size.first)
4159 .input_width(pooling_size.second)
4160 .pooling_height(pooling_size.first)
4161 .pooling_width(pooling_size.second)
4162 .channels(channels)
4163 .input_pixel_stride(2 * channels + 3)
4164 .TestF32();
4165 AveragePoolingOperatorTester()
4166 .input_height(pooling_size.second)
4167 .input_width(pooling_size.first)
4168 .pooling_height(pooling_size.second)
4169 .pooling_width(pooling_size.first)
4170 .channels(channels)
4171 .input_pixel_stride(2 * channels + 3)
4172 .TestF32();
4173 }
4174}
4175
4176TEST(AVERAGE_POOLING_NHWC_F32, small_image_with_output_stride) {
4177 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4178 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4179 for (size_t channels = 1; channels <= 100; channels += 15) {
4180 AveragePoolingOperatorTester()
4181 .input_height(pooling_size.first)
4182 .input_width(pooling_size.second)
4183 .pooling_height(pooling_size.first)
4184 .pooling_width(pooling_size.second)
4185 .channels(channels)
4186 .output_pixel_stride(2 * channels + 3)
4187 .TestF32();
4188 AveragePoolingOperatorTester()
4189 .input_height(pooling_size.second)
4190 .input_width(pooling_size.first)
4191 .pooling_height(pooling_size.second)
4192 .pooling_width(pooling_size.first)
4193 .channels(channels)
4194 .output_pixel_stride(2 * channels + 3)
4195 .TestF32();
4196 }
4197}
4198
4199TEST(AVERAGE_POOLING_NHWC_F32, small_image_with_qmin) {
4200 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4201 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4202 for (size_t channels = 1; channels <= 100; channels += 15) {
4203 AveragePoolingOperatorTester()
4204 .input_height(pooling_size.first)
4205 .input_width(pooling_size.second)
4206 .pooling_height(pooling_size.first)
4207 .pooling_width(pooling_size.second)
4208 .channels(channels)
4209 .qmin(128)
4210 .TestF32();
4211 AveragePoolingOperatorTester()
4212 .input_height(pooling_size.second)
4213 .input_width(pooling_size.first)
4214 .pooling_height(pooling_size.second)
4215 .pooling_width(pooling_size.first)
4216 .channels(channels)
4217 .qmin(128)
4218 .TestF32();
4219 }
4220}
4221
4222TEST(AVERAGE_POOLING_NHWC_F32, small_image_with_qmax) {
4223 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4224 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4225 for (size_t channels = 1; channels <= 100; channels += 15) {
4226 AveragePoolingOperatorTester()
4227 .input_height(pooling_size.first)
4228 .input_width(pooling_size.second)
4229 .pooling_height(pooling_size.first)
4230 .pooling_width(pooling_size.second)
4231 .channels(channels)
4232 .qmax(128)
4233 .TestF32();
4234 AveragePoolingOperatorTester()
4235 .input_height(pooling_size.second)
4236 .input_width(pooling_size.first)
4237 .pooling_height(pooling_size.second)
4238 .pooling_width(pooling_size.first)
4239 .channels(channels)
4240 .qmax(128)
4241 .TestF32();
4242 }
4243}
4244
4245/**************************** GAVGPOOL path, unipass, batched ****************************/
4246
4247TEST(AVERAGE_POOLING_NHWC_F32, batched_small_image) {
4248 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4249 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4250 for (size_t channels = 1; channels <= 100; channels += 15) {
4251 AveragePoolingOperatorTester()
4252 .batch_size(2)
4253 .input_height(pooling_size.first)
4254 .input_width(pooling_size.second)
4255 .pooling_height(pooling_size.first)
4256 .pooling_width(pooling_size.second)
4257 .channels(channels)
4258 .TestF32();
4259 AveragePoolingOperatorTester()
4260 .batch_size(2)
4261 .input_height(pooling_size.second)
4262 .input_width(pooling_size.first)
4263 .pooling_height(pooling_size.second)
4264 .pooling_width(pooling_size.first)
4265 .channels(channels)
4266 .TestF32();
4267 }
4268}
4269
4270TEST(AVERAGE_POOLING_NHWC_F32, batched_small_image_with_width_padding) {
4271 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4272 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4273 for (size_t channels = 1; channels <= 100; channels += 15) {
4274 /* With left padding */
4275 AveragePoolingOperatorTester()
4276 .batch_size(2)
4277 .input_height(pooling_size.first)
4278 .input_width(pooling_size.second - 1)
4279 .padding_left(1)
4280 .pooling_height(pooling_size.first)
4281 .pooling_width(pooling_size.second)
4282 .channels(channels)
4283 .TestF32();
4284 AveragePoolingOperatorTester()
4285 .batch_size(2)
4286 .input_height(pooling_size.second)
4287 .input_width(pooling_size.first - 1)
4288 .padding_left(1)
4289 .pooling_height(pooling_size.second)
4290 .pooling_width(pooling_size.first)
4291 .channels(channels)
4292 .TestF32();
4293
4294 /* With right padding */
4295 AveragePoolingOperatorTester()
4296 .batch_size(2)
4297 .input_height(pooling_size.first)
4298 .input_width(pooling_size.second - 1)
4299 .padding_right(1)
4300 .pooling_height(pooling_size.first)
4301 .pooling_width(pooling_size.second)
4302 .channels(channels)
4303 .TestF32();
4304 AveragePoolingOperatorTester()
4305 .batch_size(2)
4306 .input_height(pooling_size.second)
4307 .input_width(pooling_size.first - 1)
4308 .padding_right(1)
4309 .pooling_height(pooling_size.second)
4310 .pooling_width(pooling_size.first)
4311 .channels(channels)
4312 .TestF32();
4313 }
4314}
4315
4316TEST(AVERAGE_POOLING_NHWC_F32, batched_small_image_with_height_padding) {
4317 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4318 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4319 for (size_t channels = 1; channels <= 100; channels += 15) {
4320 /* With top padding */
4321 AveragePoolingOperatorTester()
4322 .batch_size(2)
4323 .input_height(pooling_size.first - 1)
4324 .input_width(pooling_size.second)
4325 .padding_top(1)
4326 .pooling_height(pooling_size.first)
4327 .pooling_width(pooling_size.second)
4328 .channels(channels)
4329 .TestF32();
4330 AveragePoolingOperatorTester()
4331 .batch_size(2)
4332 .input_height(pooling_size.second - 1)
4333 .input_width(pooling_size.first)
4334 .padding_top(1)
4335 .pooling_height(pooling_size.second)
4336 .pooling_width(pooling_size.first)
4337 .channels(channels)
4338 .TestF32();
4339
4340 /* With bottom padding */
4341 AveragePoolingOperatorTester()
4342 .batch_size(2)
4343 .input_height(pooling_size.first - 1)
4344 .input_width(pooling_size.second)
4345 .padding_bottom(1)
4346 .pooling_height(pooling_size.first)
4347 .pooling_width(pooling_size.second)
4348 .channels(channels)
4349 .TestF32();
4350 AveragePoolingOperatorTester()
4351 .batch_size(2)
4352 .input_height(pooling_size.second - 1)
4353 .input_width(pooling_size.first)
4354 .padding_bottom(1)
4355 .pooling_height(pooling_size.second)
4356 .pooling_width(pooling_size.first)
4357 .channels(channels)
4358 .TestF32();
4359 }
4360}
4361
4362TEST(AVERAGE_POOLING_NHWC_F32, batched_small_image_with_input_stride) {
4363 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4364 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4365 for (size_t channels = 1; channels <= 100; channels += 15) {
4366 AveragePoolingOperatorTester()
4367 .batch_size(2)
4368 .input_height(pooling_size.first)
4369 .input_width(pooling_size.second)
4370 .pooling_height(pooling_size.first)
4371 .pooling_width(pooling_size.second)
4372 .channels(channels)
4373 .input_pixel_stride(2 * channels + 3)
4374 .TestF32();
4375 AveragePoolingOperatorTester()
4376 .batch_size(2)
4377 .input_height(pooling_size.second)
4378 .input_width(pooling_size.first)
4379 .pooling_height(pooling_size.second)
4380 .pooling_width(pooling_size.first)
4381 .channels(channels)
4382 .input_pixel_stride(2 * channels + 3)
4383 .TestF32();
4384 }
4385}
4386
4387TEST(AVERAGE_POOLING_NHWC_F32, batched_small_image_with_output_stride) {
4388 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4389 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4390 for (size_t channels = 1; channels <= 100; channels += 15) {
4391 AveragePoolingOperatorTester()
4392 .batch_size(2)
4393 .input_height(pooling_size.first)
4394 .input_width(pooling_size.second)
4395 .pooling_height(pooling_size.first)
4396 .pooling_width(pooling_size.second)
4397 .channels(channels)
4398 .output_pixel_stride(2 * channels + 3)
4399 .TestF32();
4400 AveragePoolingOperatorTester()
4401 .batch_size(2)
4402 .input_height(pooling_size.second)
4403 .input_width(pooling_size.first)
4404 .pooling_height(pooling_size.second)
4405 .pooling_width(pooling_size.first)
4406 .channels(channels)
4407 .output_pixel_stride(2 * channels + 3)
4408 .TestF32();
4409 }
4410}
4411
4412TEST(AVERAGE_POOLING_NHWC_F32, batched_small_image_with_qmin) {
4413 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4414 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4415 for (size_t channels = 1; channels <= 100; channels += 15) {
4416 AveragePoolingOperatorTester()
4417 .batch_size(2)
4418 .input_height(pooling_size.first)
4419 .input_width(pooling_size.second)
4420 .pooling_height(pooling_size.first)
4421 .pooling_width(pooling_size.second)
4422 .channels(channels)
4423 .qmin(128)
4424 .TestF32();
4425 AveragePoolingOperatorTester()
4426 .batch_size(2)
4427 .input_height(pooling_size.second)
4428 .input_width(pooling_size.first)
4429 .pooling_height(pooling_size.second)
4430 .pooling_width(pooling_size.first)
4431 .channels(channels)
4432 .qmin(128)
4433 .TestF32();
4434 }
4435}
4436
4437TEST(AVERAGE_POOLING_NHWC_F32, batched_small_image_with_qmax) {
4438 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4439 const std::pair<size_t, size_t> pooling_size = SmallPoolSize(xnn_params.f32.gavgpool.mr);
4440 for (size_t channels = 1; channels <= 100; channels += 15) {
4441 AveragePoolingOperatorTester()
4442 .batch_size(2)
4443 .input_height(pooling_size.first)
4444 .input_width(pooling_size.second)
4445 .pooling_height(pooling_size.first)
4446 .pooling_width(pooling_size.second)
4447 .channels(channels)
4448 .qmax(128)
4449 .TestF32();
4450 AveragePoolingOperatorTester()
4451 .batch_size(2)
4452 .input_height(pooling_size.second)
4453 .input_width(pooling_size.first)
4454 .pooling_height(pooling_size.second)
4455 .pooling_width(pooling_size.first)
4456 .channels(channels)
4457 .qmax(128)
4458 .TestF32();
4459 }
4460}
4461
4462/**************************** GAVGPOOL path, multipass ****************************/
4463
4464TEST(AVERAGE_POOLING_NHWC_F32, large_image) {
4465 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4466 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4467 for (size_t channels = 1; channels <= 100; channels += 15) {
4468 AveragePoolingOperatorTester()
4469 .input_height(pooling_size.first)
4470 .input_width(pooling_size.second)
4471 .pooling_height(pooling_size.first)
4472 .pooling_width(pooling_size.second)
4473 .channels(channels)
4474 .TestF32();
4475 AveragePoolingOperatorTester()
4476 .input_height(pooling_size.second)
4477 .input_width(pooling_size.first)
4478 .pooling_height(pooling_size.second)
4479 .pooling_width(pooling_size.first)
4480 .channels(channels)
4481 .TestF32();
4482 }
4483}
4484
4485TEST(AVERAGE_POOLING_NHWC_F32, large_image_with_width_padding) {
4486 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4487 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4488 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]4489 for (size_t padding_left = 1; padding_left <= 2; padding_left++) {
4490 AveragePoolingOperatorTester()
4491 .input_height(pooling_size.first)
4492 .input_width(pooling_size.second - padding_left)
4493 .padding_left(padding_left)
4494 .pooling_height(pooling_size.first)
4495 .pooling_width(pooling_size.second)
4496 .channels(channels)
4497 .TestF32();
4498 AveragePoolingOperatorTester()
4499 .input_height(pooling_size.second)
4500 .input_width(pooling_size.first - padding_left)
4501 .padding_left(padding_left)
4502 .pooling_height(pooling_size.second)
4503 .pooling_width(pooling_size.first)
4504 .channels(channels)
4505 .TestF32();
4506 }
4507 for (size_t padding_right = 1; padding_right <= 2; padding_right++) {
4508 AveragePoolingOperatorTester()
4509 .input_height(pooling_size.first)
4510 .input_width(pooling_size.second - padding_right)
4511 .padding_right(padding_right)
4512 .pooling_height(pooling_size.first)
4513 .pooling_width(pooling_size.second)
4514 .channels(channels)
4515 .TestF32();
4516 AveragePoolingOperatorTester()
4517 .input_height(pooling_size.second)
4518 .input_width(pooling_size.first - padding_right)
4519 .padding_right(padding_right)
4520 .pooling_height(pooling_size.second)
4521 .pooling_width(pooling_size.first)
4522 .channels(channels)
4523 .TestF32();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4524 }
4525 }
4526}
4527
4528TEST(AVERAGE_POOLING_NHWC_F32, large_image_with_height_padding) {
4529 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4530 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4531 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]4532 for (size_t padding_top = 1; padding_top <= 2; padding_top++) {
4533 AveragePoolingOperatorTester()
4534 .input_height(pooling_size.first - padding_top)
4535 .input_width(pooling_size.second)
4536 .padding_top(padding_top)
4537 .pooling_height(pooling_size.first)
4538 .pooling_width(pooling_size.second)
4539 .channels(channels)
4540 .TestF32();
4541 AveragePoolingOperatorTester()
4542 .input_height(pooling_size.second - padding_top)
4543 .input_width(pooling_size.first)
4544 .padding_top(padding_top)
4545 .pooling_height(pooling_size.second)
4546 .pooling_width(pooling_size.first)
4547 .channels(channels)
4548 .TestF32();
4549 }
4550 for (size_t padding_bottom = 1; padding_bottom <= 2; padding_bottom++) {
4551 AveragePoolingOperatorTester()
4552 .input_height(pooling_size.first - padding_bottom)
4553 .input_width(pooling_size.second)
4554 .padding_bottom(padding_bottom)
4555 .pooling_height(pooling_size.first)
4556 .pooling_width(pooling_size.second)
4557 .channels(channels)
4558 .TestF32();
4559 AveragePoolingOperatorTester()
4560 .input_height(pooling_size.second - padding_bottom)
4561 .input_width(pooling_size.first)
4562 .padding_bottom(padding_bottom)
4563 .pooling_height(pooling_size.second)
4564 .pooling_width(pooling_size.first)
4565 .channels(channels)
4566 .TestF32();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4567 }
4568 }
4569}
4570
4571TEST(AVERAGE_POOLING_NHWC_F32, large_image_with_input_stride) {
4572 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4573 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4574 for (size_t channels = 1; channels <= 100; channels += 15) {
4575 AveragePoolingOperatorTester()
4576 .input_height(pooling_size.first)
4577 .input_width(pooling_size.second)
4578 .pooling_height(pooling_size.first)
4579 .pooling_width(pooling_size.second)
4580 .channels(channels)
4581 .input_pixel_stride(2 * channels + 3)
4582 .TestF32();
4583 AveragePoolingOperatorTester()
4584 .input_height(pooling_size.second)
4585 .input_width(pooling_size.first)
4586 .pooling_height(pooling_size.second)
4587 .pooling_width(pooling_size.first)
4588 .channels(channels)
4589 .input_pixel_stride(2 * channels + 3)
4590 .TestF32();
4591 }
4592}
4593
4594TEST(AVERAGE_POOLING_NHWC_F32, large_image_with_output_stride) {
4595 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4596 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4597 for (size_t channels = 1; channels <= 100; channels += 15) {
4598 AveragePoolingOperatorTester()
4599 .input_height(pooling_size.first)
4600 .input_width(pooling_size.second)
4601 .pooling_height(pooling_size.first)
4602 .pooling_width(pooling_size.second)
4603 .channels(channels)
4604 .output_pixel_stride(2 * channels + 3)
4605 .TestF32();
4606 AveragePoolingOperatorTester()
4607 .input_height(pooling_size.second)
4608 .input_width(pooling_size.first)
4609 .pooling_height(pooling_size.second)
4610 .pooling_width(pooling_size.first)
4611 .channels(channels)
4612 .output_pixel_stride(2 * channels + 3)
4613 .TestF32();
4614 }
4615}
4616
4617TEST(AVERAGE_POOLING_NHWC_F32, large_image_with_qmin) {
4618 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4619 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4620 for (size_t channels = 1; channels <= 100; channels += 15) {
4621 AveragePoolingOperatorTester()
4622 .input_height(pooling_size.first)
4623 .input_width(pooling_size.second)
4624 .pooling_height(pooling_size.first)
4625 .pooling_width(pooling_size.second)
4626 .channels(channels)
4627 .qmin(128)
4628 .TestF32();
4629 AveragePoolingOperatorTester()
4630 .input_height(pooling_size.second)
4631 .input_width(pooling_size.first)
4632 .pooling_height(pooling_size.second)
4633 .pooling_width(pooling_size.first)
4634 .channels(channels)
4635 .qmin(128)
4636 .TestF32();
4637 }
4638}
4639
4640TEST(AVERAGE_POOLING_NHWC_F32, large_image_with_qmax) {
4641 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4642 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4643 for (size_t channels = 1; channels <= 100; channels += 15) {
4644 AveragePoolingOperatorTester()
4645 .input_height(pooling_size.first)
4646 .input_width(pooling_size.second)
4647 .pooling_height(pooling_size.first)
4648 .pooling_width(pooling_size.second)
4649 .channels(channels)
4650 .qmax(128)
4651 .TestF32();
4652 AveragePoolingOperatorTester()
4653 .input_height(pooling_size.second)
4654 .input_width(pooling_size.first)
4655 .pooling_height(pooling_size.second)
4656 .pooling_width(pooling_size.first)
4657 .channels(channels)
4658 .qmax(128)
4659 .TestF32();
4660 }
4661}
4662
4663/**************************** GAVGPOOL path, multipass, batched ****************************/
4664
4665TEST(AVERAGE_POOLING_NHWC_F32, batched_large_image) {
4666 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4667 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4668 for (size_t channels = 1; channels <= 100; channels += 15) {
4669 AveragePoolingOperatorTester()
4670 .batch_size(2)
4671 .input_height(pooling_size.first)
4672 .input_width(pooling_size.second)
4673 .pooling_height(pooling_size.first)
4674 .pooling_width(pooling_size.second)
4675 .channels(channels)
4676 .TestF32();
4677 AveragePoolingOperatorTester()
4678 .batch_size(2)
4679 .input_height(pooling_size.second)
4680 .input_width(pooling_size.first)
4681 .pooling_height(pooling_size.second)
4682 .pooling_width(pooling_size.first)
4683 .channels(channels)
4684 .TestF32();
4685 }
4686}
4687
4688TEST(AVERAGE_POOLING_NHWC_F32, batched_large_image_with_width_padding) {
4689 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4690 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4691 for (size_t channels = 1; channels <= 100; channels += 15) {
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]4692 for (size_t padding_left = 1; padding_left <= 2; padding_left++) {
4693 AveragePoolingOperatorTester()
4694 .batch_size(2)
4695 .input_height(pooling_size.first)
4696 .input_width(pooling_size.second - padding_left)
4697 .padding_left(padding_left)
4698 .pooling_height(pooling_size.first)
4699 .pooling_width(pooling_size.second)
4700 .channels(channels)
4701 .TestF32();
4702 AveragePoolingOperatorTester()
4703 .batch_size(2)
4704 .input_height(pooling_size.second)
4705 .input_width(pooling_size.first - padding_left)
4706 .padding_left(padding_left)
4707 .pooling_height(pooling_size.second)
4708 .pooling_width(pooling_size.first)
4709 .channels(channels)
4710 .TestF32();
4711 }
4712 for (size_t padding_right = 1; padding_right <= 2; padding_right++) {
4713 AveragePoolingOperatorTester()
4714 .batch_size(2)
4715 .input_height(pooling_size.first)
4716 .input_width(pooling_size.second - padding_right)
4717 .padding_right(padding_right)
4718 .pooling_height(pooling_size.first)
4719 .pooling_width(pooling_size.second)
4720 .channels(channels)
4721 .TestF32();
4722 AveragePoolingOperatorTester()
4723 .batch_size(2)
4724 .input_height(pooling_size.second)
4725 .input_width(pooling_size.first - padding_right)
4726 .padding_right(padding_right)
4727 .pooling_height(pooling_size.second)
4728 .pooling_width(pooling_size.first)
4729 .channels(channels)
4730 .TestF32();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4731 }
4732 }
4733}
4734
4735TEST(AVERAGE_POOLING_NHWC_F32, batched_large_image_with_height_padding) {
4736 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4737 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4738 for (size_t channels = 1; channels <= 100; channels += 15) {
4739 for (size_t padding_top = 0; padding_top <= 1; padding_top++) {
Marat Dukhan1c8bc0c2020-03-20 00:21:58 -0700[diff] [blame]4740 AveragePoolingOperatorTester()
4741 .batch_size(2)
4742 .input_height(pooling_size.first - padding_top)
4743 .input_width(pooling_size.second)
4744 .padding_top(padding_top)
4745 .pooling_height(pooling_size.first)
4746 .pooling_width(pooling_size.second)
4747 .channels(channels)
4748 .TestF32();
4749 AveragePoolingOperatorTester()
4750 .batch_size(2)
4751 .input_height(pooling_size.second - padding_top)
4752 .input_width(pooling_size.first)
4753 .padding_top(padding_top)
4754 .pooling_height(pooling_size.second)
4755 .pooling_width(pooling_size.first)
4756 .channels(channels)
4757 .TestF32();
4758 }
4759 for (size_t padding_bottom = 1; padding_bottom <= 2; padding_bottom++) {
4760 AveragePoolingOperatorTester()
4761 .batch_size(2)
4762 .input_height(pooling_size.first - padding_bottom)
4763 .input_width(pooling_size.second)
4764 .padding_bottom(padding_bottom)
4765 .pooling_height(pooling_size.first)
4766 .pooling_width(pooling_size.second)
4767 .channels(channels)
4768 .TestF32();
4769 AveragePoolingOperatorTester()
4770 .batch_size(2)
4771 .input_height(pooling_size.second - padding_bottom)
4772 .input_width(pooling_size.first)
4773 .padding_bottom(padding_bottom)
4774 .pooling_height(pooling_size.second)
4775 .pooling_width(pooling_size.first)
4776 .channels(channels)
4777 .TestF32();
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4778 }
4779 }
4780}
4781
4782TEST(AVERAGE_POOLING_NHWC_F32, batched_large_image_with_input_stride) {
4783 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4784 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4785 for (size_t channels = 1; channels <= 100; channels += 15) {
4786 AveragePoolingOperatorTester()
4787 .batch_size(2)
4788 .input_height(pooling_size.first)
4789 .input_width(pooling_size.second)
4790 .pooling_height(pooling_size.first)
4791 .pooling_width(pooling_size.second)
4792 .channels(channels)
4793 .input_pixel_stride(2 * channels + 3)
4794 .TestF32();
4795 AveragePoolingOperatorTester()
4796 .batch_size(2)
4797 .input_height(pooling_size.second)
4798 .input_width(pooling_size.first)
4799 .pooling_height(pooling_size.second)
4800 .pooling_width(pooling_size.first)
4801 .channels(channels)
4802 .input_pixel_stride(2 * channels + 3)
4803 .TestF32();
4804 }
4805}
4806
4807TEST(AVERAGE_POOLING_NHWC_F32, batched_large_image_with_output_stride) {
4808 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4809 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4810 for (size_t channels = 1; channels <= 100; channels += 15) {
4811 AveragePoolingOperatorTester()
4812 .batch_size(2)
4813 .input_height(pooling_size.first)
4814 .input_width(pooling_size.second)
4815 .pooling_height(pooling_size.first)
4816 .pooling_width(pooling_size.second)
4817 .channels(channels)
4818 .output_pixel_stride(2 * channels + 3)
4819 .TestF32();
4820 AveragePoolingOperatorTester()
4821 .batch_size(2)
4822 .input_height(pooling_size.second)
4823 .input_width(pooling_size.first)
4824 .pooling_height(pooling_size.second)
4825 .pooling_width(pooling_size.first)
4826 .channels(channels)
4827 .output_pixel_stride(2 * channels + 3)
4828 .TestF32();
4829 }
4830}
4831
4832TEST(AVERAGE_POOLING_NHWC_F32, batched_large_image_with_qmin) {
4833 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4834 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4835 for (size_t channels = 1; channels <= 100; channels += 15) {
4836 AveragePoolingOperatorTester()
4837 .batch_size(2)
4838 .input_height(pooling_size.first)
4839 .input_width(pooling_size.second)
4840 .pooling_height(pooling_size.first)
4841 .pooling_width(pooling_size.second)
4842 .channels(channels)
4843 .qmin(128)
4844 .TestF32();
4845 AveragePoolingOperatorTester()
4846 .batch_size(2)
4847 .input_height(pooling_size.second)
4848 .input_width(pooling_size.first)
4849 .pooling_height(pooling_size.second)
4850 .pooling_width(pooling_size.first)
4851 .channels(channels)
4852 .qmin(128)
4853 .TestF32();
4854 }
4855}
4856
4857TEST(AVERAGE_POOLING_NHWC_F32, batched_large_image_with_qmax) {
4858 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4859 const std::pair<size_t, size_t> pooling_size = LargePoolSize(xnn_params.f32.gavgpool.mr * 2);
4860 for (size_t channels = 1; channels <= 100; channels += 15) {
4861 AveragePoolingOperatorTester()
4862 .batch_size(2)
4863 .input_height(pooling_size.first)
4864 .input_width(pooling_size.second)
4865 .pooling_height(pooling_size.first)
4866 .pooling_width(pooling_size.second)
4867 .channels(channels)
4868 .qmax(128)
4869 .TestF32();
4870 AveragePoolingOperatorTester()
4871 .batch_size(2)
4872 .input_height(pooling_size.second)
4873 .input_width(pooling_size.first)
4874 .pooling_height(pooling_size.second)
4875 .pooling_width(pooling_size.first)
4876 .channels(channels)
4877 .qmax(128)
4878 .TestF32();
4879 }
4880}
4881
4882/**************************** AVGPOOL path, setup ****************************/
4883
4884TEST(AVERAGE_POOLING_NHWC_F32, setup_increasing_batch) {
4885 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4886 AveragePoolingOperatorTester()
4887 .batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4888 .next_batch_size(5)
4889 .input_height(8)
4890 .input_width(8)
4891 .pooling_height(5)
4892 .pooling_width(3)
4893 .channels(24)
4894 .TestSetupF32();
4895}
4896
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4897TEST(AVERAGE_POOLING_NHWC_F32, setup_decreasing_batch) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]4898 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4899 AveragePoolingOperatorTester()
4900 .batch_size(5)
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4901 .next_batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4902 .input_height(8)
4903 .input_width(8)
4904 .pooling_height(5)
4905 .pooling_width(3)
4906 .channels(24)
4907 .TestSetupF32();
4908}
4909
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4910TEST(AVERAGE_POOLING_NHWC_F32, setup_changing_height) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]4911 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4912 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4913 .batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4914 .input_height(8)
4915 .input_width(8)
4916 .next_input_height(9)
4917 .pooling_height(5)
4918 .pooling_width(3)
4919 .channels(24)
4920 .TestSetupF32();
4921 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4922 .batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4923 .input_height(8)
4924 .input_width(8)
4925 .next_input_height(7)
4926 .pooling_height(5)
4927 .pooling_width(3)
4928 .channels(24)
4929 .TestSetupF32();
4930}
4931
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4932TEST(AVERAGE_POOLING_NHWC_F32, setup_changing_width) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]4933 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4934 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4935 .batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4936 .input_height(8)
4937 .input_width(8)
4938 .next_input_width(9)
4939 .pooling_height(5)
4940 .pooling_width(3)
4941 .channels(24)
4942 .TestSetupF32();
4943 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4944 .batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4945 .input_height(8)
4946 .input_width(8)
4947 .next_input_width(7)
4948 .pooling_height(5)
4949 .pooling_width(3)
4950 .channels(24)
4951 .TestSetupF32();
4952}
4953
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4954TEST(AVERAGE_POOLING_NHWC_F32, setup_swap_height_and_width) {
Marat Dukhan04f03be2019-11-19 12:36:47 -0800[diff] [blame]4955 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4956 AveragePoolingOperatorTester()
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4957 .batch_size(2)
XNNPACK Teamb455b122019-09-27 18:10:33 -0700[diff] [blame]4958 .input_height(9)
4959 .input_width(8)
4960 .next_input_height(8)
4961 .next_input_width(9)
4962 .pooling_height(5)
4963 .pooling_width(3)
4964 .channels(24)
4965 .TestSetupF32();
4966}
Marat Dukhan5868d802020-03-19 17:18:45 -0700[diff] [blame]4967
4968TEST(AVERAGE_POOLING_NHWC_F32, setup_local_to_global) {
4969 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4970 AveragePoolingOperatorTester()
4971 .batch_size(2)
4972 .input_height(6)
4973 .input_width(5)
4974 .next_input_height(5)
4975 .next_input_width(3)
4976 .pooling_height(5)
4977 .pooling_width(3)
4978 .channels(24)
4979 .TestSetupF32();
4980}
4981
4982TEST(AVERAGE_POOLING_NHWC_F32, setup_global_to_local) {
4983 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
4984 AveragePoolingOperatorTester()
4985 .batch_size(2)
4986 .input_height(5)
4987 .input_width(3)
4988 .next_input_height(6)
4989 .next_input_width(5)
4990 .pooling_height(5)
4991 .pooling_width(3)
4992 .channels(24)
4993 .TestSetupF32();
4994}