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
11 #include "clamp-operator-tester.h"
12
13
TEST(CLAMP_NC_F16,unit_batch)14 TEST(CLAMP_NC_F16, unit_batch) {
15 for (size_t channels = 1; channels < 100; channels++) {
16 ClampOperatorTester()
17 .batch_size(1)
18 .channels(channels)
19 .iterations(3)
20 .TestF16();
21 }
22 }
23
TEST(CLAMP_NC_F16,unit_batch_with_qmin)24 TEST(CLAMP_NC_F16, unit_batch_with_qmin) {
25 for (size_t channels = 1; channels < 100; channels += 15) {
26 for (int32_t qmin = std::numeric_limits<int16_t>::min() + 16;
27 qmin < std::numeric_limits<int16_t>::max() - 16;
28 qmin += 257)
29 {
30 ClampOperatorTester()
31 .batch_size(1)
32 .channels(channels)
33 .qmin(qmin)
34 .iterations(3)
35 .TestF16();
36 }
37 }
38 }
39
TEST(CLAMP_NC_F16,unit_batch_with_qmax)40 TEST(CLAMP_NC_F16, unit_batch_with_qmax) {
41 for (size_t channels = 1; channels < 100; channels += 15) {
42 for (int32_t qmax = std::numeric_limits<int16_t>::min() + 16;
43 qmax < std::numeric_limits<int16_t>::max() - 16;
44 qmax += 257)
45 {
46 ClampOperatorTester()
47 .batch_size(1)
48 .channels(channels)
49 .qmax(qmax)
50 .iterations(3)
51 .TestF16();
52 }
53 }
54 }
55
TEST(CLAMP_NC_F16,small_batch)56 TEST(CLAMP_NC_F16, small_batch) {
57 for (size_t channels = 1; channels < 100; channels++) {
58 ClampOperatorTester()
59 .batch_size(3)
60 .channels(channels)
61 .iterations(3)
62 .TestF16();
63 }
64 }
65
TEST(CLAMP_NC_F16,small_batch_with_input_stride)66 TEST(CLAMP_NC_F16, small_batch_with_input_stride) {
67 for (size_t channels = 1; channels < 100; channels += 15) {
68 ClampOperatorTester()
69 .batch_size(3)
70 .channels(channels)
71 .input_stride(129)
72 .iterations(3)
73 .TestF16();
74 }
75 }
76
TEST(CLAMP_NC_F16,small_batch_with_output_stride)77 TEST(CLAMP_NC_F16, small_batch_with_output_stride) {
78 for (size_t channels = 1; channels < 100; channels += 15) {
79 ClampOperatorTester()
80 .batch_size(3)
81 .channels(channels)
82 .output_stride(117)
83 .iterations(3)
84 .TestF16();
85 }
86 }
87
TEST(CLAMP_NC_F16,small_batch_with_input_and_output_stride)88 TEST(CLAMP_NC_F16, small_batch_with_input_and_output_stride) {
89 for (size_t channels = 1; channels < 100; channels += 15) {
90 ClampOperatorTester()
91 .batch_size(3)
92 .channels(channels)
93 .input_stride(129)
94 .output_stride(117)
95 .iterations(3)
96 .TestF16();
97 }
98 }
99
100
TEST(CLAMP_NC_F32,unit_batch)101 TEST(CLAMP_NC_F32, unit_batch) {
102 for (size_t channels = 1; channels < 100; channels++) {
103 ClampOperatorTester()
104 .batch_size(1)
105 .channels(channels)
106 .iterations(3)
107 .TestF32();
108 }
109 }
110
TEST(CLAMP_NC_F32,unit_batch_with_qmin)111 TEST(CLAMP_NC_F32, unit_batch_with_qmin) {
112 for (size_t channels = 1; channels < 100; channels += 15) {
113 for (int32_t qmin = std::numeric_limits<int16_t>::min() + 1;
114 qmin < std::numeric_limits<int16_t>::max();
115 qmin += 257)
116 {
117 ClampOperatorTester()
118 .batch_size(1)
119 .channels(channels)
120 .qmin(qmin)
121 .iterations(3)
122 .TestF32();
123 }
124 }
125 }
126
TEST(CLAMP_NC_F32,unit_batch_with_qmax)127 TEST(CLAMP_NC_F32, unit_batch_with_qmax) {
128 for (size_t channels = 1; channels < 100; channels += 15) {
129 for (int32_t qmax = std::numeric_limits<int16_t>::min() + 1;
130 qmax < std::numeric_limits<int16_t>::max();
131 qmax += 257)
132 {
133 ClampOperatorTester()
134 .batch_size(1)
135 .channels(channels)
136 .qmax(qmax)
137 .iterations(3)
138 .TestF32();
139 }
140 }
141 }
142
TEST(CLAMP_NC_F32,unit_batch_with_relu)143 TEST(CLAMP_NC_F32, unit_batch_with_relu) {
144 for (size_t channels = 1; channels < 100; channels++) {
145 ClampOperatorTester()
146 .batch_size(1)
147 .channels(channels)
148 .relu_activation(true)
149 .iterations(3)
150 .TestF32();
151 }
152 }
153
TEST(CLAMP_NC_F32,small_batch)154 TEST(CLAMP_NC_F32, small_batch) {
155 for (size_t channels = 1; channels < 100; channels++) {
156 ClampOperatorTester()
157 .batch_size(3)
158 .channels(channels)
159 .iterations(3)
160 .TestF32();
161 }
162 }
163
TEST(CLAMP_NC_F32,small_batch_with_input_stride)164 TEST(CLAMP_NC_F32, small_batch_with_input_stride) {
165 for (size_t channels = 1; channels < 100; channels += 15) {
166 ClampOperatorTester()
167 .batch_size(3)
168 .channels(channels)
169 .input_stride(129)
170 .iterations(3)
171 .TestF32();
172 }
173 }
174
TEST(CLAMP_NC_F32,small_batch_with_output_stride)175 TEST(CLAMP_NC_F32, small_batch_with_output_stride) {
176 for (size_t channels = 1; channels < 100; channels += 15) {
177 ClampOperatorTester()
178 .batch_size(3)
179 .channels(channels)
180 .output_stride(117)
181 .iterations(3)
182 .TestF32();
183 }
184 }
185
TEST(CLAMP_NC_F32,small_batch_with_input_and_output_stride)186 TEST(CLAMP_NC_F32, small_batch_with_input_and_output_stride) {
187 for (size_t channels = 1; channels < 100; channels += 15) {
188 ClampOperatorTester()
189 .batch_size(3)
190 .channels(channels)
191 .input_stride(129)
192 .output_stride(117)
193 .iterations(3)
194 .TestF32();
195 }
196 }
197
198
TEST(CLAMP_NC_S8,unit_batch)199 TEST(CLAMP_NC_S8, unit_batch) {
200 for (size_t channels = 1; channels < 100; channels++) {
201 ClampOperatorTester()
202 .batch_size(1)
203 .channels(channels)
204 .qmin(std::numeric_limits<int8_t>::min())
205 .qmax(std::numeric_limits<int8_t>::max())
206 .iterations(3)
207 .TestS8();
208 }
209 }
210
TEST(CLAMP_NC_S8,unit_batch_with_qmin)211 TEST(CLAMP_NC_S8, unit_batch_with_qmin) {
212 for (size_t channels = 1; channels < 100; channels += 15) {
213 for (int32_t qmin = std::numeric_limits<int8_t>::min() + 1;
214 qmin < std::numeric_limits<int8_t>::max();
215 qmin++)
216 {
217 ClampOperatorTester()
218 .batch_size(1)
219 .channels(channels)
220 .qmin(qmin)
221 .qmax(std::numeric_limits<int8_t>::max())
222 .iterations(3)
223 .TestS8();
224 }
225 }
226 }
227
TEST(CLAMP_NC_S8,unit_batch_with_qmax)228 TEST(CLAMP_NC_S8, unit_batch_with_qmax) {
229 for (size_t channels = 1; channels < 100; channels += 15) {
230 for (int32_t qmax = std::numeric_limits<int8_t>::min() + 1;
231 qmax < std::numeric_limits<int8_t>::max();
232 qmax++)
233 {
234 ClampOperatorTester()
235 .batch_size(1)
236 .channels(channels)
237 .qmin(std::numeric_limits<int8_t>::min())
238 .qmax(qmax)
239 .iterations(3)
240 .TestS8();
241 }
242 }
243 }
244
TEST(CLAMP_NC_S8,small_batch)245 TEST(CLAMP_NC_S8, small_batch) {
246 for (size_t channels = 1; channels < 100; channels++) {
247 ClampOperatorTester()
248 .batch_size(3)
249 .channels(channels)
250 .qmin(std::numeric_limits<int8_t>::min())
251 .qmax(std::numeric_limits<int8_t>::max())
252 .iterations(3)
253 .TestS8();
254 }
255 }
256
TEST(CLAMP_NC_S8,small_batch_with_input_stride)257 TEST(CLAMP_NC_S8, small_batch_with_input_stride) {
258 for (size_t channels = 1; channels < 100; channels += 15) {
259 ClampOperatorTester()
260 .batch_size(3)
261 .channels(channels)
262 .input_stride(129)
263 .qmin(std::numeric_limits<int8_t>::min())
264 .qmax(std::numeric_limits<int8_t>::max())
265 .iterations(3)
266 .TestS8();
267 }
268 }
269
TEST(CLAMP_NC_S8,small_batch_with_output_stride)270 TEST(CLAMP_NC_S8, small_batch_with_output_stride) {
271 for (size_t channels = 1; channels < 100; channels += 15) {
272 ClampOperatorTester()
273 .batch_size(3)
274 .channels(channels)
275 .output_stride(117)
276 .qmin(std::numeric_limits<int8_t>::min())
277 .qmax(std::numeric_limits<int8_t>::max())
278 .iterations(3)
279 .TestS8();
280 }
281 }
282
TEST(CLAMP_NC_S8,small_batch_with_input_and_output_stride)283 TEST(CLAMP_NC_S8, small_batch_with_input_and_output_stride) {
284 for (size_t channels = 1; channels < 100; channels += 15) {
285 ClampOperatorTester()
286 .batch_size(3)
287 .channels(channels)
288 .input_stride(129)
289 .output_stride(117)
290 .qmin(std::numeric_limits<int8_t>::min())
291 .qmax(std::numeric_limits<int8_t>::max())
292 .iterations(3)
293 .TestS8();
294 }
295 }
296
297
TEST(CLAMP_NC_U8,unit_batch)298 TEST(CLAMP_NC_U8, unit_batch) {
299 for (size_t channels = 1; channels < 100; channels++) {
300 ClampOperatorTester()
301 .batch_size(1)
302 .channels(channels)
303 .qmin(std::numeric_limits<uint8_t>::min())
304 .qmax(std::numeric_limits<uint8_t>::max())
305 .iterations(3)
306 .TestU8();
307 }
308 }
309
TEST(CLAMP_NC_U8,unit_batch_with_qmin)310 TEST(CLAMP_NC_U8, unit_batch_with_qmin) {
311 for (size_t channels = 1; channels < 100; channels += 15) {
312 for (int32_t qmin = std::numeric_limits<uint8_t>::min() + 1;
313 qmin < std::numeric_limits<uint8_t>::max();
314 qmin++)
315 {
316 ClampOperatorTester()
317 .batch_size(1)
318 .channels(channels)
319 .qmin(qmin)
320 .qmax(std::numeric_limits<uint8_t>::max())
321 .iterations(3)
322 .TestU8();
323 }
324 }
325 }
326
TEST(CLAMP_NC_U8,unit_batch_with_qmax)327 TEST(CLAMP_NC_U8, unit_batch_with_qmax) {
328 for (size_t channels = 1; channels < 100; channels += 15) {
329 for (uint8_t qmax = 1; qmax < 255; qmax++) {
330 ClampOperatorTester()
331 .batch_size(1)
332 .channels(channels)
333 .qmin(std::numeric_limits<uint8_t>::min())
334 .qmax(qmax)
335 .iterations(3)
336 .TestU8();
337 }
338 }
339 }
340
TEST(CLAMP_NC_U8,small_batch)341 TEST(CLAMP_NC_U8, small_batch) {
342 for (size_t channels = 1; channels < 100; channels++) {
343 ClampOperatorTester()
344 .batch_size(3)
345 .channels(channels)
346 .qmin(std::numeric_limits<uint8_t>::min())
347 .qmax(std::numeric_limits<uint8_t>::max())
348 .iterations(3)
349 .TestU8();
350 }
351 }
352
TEST(CLAMP_NC_U8,small_batch_with_input_stride)353 TEST(CLAMP_NC_U8, small_batch_with_input_stride) {
354 for (size_t channels = 1; channels < 100; channels += 15) {
355 ClampOperatorTester()
356 .batch_size(3)
357 .channels(channels)
358 .input_stride(129)
359 .qmin(std::numeric_limits<uint8_t>::min())
360 .qmax(std::numeric_limits<uint8_t>::max())
361 .iterations(3)
362 .TestU8();
363 }
364 }
365
TEST(CLAMP_NC_U8,small_batch_with_output_stride)366 TEST(CLAMP_NC_U8, small_batch_with_output_stride) {
367 for (size_t channels = 1; channels < 100; channels += 15) {
368 ClampOperatorTester()
369 .batch_size(3)
370 .channels(channels)
371 .output_stride(117)
372 .qmin(std::numeric_limits<uint8_t>::min())
373 .qmax(std::numeric_limits<uint8_t>::max())
374 .iterations(3)
375 .TestU8();
376 }
377 }
378
TEST(CLAMP_NC_U8,small_batch_with_input_and_output_stride)379 TEST(CLAMP_NC_U8, small_batch_with_input_and_output_stride) {
380 for (size_t channels = 1; channels < 100; channels += 15) {
381 ClampOperatorTester()
382 .batch_size(3)
383 .channels(channels)
384 .input_stride(129)
385 .output_stride(117)
386 .qmin(std::numeric_limits<uint8_t>::min())
387 .qmax(std::numeric_limits<uint8_t>::max())
388 .iterations(3)
389 .TestU8();
390 }
391 }
392