1 // Copyright 2019 Google LLC
2 //
3 // This source code is licensed under the BSD-style license found in the
4 // LICENSE file in the root directory of this source tree.
5
6 #include <gtest/gtest.h>
7
8 #include <xnnpack/params.h>
9
10 #include "prelu-operator-tester.h"
11
12
TEST(PRELU_NC_F16,unit_batch)13 TEST(PRELU_NC_F16, unit_batch) {
14 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
15 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
16 PReLUOperatorTester()
17 .batch_size(1)
18 .channels(channels)
19 .iterations(3)
20 .TestF16();
21 }
22 }
23
TEST(PRELU_NC_F16,small_batch)24 TEST(PRELU_NC_F16, small_batch) {
25 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
26 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
27 PReLUOperatorTester()
28 .batch_size(xnn_params.f16.prelu.row_tile)
29 .channels(channels)
30 .iterations(3)
31 .TestF16();
32 }
33 }
34
TEST(PRELU_NC_F16,small_batch_with_x_stride)35 TEST(PRELU_NC_F16, small_batch_with_x_stride) {
36 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
37 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
38 PReLUOperatorTester()
39 .batch_size(xnn_params.f16.prelu.row_tile)
40 .channels(channels)
41 .x_stride(337)
42 .iterations(3)
43 .TestF16();
44 }
45 }
46
TEST(PRELU_NC_F16,small_batch_with_y_stride)47 TEST(PRELU_NC_F16, small_batch_with_y_stride) {
48 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
49 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
50 PReLUOperatorTester()
51 .batch_size(xnn_params.f16.prelu.row_tile)
52 .channels(channels)
53 .y_stride(347)
54 .iterations(3)
55 .TestF16();
56 }
57 }
58
TEST(PRELU_NC_F16,small_batch_with_x_stride_and_y_stride)59 TEST(PRELU_NC_F16, small_batch_with_x_stride_and_y_stride) {
60 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
61 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
62 PReLUOperatorTester()
63 .batch_size(xnn_params.f16.prelu.row_tile)
64 .channels(channels)
65 .x_stride(337)
66 .y_stride(347)
67 .iterations(3)
68 .TestF16();
69 }
70 }
71
TEST(PRELU_NC_F16,large_batch)72 TEST(PRELU_NC_F16, large_batch) {
73 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
74 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
75 PReLUOperatorTester()
76 .batch_size(3 * xnn_params.f16.prelu.row_tile + 1)
77 .channels(channels)
78 .iterations(1)
79 .TestF16();
80 }
81 }
82
TEST(PRELU_NC_F16,large_batch_with_x_stride)83 TEST(PRELU_NC_F16, large_batch_with_x_stride) {
84 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
85 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
86 PReLUOperatorTester()
87 .batch_size(3 * xnn_params.f16.prelu.row_tile + 1)
88 .channels(channels)
89 .x_stride(337)
90 .iterations(1)
91 .TestF16();
92 }
93 }
94
TEST(PRELU_NC_F16,large_batch_with_y_stride)95 TEST(PRELU_NC_F16, large_batch_with_y_stride) {
96 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
97 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
98 PReLUOperatorTester()
99 .batch_size(3 * xnn_params.f16.prelu.row_tile + 1)
100 .channels(channels)
101 .y_stride(347)
102 .iterations(1)
103 .TestF16();
104 }
105 }
106
TEST(PRELU_NC_F16,large_batch_with_x_stride_and_y_stride)107 TEST(PRELU_NC_F16, large_batch_with_x_stride_and_y_stride) {
108 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
109 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
110 PReLUOperatorTester()
111 .batch_size(3 * xnn_params.f16.prelu.row_tile + 1)
112 .channels(channels)
113 .x_stride(337)
114 .y_stride(347)
115 .iterations(1)
116 .TestF16();
117 }
118 }
119
TEST(PRELU_NC_F16,fp32_weights)120 TEST(PRELU_NC_F16, fp32_weights) {
121 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
122 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
123 PReLUOperatorTester()
124 .batch_size(3 * xnn_params.f16.prelu.row_tile + 1)
125 .channels(channels)
126 .x_stride(337)
127 .y_stride(347)
128 .weights_type(PReLUOperatorTester::WeightsType::FP32)
129 .iterations(1)
130 .TestF16();
131 }
132 }
133
TEST(PRELU_NC_F16,weights_cache_unit_batch)134 TEST(PRELU_NC_F16, weights_cache_unit_batch) {
135 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
136 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
137 PReLUOperatorTester()
138 .batch_size(1)
139 .channels(channels)
140 .use_weights_cache(true)
141 .iterations(3)
142 .TestF16();
143 }
144 }
145
TEST(PRELU_NC_F16,weights_cache_fp32_weights)146 TEST(PRELU_NC_F16, weights_cache_fp32_weights) {
147 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
148 for (size_t channels = 1; channels < xnn_params.f16.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f16.prelu.channel_tile - 1)) {
149 PReLUOperatorTester()
150 .batch_size(3 * xnn_params.f16.prelu.row_tile + 1)
151 .channels(channels)
152 .x_stride(345)
153 .y_stride(347)
154 .weights_type(PReLUOperatorTester::WeightsType::FP32)
155 .use_weights_cache(true)
156 .iterations(1)
157 .TestF16();
158 }
159 }
160
TEST(PRELU_NC_F32,unit_batch)161 TEST(PRELU_NC_F32, unit_batch) {
162 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
163 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
164 PReLUOperatorTester()
165 .batch_size(1)
166 .channels(channels)
167 .iterations(3)
168 .TestF32();
169 }
170 }
171
TEST(PRELU_NC_F32,small_batch)172 TEST(PRELU_NC_F32, small_batch) {
173 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
174 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
175 PReLUOperatorTester()
176 .batch_size(xnn_params.f32.prelu.row_tile)
177 .channels(channels)
178 .iterations(3)
179 .TestF32();
180 }
181 }
182
TEST(PRELU_NC_F32,small_batch_with_x_stride)183 TEST(PRELU_NC_F32, small_batch_with_x_stride) {
184 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
185 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
186 PReLUOperatorTester()
187 .batch_size(xnn_params.f32.prelu.row_tile)
188 .channels(channels)
189 .x_stride(337)
190 .iterations(3)
191 .TestF32();
192 }
193 }
194
TEST(PRELU_NC_F32,small_batch_with_y_stride)195 TEST(PRELU_NC_F32, small_batch_with_y_stride) {
196 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
197 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
198 PReLUOperatorTester()
199 .batch_size(xnn_params.f32.prelu.row_tile)
200 .channels(channels)
201 .y_stride(347)
202 .iterations(3)
203 .TestF32();
204 }
205 }
206
TEST(PRELU_NC_F32,small_batch_with_x_stride_and_y_stride)207 TEST(PRELU_NC_F32, small_batch_with_x_stride_and_y_stride) {
208 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
209 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
210 PReLUOperatorTester()
211 .batch_size(xnn_params.f32.prelu.row_tile)
212 .channels(channels)
213 .x_stride(337)
214 .y_stride(347)
215 .iterations(3)
216 .TestF32();
217 }
218 }
219
TEST(PRELU_NC_F32,large_batch)220 TEST(PRELU_NC_F32, large_batch) {
221 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
222 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
223 PReLUOperatorTester()
224 .batch_size(3 * xnn_params.f32.prelu.row_tile + 1)
225 .channels(channels)
226 .iterations(1)
227 .TestF32();
228 }
229 }
230
TEST(PRELU_NC_F32,large_batch_with_x_stride)231 TEST(PRELU_NC_F32, large_batch_with_x_stride) {
232 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
233 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
234 PReLUOperatorTester()
235 .batch_size(3 * xnn_params.f32.prelu.row_tile + 1)
236 .channels(channels)
237 .x_stride(337)
238 .iterations(1)
239 .TestF32();
240 }
241 }
242
TEST(PRELU_NC_F32,large_batch_with_y_stride)243 TEST(PRELU_NC_F32, large_batch_with_y_stride) {
244 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
245 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
246 PReLUOperatorTester()
247 .batch_size(3 * xnn_params.f32.prelu.row_tile + 1)
248 .channels(channels)
249 .y_stride(347)
250 .iterations(1)
251 .TestF32();
252 }
253 }
254
TEST(PRELU_NC_F32,large_batch_with_x_stride_and_y_stride)255 TEST(PRELU_NC_F32, large_batch_with_x_stride_and_y_stride) {
256 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
257 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
258 PReLUOperatorTester()
259 .batch_size(3 * xnn_params.f32.prelu.row_tile + 1)
260 .channels(channels)
261 .x_stride(337)
262 .y_stride(347)
263 .iterations(1)
264 .TestF32();
265 }
266 }
267
TEST(PRELU_NC_F32,weights_cache_unit_batch)268 TEST(PRELU_NC_F32, weights_cache_unit_batch) {
269 ASSERT_EQ(xnn_status_success, xnn_initialize(nullptr /* allocator */));
270 for (size_t channels = 1; channels < xnn_params.f32.prelu.channel_tile * 10; channels += std::max<size_t>(1, xnn_params.f32.prelu.channel_tile - 1)) {
271 PReLUOperatorTester()
272 .batch_size(1)
273 .channels(channels)
274 .use_weights_cache(true)
275 .iterations(3)
276 .TestF32();
277 }
278 }
279