Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / XNNPACK / refs/tags/rel/11/fp3/8901.4.A.0016.6 / . / tools / generate-argmaxpool-test.py
blob: 3160b275fd793d3f54481c83e007dc24e1b2c3a0 [file] [log] [blame]
Marat Dukhan329da642019-11-19 21:44:39 -0800[diff] [blame]1#!/usr/bin/env python
2# Copyright 2019 Google LLC
3#
4# This source code is licensed under the BSD-style license found in the
5# LICENSE file in the root directory of this source tree.
6
7import argparse
8import codecs
9import math
10import os
11import re
12import sys
13import yaml
14
15sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
16from primes import next_prime
17import xngen
18import xnncommon
19
20
21parser = argparse.ArgumentParser(
22 description='ArgMaxPool microkernel test generator')
23parser.add_argument("-s", "--spec", metavar="FILE", required=True,
24 help="Specification (YAML) file")
25parser.add_argument("-o", "--output", metavar="FILE", required=True,
26 help='Output (C++ source) file')
27parser.set_defaults(defines=list())
28
29
30def split_ukernel_name(name):
31 match = re.match(r"^xnn_(f16|f32)_argmaxpool_ukernel_((\d+)p)?(\d+)x__(.+)_c(\d+)$", name)
32 if match is None:
33 raise ValueError("Unexpected microkernel name: " + name)
34
35 if match.group(2):
36 primary_tile = int(match.group(3))
37 incremental_tile = int(match.group(4))
38 else:
39 primary_tile = int(match.group(4))
40 incremental_tile = 0
41
42 channel_tile = int(match.group(6))
43
44 arch, isa = xnncommon.parse_target_name(target_name=match.group(5))
45 return primary_tile, incremental_tile, channel_tile, arch, isa
46
47
48ARGMAXPOOL_TEST_TEMPLATE = """\
49$if INCREMENTAL_TILE == 0:
50 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_unipass_fulltile) {
51 $if ISA_CHECK:
52 ${ISA_CHECK};
53 ArgMaxPoolMicrokernelTester()
54 .pooling_elements(${PRIMARY_TILE})
55 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
56 .channels(${CHANNEL_TILE})
57 .Test(${", ".join(TEST_ARGS)});
58 }
59
60 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_unipass_fulltile_with_input_offset) {
61 $if ISA_CHECK:
62 ${ISA_CHECK};
63 ArgMaxPoolMicrokernelTester()
64 .pooling_elements(${PRIMARY_TILE})
65 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
66 .channels(${CHANNEL_TILE})
67 .input_offset(${next_prime(CHANNEL_TILE+1)})
68 .Test(${", ".join(TEST_ARGS)});
69 }
70
71 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_unipass_fulltile_with_qmin) {
72 $if ISA_CHECK:
73 ${ISA_CHECK};
74 ArgMaxPoolMicrokernelTester()
75 .pooling_elements(${PRIMARY_TILE})
76 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
77 .channels(${CHANNEL_TILE})
78 .qmin(192)
79 .Test(${", ".join(TEST_ARGS)});
80 }
81
82 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_unipass_fulltile_with_qmax) {
83 $if ISA_CHECK:
84 ${ISA_CHECK};
85 ArgMaxPoolMicrokernelTester()
86 .pooling_elements(${PRIMARY_TILE})
87 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
88 .channels(${CHANNEL_TILE})
89 .qmax(192)
90 .Test(${", ".join(TEST_ARGS)});
91 }
92
93 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_unipass_subtile) {
94 $if ISA_CHECK:
95 ${ISA_CHECK};
96 for (size_t pooling_elements = 2; pooling_elements < ${PRIMARY_TILE}; pooling_elements++) {
97 ArgMaxPoolMicrokernelTester()
98 .pooling_elements(pooling_elements)
99 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
100 .channels(${CHANNEL_TILE})
101 .Test(${", ".join(TEST_ARGS)});
102 }
103 }
104
105 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_unipass_subtile_with_input_offset) {
106 $if ISA_CHECK:
107 ${ISA_CHECK};
108 for (size_t pooling_elements = 2; pooling_elements < ${PRIMARY_TILE}; pooling_elements++) {
109 ArgMaxPoolMicrokernelTester()
110 .pooling_elements(pooling_elements)
111 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
112 .channels(${CHANNEL_TILE})
113 .input_offset(${next_prime(CHANNEL_TILE+1)})
114 .Test(${", ".join(TEST_ARGS)});
115 }
116 }
117
118 $if CHANNEL_TILE > 1:
119 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_unipass_fulltile) {
120 $if ISA_CHECK:
121 ${ISA_CHECK};
122 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
123 ArgMaxPoolMicrokernelTester()
124 .pooling_elements(${PRIMARY_TILE})
125 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
126 .channels(channels)
127 .Test(${", ".join(TEST_ARGS)});
128 }
129 }
130
131 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_unipass_fulltile_with_input_offset) {
132 $if ISA_CHECK:
133 ${ISA_CHECK};
134 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
135 ArgMaxPoolMicrokernelTester()
136 .pooling_elements(${PRIMARY_TILE})
137 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
138 .channels(channels)
139 .input_offset(${next_prime(CHANNEL_TILE*8)})
140 .Test(${", ".join(TEST_ARGS)});
141 }
142 }
143
144 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_unipass_fulltile_with_qmin) {
145 $if ISA_CHECK:
146 ${ISA_CHECK};
147 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
148 ArgMaxPoolMicrokernelTester()
149 .pooling_elements(${PRIMARY_TILE})
150 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
151 .channels(channels)
152 .qmin(192)
153 .Test(${", ".join(TEST_ARGS)});
154 }
155 }
156
157 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_unipass_fulltile_with_qmax) {
158 $if ISA_CHECK:
159 ${ISA_CHECK};
160 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
161 ArgMaxPoolMicrokernelTester()
162 .pooling_elements(${PRIMARY_TILE})
163 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
164 .channels(channels)
165 .qmax(192)
166 .Test(${", ".join(TEST_ARGS)});
167 }
168 }
169
170 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_unipass_subtile) {
171 $if ISA_CHECK:
172 ${ISA_CHECK};
173 for (size_t pooling_elements = 2; pooling_elements < ${PRIMARY_TILE}; pooling_elements++) {
174 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
175 ArgMaxPoolMicrokernelTester()
176 .pooling_elements(pooling_elements)
177 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
178 .channels(channels)
179 .Test(${", ".join(TEST_ARGS)});
180 }
181 }
182 }
183
184 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_unipass_subtile_with_input_offset) {
185 $if ISA_CHECK:
186 ${ISA_CHECK};
187 for (size_t pooling_elements = 2; pooling_elements < ${PRIMARY_TILE}; pooling_elements++) {
188 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
189 ArgMaxPoolMicrokernelTester()
190 .pooling_elements(pooling_elements)
191 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
192 .channels(channels)
193 .input_offset(${next_prime(CHANNEL_TILE*8)})
194 .Test(${", ".join(TEST_ARGS)});
195 }
196 }
197 }
198
199 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_unipass_fulltile) {
200 $if ISA_CHECK:
201 ${ISA_CHECK};
202 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
203 ArgMaxPoolMicrokernelTester()
204 .pooling_elements(${PRIMARY_TILE})
205 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
206 .channels(channels)
207 .Test(${", ".join(TEST_ARGS)});
208 }
209 }
210
211 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_unipass_fulltile_with_input_offset) {
212 $if ISA_CHECK:
213 ${ISA_CHECK};
214 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
215 ArgMaxPoolMicrokernelTester()
216 .pooling_elements(${PRIMARY_TILE})
217 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
218 .channels(channels)
219 .input_offset(${next_prime(CHANNEL_TILE)})
220 .Test(${", ".join(TEST_ARGS)});
221 }
222 }
223
224 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_unipass_fulltile_with_qmin) {
225 $if ISA_CHECK:
226 ${ISA_CHECK};
227 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
228 ArgMaxPoolMicrokernelTester()
229 .pooling_elements(${PRIMARY_TILE})
230 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
231 .channels(channels)
232 .qmin(192)
233 .Test(${", ".join(TEST_ARGS)});
234 }
235 }
236
237 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_unipass_fulltile_with_qmax) {
238 $if ISA_CHECK:
239 ${ISA_CHECK};
240 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
241 ArgMaxPoolMicrokernelTester()
242 .pooling_elements(${PRIMARY_TILE})
243 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
244 .channels(channels)
245 .qmax(192)
246 .Test(${", ".join(TEST_ARGS)});
247 }
248 }
249
250 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_unipass_subtile) {
251 $if ISA_CHECK:
252 ${ISA_CHECK};
253 for (size_t pooling_elements = 2; pooling_elements < ${PRIMARY_TILE}; pooling_elements++) {
254 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
255 ArgMaxPoolMicrokernelTester()
256 .pooling_elements(pooling_elements)
257 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
258 .channels(channels)
259 .Test(${", ".join(TEST_ARGS)});
260 }
261 }
262 }
263
264 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_unipass_subtile_with_input_offset) {
265 $if ISA_CHECK:
266 ${ISA_CHECK};
267 for (size_t pooling_elements = 2; pooling_elements < ${PRIMARY_TILE}; pooling_elements++) {
268 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
269 ArgMaxPoolMicrokernelTester()
270 .pooling_elements(pooling_elements)
271 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
272 .channels(channels)
273 .input_offset(${next_prime(CHANNEL_TILE)})
274 .Test(${", ".join(TEST_ARGS)});
275 }
276 }
277 }
278
279 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_unipass_fulltile) {
280 $if ISA_CHECK:
281 ${ISA_CHECK};
282 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
283 ArgMaxPoolMicrokernelTester()
284 .pooling_elements(${PRIMARY_TILE})
285 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
286 .channels(channels)
287 .Test(${", ".join(TEST_ARGS)});
288 }
289 }
290
291 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_unipass_fulltile_with_input_offset) {
292 $if ISA_CHECK:
293 ${ISA_CHECK};
294 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
295 ArgMaxPoolMicrokernelTester()
296 .pooling_elements(${PRIMARY_TILE})
297 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
298 .channels(channels)
299 .input_offset(${next_prime(CHANNEL_TILE*2)})
300 .Test(${", ".join(TEST_ARGS)});
301 }
302 }
303
304 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_unipass_fulltile_with_qmin) {
305 $if ISA_CHECK:
306 ${ISA_CHECK};
307 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
308 ArgMaxPoolMicrokernelTester()
309 .pooling_elements(${PRIMARY_TILE})
310 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
311 .channels(channels)
312 .qmin(192)
313 .Test(${", ".join(TEST_ARGS)});
314 }
315 }
316
317 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_unipass_fulltile_with_qmax) {
318 $if ISA_CHECK:
319 ${ISA_CHECK};
320 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
321 ArgMaxPoolMicrokernelTester()
322 .pooling_elements(${PRIMARY_TILE})
323 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
324 .channels(channels)
325 .qmax(192)
326 .Test(${", ".join(TEST_ARGS)});
327 }
328 }
329
330 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_unipass_subtile) {
331 $if ISA_CHECK:
332 ${ISA_CHECK};
333 for (size_t pooling_elements = 2; pooling_elements < ${PRIMARY_TILE}; pooling_elements++) {
334 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
335 ArgMaxPoolMicrokernelTester()
336 .pooling_elements(pooling_elements)
337 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
338 .channels(channels)
339 .Test(${", ".join(TEST_ARGS)});
340 }
341 }
342 }
343
344 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_unipass_subtile_with_input_offset) {
345 $if ISA_CHECK:
346 ${ISA_CHECK};
347 for (size_t pooling_elements = 2; pooling_elements < ${PRIMARY_TILE}; pooling_elements++) {
348 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
349 ArgMaxPoolMicrokernelTester()
350 .pooling_elements(pooling_elements)
351 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
352 .channels(channels)
353 .input_offset(${next_prime(CHANNEL_TILE*2)})
354 .Test(${", ".join(TEST_ARGS)});
355 }
356 }
357 }
358
359$if INCREMENTAL_TILE != 0:
360 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_twopass_fulltile) {
361 $if ISA_CHECK:
362 ${ISA_CHECK};
363 ArgMaxPoolMicrokernelTester()
364 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
365 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
366 .channels(${CHANNEL_TILE})
367 .Test(${", ".join(TEST_ARGS)});
368 }
369
370 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_twopass_fulltile_with_input_offset) {
371 $if ISA_CHECK:
372 ${ISA_CHECK};
373 ArgMaxPoolMicrokernelTester()
374 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
375 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
376 .channels(${CHANNEL_TILE})
377 .input_offset(${next_prime(CHANNEL_TILE+1)})
378 .Test(${", ".join(TEST_ARGS)});
379 }
380
381 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_twopass_fulltile_with_qmin) {
382 $if ISA_CHECK:
383 ${ISA_CHECK};
384 ArgMaxPoolMicrokernelTester()
385 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
386 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
387 .channels(${CHANNEL_TILE})
388 .qmin(192)
389 .Test(${", ".join(TEST_ARGS)});
390 }
391
392 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_twopass_fulltile_with_qmax) {
393 $if ISA_CHECK:
394 ${ISA_CHECK};
395 ArgMaxPoolMicrokernelTester()
396 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
397 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
398 .channels(${CHANNEL_TILE})
399 .qmax(192)
400 .Test(${", ".join(TEST_ARGS)});
401 }
402
403 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_twopass_subtile) {
404 $if ISA_CHECK:
405 ${ISA_CHECK};
406 for (size_t pooling_elements = ${PRIMARY_TILE+1}; pooling_elements < ${PRIMARY_TILE+INCREMENTAL_TILE}; pooling_elements++) {
407 ArgMaxPoolMicrokernelTester()
408 .pooling_elements(pooling_elements)
409 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
410 .channels(${CHANNEL_TILE})
411 .Test(${", ".join(TEST_ARGS)});
412 }
413 }
414
415 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_twopass_subtile_with_input_offset) {
416 $if ISA_CHECK:
417 ${ISA_CHECK};
418 for (size_t pooling_elements = ${PRIMARY_TILE+1}; pooling_elements < ${PRIMARY_TILE+INCREMENTAL_TILE}; pooling_elements++) {
419 ArgMaxPoolMicrokernelTester()
420 .pooling_elements(pooling_elements)
421 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
422 .channels(${CHANNEL_TILE})
423 .input_offset(${next_prime(CHANNEL_TILE+1)})
424 .Test(${", ".join(TEST_ARGS)});
425 }
426 }
427
428 $if CHANNEL_TILE > 1:
429 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_twopass_fulltile) {
430 $if ISA_CHECK:
431 ${ISA_CHECK};
432 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
433 ArgMaxPoolMicrokernelTester()
434 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
435 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
436 .channels(channels)
437 .Test(${", ".join(TEST_ARGS)});
438 }
439 }
440
441 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_twopass_fulltile_with_input_offset) {
442 $if ISA_CHECK:
443 ${ISA_CHECK};
444 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
445 ArgMaxPoolMicrokernelTester()
446 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
447 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
448 .channels(channels)
449 .input_offset(${next_prime(CHANNEL_TILE*5)})
450 .Test(${", ".join(TEST_ARGS)});
451 }
452 }
453
454 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_twopass_fulltile_with_qmin) {
455 $if ISA_CHECK:
456 ${ISA_CHECK};
457 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
458 ArgMaxPoolMicrokernelTester()
459 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
460 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
461 .channels(channels)
462 .qmin(192)
463 .Test(${", ".join(TEST_ARGS)});
464 }
465 }
466
467 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_twopass_fulltile_with_qmax) {
468 $if ISA_CHECK:
469 ${ISA_CHECK};
470 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
471 ArgMaxPoolMicrokernelTester()
472 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
473 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
474 .channels(channels)
475 .qmax(192)
476 .Test(${", ".join(TEST_ARGS)});
477 }
478 }
479
480 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_twopass_subtile) {
481 $if ISA_CHECK:
482 ${ISA_CHECK};
483 for (size_t pooling_elements = ${PRIMARY_TILE+1}; pooling_elements < ${PRIMARY_TILE+INCREMENTAL_TILE}; pooling_elements++) {
484 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
485 ArgMaxPoolMicrokernelTester()
486 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
487 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
488 .channels(channels)
489 .Test(${", ".join(TEST_ARGS)});
490 }
491 }
492 }
493
494 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_twopass_subtile_with_input_offset) {
495 $if ISA_CHECK:
496 ${ISA_CHECK};
497 for (size_t pooling_elements = ${PRIMARY_TILE+1}; pooling_elements < ${PRIMARY_TILE+INCREMENTAL_TILE}; pooling_elements++) {
498 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
499 ArgMaxPoolMicrokernelTester()
500 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
501 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
502 .channels(channels)
503 .input_offset(${next_prime(CHANNEL_TILE*8)})
504 .Test(${", ".join(TEST_ARGS)});
505 }
506 }
507 }
508
509 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_twopass_fulltile) {
510 $if ISA_CHECK:
511 ${ISA_CHECK};
512 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
513 ArgMaxPoolMicrokernelTester()
514 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
515 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
516 .channels(channels)
517 .Test(${", ".join(TEST_ARGS)});
518 }
519 }
520
521 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_twopass_fulltile_with_input_offset) {
522 $if ISA_CHECK:
523 ${ISA_CHECK};
524 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
525 ArgMaxPoolMicrokernelTester()
526 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
527 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
528 .channels(channels)
529 .input_offset(${next_prime(CHANNEL_TILE)})
530 .Test(${", ".join(TEST_ARGS)});
531 }
532 }
533
534 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_twopass_fulltile_with_qmin) {
535 $if ISA_CHECK:
536 ${ISA_CHECK};
537 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
538 ArgMaxPoolMicrokernelTester()
539 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
540 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
541 .channels(channels)
542 .qmin(192)
543 .Test(${", ".join(TEST_ARGS)});
544 }
545 }
546
547 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_twopass_fulltile_with_qmax) {
548 $if ISA_CHECK:
549 ${ISA_CHECK};
550 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
551 ArgMaxPoolMicrokernelTester()
552 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
553 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
554 .channels(channels)
555 .qmax(192)
556 .Test(${", ".join(TEST_ARGS)});
557 }
558 }
559
560 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_twopass_subtile) {
561 $if ISA_CHECK:
562 ${ISA_CHECK};
563 for (size_t pooling_elements = ${PRIMARY_TILE+1}; pooling_elements < ${PRIMARY_TILE+INCREMENTAL_TILE}; pooling_elements++) {
564 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
565 ArgMaxPoolMicrokernelTester()
566 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
567 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
568 .channels(channels)
569 .Test(${", ".join(TEST_ARGS)});
570 }
571 }
572 }
573
574 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_twopass_subtile_with_input_offset) {
575 $if ISA_CHECK:
576 ${ISA_CHECK};
577 for (size_t pooling_elements = ${PRIMARY_TILE+1}; pooling_elements < ${PRIMARY_TILE+INCREMENTAL_TILE}; pooling_elements++) {
578 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
579 ArgMaxPoolMicrokernelTester()
580 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
581 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
582 .channels(channels)
583 .input_offset(${next_prime(CHANNEL_TILE)})
584 .Test(${", ".join(TEST_ARGS)});
585 }
586 }
587 }
588
589 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_twopass_fulltile) {
590 $if ISA_CHECK:
591 ${ISA_CHECK};
592 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
593 ArgMaxPoolMicrokernelTester()
594 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
595 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
596 .channels(channels)
597 .Test(${", ".join(TEST_ARGS)});
598 }
599 }
600
601 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_twopass_fulltile_with_input_offset) {
602 $if ISA_CHECK:
603 ${ISA_CHECK};
604 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
605 ArgMaxPoolMicrokernelTester()
606 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
607 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
608 .channels(channels)
609 .input_offset(${next_prime(CHANNEL_TILE*2)})
610 .Test(${", ".join(TEST_ARGS)});
611 }
612 }
613
614 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_twopass_fulltile_with_qmin) {
615 $if ISA_CHECK:
616 ${ISA_CHECK};
617 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
618 ArgMaxPoolMicrokernelTester()
619 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
620 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
621 .channels(channels)
622 .qmin(192)
623 .Test(${", ".join(TEST_ARGS)});
624 }
625 }
626
627 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_twopass_fulltile_with_qmax) {
628 $if ISA_CHECK:
629 ${ISA_CHECK};
630 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
631 ArgMaxPoolMicrokernelTester()
632 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
633 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
634 .channels(channels)
635 .qmax(192)
636 .Test(${", ".join(TEST_ARGS)});
637 }
638 }
639
640 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_twopass_subtile) {
641 $if ISA_CHECK:
642 ${ISA_CHECK};
643 for (size_t pooling_elements = ${PRIMARY_TILE+1}; pooling_elements < ${PRIMARY_TILE+INCREMENTAL_TILE}; pooling_elements++) {
644 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
645 ArgMaxPoolMicrokernelTester()
646 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
647 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
648 .channels(channels)
649 .Test(${", ".join(TEST_ARGS)});
650 }
651 }
652 }
653
654 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_twopass_subtile_with_input_offset) {
655 $if ISA_CHECK:
656 ${ISA_CHECK};
657 for (size_t pooling_elements = ${PRIMARY_TILE+1}; pooling_elements < ${PRIMARY_TILE+INCREMENTAL_TILE}; pooling_elements++) {
658 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
659 ArgMaxPoolMicrokernelTester()
660 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
661 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
662 .channels(channels)
663 .input_offset(${next_prime(CHANNEL_TILE*2)})
664 .Test(${", ".join(TEST_ARGS)});
665 }
666 }
667 }
668
669 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_multipass) {
670 $if ISA_CHECK:
671 ${ISA_CHECK};
672 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
673 ArgMaxPoolMicrokernelTester()
674 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
675 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
676 .channels(${CHANNEL_TILE})
677 .Test(${", ".join(TEST_ARGS)});
678 }
679 }
680
681 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_multipass_with_input_offset) {
682 $if ISA_CHECK:
683 ${ISA_CHECK};
684 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
685 ArgMaxPoolMicrokernelTester()
686 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
687 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
688 .channels(${CHANNEL_TILE})
689 .input_offset(${next_prime(CHANNEL_TILE+1)})
690 .Test(${", ".join(TEST_ARGS)});
691 }
692 }
693
694 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_multipass_with_qmin) {
695 $if ISA_CHECK:
696 ${ISA_CHECK};
697 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
698 ArgMaxPoolMicrokernelTester()
699 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
700 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
701 .channels(${CHANNEL_TILE})
702 .qmin(192)
703 .Test(${", ".join(TEST_ARGS)});
704 }
705 }
706
707 TEST(${TEST_NAME}, channels_eq_${CHANNEL_TILE}_multipass_with_qmax) {
708 $if ISA_CHECK:
709 ${ISA_CHECK};
710 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
711 ArgMaxPoolMicrokernelTester()
712 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
713 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
714 .channels(${CHANNEL_TILE})
715 .qmax(192)
716 .Test(${", ".join(TEST_ARGS)});
717 }
718 }
719
720 $if CHANNEL_TILE > 1:
721 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_multipass) {
722 $if ISA_CHECK:
723 ${ISA_CHECK};
724 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
725 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
726 ArgMaxPoolMicrokernelTester()
727 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
728 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
729 .channels(channels)
730 .Test(${", ".join(TEST_ARGS)});
731 }
732 }
733 }
734
735 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_multipass_with_input_offset) {
736 $if ISA_CHECK:
737 ${ISA_CHECK};
738 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
739 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
740 ArgMaxPoolMicrokernelTester()
741 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
742 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
743 .channels(channels)
744 .input_offset(${next_prime(CHANNEL_TILE*8)})
745 .Test(${", ".join(TEST_ARGS)});
746 }
747 }
748 }
749
750 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_multipass_with_qmin) {
751 $if ISA_CHECK:
752 ${ISA_CHECK};
753 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
754 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
755 ArgMaxPoolMicrokernelTester()
756 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
757 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
758 .channels(channels)
759 .qmin(192)
760 .Test(${", ".join(TEST_ARGS)});
761 }
762 }
763 }
764
765 TEST(${TEST_NAME}, channels_div_${CHANNEL_TILE}_multipass_with_qmax) {
766 $if ISA_CHECK:
767 ${ISA_CHECK};
768 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
769 for (size_t channels = ${CHANNEL_TILE*2}; channels < ${CHANNEL_TILE*8}; channels += ${CHANNEL_TILE}) {
770 ArgMaxPoolMicrokernelTester()
771 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
772 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
773 .channels(channels)
774 .qmax(192)
775 .Test(${", ".join(TEST_ARGS)});
776 }
777 }
778 }
779
780 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_multipass) {
781 $if ISA_CHECK:
782 ${ISA_CHECK};
783 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
784 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
785 ArgMaxPoolMicrokernelTester()
786 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
787 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
788 .channels(channels)
789 .Test(${", ".join(TEST_ARGS)});
790 }
791 }
792 }
793
794 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_multipass_with_input_offset) {
795 $if ISA_CHECK:
796 ${ISA_CHECK};
797 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
798 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
799 ArgMaxPoolMicrokernelTester()
800 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
801 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
802 .channels(channels)
803 .input_offset(${CHANNEL_TILE})
804 .Test(${", ".join(TEST_ARGS)});
805 }
806 }
807 }
808
809 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_multipass_with_qmin) {
810 $if ISA_CHECK:
811 ${ISA_CHECK};
812 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
813 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
814 ArgMaxPoolMicrokernelTester()
815 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
816 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
817 .channels(channels)
818 .qmin(192)
819 .Test(${", ".join(TEST_ARGS)});
820 }
821 }
822 }
823
824 TEST(${TEST_NAME}, channels_lt_${CHANNEL_TILE}_multipass_with_qmax) {
825 $if ISA_CHECK:
826 ${ISA_CHECK};
827 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
828 for (size_t channels = 1; channels < ${CHANNEL_TILE}; channels++) {
829 ArgMaxPoolMicrokernelTester()
830 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
831 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
832 .channels(channels)
833 .qmax(192)
834 .Test(${", ".join(TEST_ARGS)});
835 }
836 }
837 }
838
839 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_multipass) {
840 $if ISA_CHECK:
841 ${ISA_CHECK};
842 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
843 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
844 ArgMaxPoolMicrokernelTester()
845 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
846 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
847 .channels(channels)
848 .Test(${", ".join(TEST_ARGS)});
849 }
850 }
851 }
852
853 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_multipass_with_input_offset) {
854 $if ISA_CHECK:
855 ${ISA_CHECK};
856 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
857 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
858 ArgMaxPoolMicrokernelTester()
859 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
860 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
861 .channels(channels)
862 .input_offset(${next_prime(CHANNEL_TILE*2)})
863 .Test(${", ".join(TEST_ARGS)});
864 }
865 }
866 }
867
868 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_multipass_with_qmin) {
869 $if ISA_CHECK:
870 ${ISA_CHECK};
871 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
872 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
873 ArgMaxPoolMicrokernelTester()
874 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
875 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
876 .channels(channels)
877 .qmin(192)
878 .Test(${", ".join(TEST_ARGS)});
879 }
880 }
881 }
882
883 TEST(${TEST_NAME}, channels_gt_${CHANNEL_TILE}_multipass_with_qmax) {
884 $if ISA_CHECK:
885 ${ISA_CHECK};
886 for (size_t pooling_elements = ${PRIMARY_TILE+INCREMENTAL_TILE+1}; pooling_elements <= ${PRIMARY_TILE+INCREMENTAL_TILE*3}; pooling_elements += 3) {
887 for (size_t channels = ${CHANNEL_TILE+1}; channels < ${10 if CHANNEL_TILE == 1 else CHANNEL_TILE*2}; channels++) {
888 ArgMaxPoolMicrokernelTester()
889 .pooling_elements(${PRIMARY_TILE+INCREMENTAL_TILE})
890 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
891 .channels(channels)
892 .qmax(192)
893 .Test(${", ".join(TEST_ARGS)});
894 }
895 }
896 }
897
898$if INCREMENTAL_TILE == 0:
899 $MIN_POOLING, MAX_POOLING = 2, PRIMARY_TILE
900$else:
901 $MIN_POOLING, MAX_POOLING = PRIMARY_TILE + 1, PRIMARY_TILE + INCREMENTAL_TILE
902
903TEST(${TEST_NAME}, few_output_pixels) {
904 $if ISA_CHECK:
905 ${ISA_CHECK};
906 for (size_t output_pixels = 2; output_pixels <= 5; output_pixels++) {
907 for (size_t pooling_elements = ${MIN_POOLING}; pooling_elements <= ${MAX_POOLING}; pooling_elements++) {
908 for (size_t channels = 1; channels <= ${CHANNEL_TILE*5}; channels += ${max(1, CHANNEL_TILE-1)}) {
909 ArgMaxPoolMicrokernelTester()
910 .output_pixels(output_pixels)
911 .pooling_elements(pooling_elements)
912 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
913 .channels(channels)
914 .Test(${", ".join(TEST_ARGS)});
915 }
916 }
917 }
918}
919
920TEST(${TEST_NAME}, few_output_pixels_with_input_offset) {
921 $if ISA_CHECK:
922 ${ISA_CHECK};
923 for (size_t output_pixels = 2; output_pixels <= 5; output_pixels++) {
924 for (size_t pooling_elements = ${MIN_POOLING}; pooling_elements <= ${MAX_POOLING}; pooling_elements++) {
925 for (size_t channels = 1; channels <= ${CHANNEL_TILE*5}; channels += ${max(1, CHANNEL_TILE-1)}) {
926 ArgMaxPoolMicrokernelTester()
927 .output_pixels(output_pixels)
928 .pooling_elements(pooling_elements)
929 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
930 .channels(channels)
931 .input_offset(${next_prime(CHANNEL_TILE*5+1)})
932 .Test(${", ".join(TEST_ARGS)});
933 }
934 }
935 }
936}
937
938TEST(${TEST_NAME}, few_output_pixels_with_qmin) {
939 $if ISA_CHECK:
940 ${ISA_CHECK};
941 for (size_t output_pixels = 2; output_pixels <= 5; output_pixels++) {
942 for (size_t pooling_elements = ${MIN_POOLING}; pooling_elements <= ${MAX_POOLING}; pooling_elements++) {
943 for (size_t channels = 1; channels <= ${CHANNEL_TILE*5}; channels += ${max(1, CHANNEL_TILE-1)}) {
944 ArgMaxPoolMicrokernelTester()
945 .output_pixels(output_pixels)
946 .pooling_elements(pooling_elements)
947 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
948 .channels(channels)
949 .qmin(192)
950 .Test(${", ".join(TEST_ARGS)});
951 }
952 }
953 }
954}
955
956TEST(${TEST_NAME}, few_output_pixels_with_qmax) {
957 $if ISA_CHECK:
958 ${ISA_CHECK};
959 for (size_t output_pixels = 2; output_pixels <= 5; output_pixels++) {
960 for (size_t pooling_elements = ${MIN_POOLING}; pooling_elements <= ${MAX_POOLING}; pooling_elements++) {
961 for (size_t channels = 1; channels <= ${CHANNEL_TILE*5}; channels += ${max(1, CHANNEL_TILE-1)}) {
962 ArgMaxPoolMicrokernelTester()
963 .output_pixels(output_pixels)
964 .pooling_elements(pooling_elements)
965 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
966 .channels(channels)
967 .qmax(192)
968 .Test(${", ".join(TEST_ARGS)});
969 }
970 }
971 }
972}
973
974TEST(${TEST_NAME}, few_output_pixels_with_output_stride) {
975 $if ISA_CHECK:
976 ${ISA_CHECK};
977 for (size_t output_pixels = 2; output_pixels <= 5; output_pixels++) {
978 for (size_t pooling_elements = ${MIN_POOLING}; pooling_elements <= ${MAX_POOLING}; pooling_elements++) {
979 for (size_t channels = 1; channels <= ${CHANNEL_TILE*5}; channels += ${max(1, CHANNEL_TILE-1)}) {
980 ArgMaxPoolMicrokernelTester()
981 .output_pixels(output_pixels)
982 .pooling_elements(pooling_elements)
983 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
984 .channels(channels)
985 .output_stride(${next_prime(CHANNEL_TILE*5+1)})
986 .Test(${", ".join(TEST_ARGS)});
987 }
988 }
989 }
990}
991
992TEST(${TEST_NAME}, few_output_pixels_with_step) {
993 $if ISA_CHECK:
994 ${ISA_CHECK};
995 for (size_t output_pixels = 2; output_pixels <= 5; output_pixels++) {
996 for (size_t pooling_elements = ${MIN_POOLING}; pooling_elements <= ${MAX_POOLING}; pooling_elements++) {
997 for (size_t channels = 1; channels <= ${CHANNEL_TILE*5}; channels += ${max(1, CHANNEL_TILE-1)}) {
998 for (size_t step = 2; step <= pooling_elements; step++) {
999 ArgMaxPoolMicrokernelTester()
1000 .output_pixels(output_pixels)
1001 .pooling_elements(pooling_elements)
1002 .pooling_tile(${", ".join(map(str, filter(bool, [PRIMARY_TILE, INCREMENTAL_TILE])))})
1003 .step(step)
1004 .channels(channels)
1005 .output_stride(${next_prime(CHANNEL_TILE*5+1)})
1006 .Test(${", ".join(TEST_ARGS)});
1007 }
1008 }
1009 }
1010 }
1011}
1012"""
1013
1014
1015def generate_test_cases(ukernel, primary_tile, incremental_tile, channel_tile,
1016 isa):
1017 """Generates all tests cases for a ARGMAXPOOL micro-kernel.
1018
1019 Args:
1020 ukernel: C name of the micro-kernel function.
1021 primary_tile: Number of rows (pixels) processed per one iteration of the
1022 primary outer loop of the micro-kernel.
1023 incremental_tile: Number of rows (pixels) processed per one iteration of
1024 the incremental outer loop of the micro-kernel.
1025 channel_tile: Number of channels processed per one iteration of the inner
1026 loops of the micro-kernel.
1027 isa: instruction set required to run the micro-kernel. Generated unit test
1028 will skip execution if the host processor doesn't support this ISA.
1029
1030 Returns:
1031 Code for the test case.
1032 """
1033 _, test_name = ukernel.split("_", 1)
1034 _, datatype, ukernel_type, _ = ukernel.split("_", 3)
1035 test_args = [ukernel]
1036 if not isa or isa == "psimd":
1037 test_args.append("ArgMaxPoolMicrokernelTester::Variant::Scalar")
1038 return xngen.preprocess(ARGMAXPOOL_TEST_TEMPLATE, {
1039 "TEST_NAME": test_name.upper().replace("UKERNEL_", ""),
1040 "TEST_ARGS": test_args,
1041 "DATATYPE": datatype,
1042 "PRIMARY_TILE": primary_tile,
1043 "INCREMENTAL_TILE": incremental_tile,
1044 "CHANNEL_TILE": channel_tile,
1045 "ISA_CHECK": xnncommon.generate_isa_check_macro(isa),
1046 "next_prime": next_prime,
1047 })
1048
1049
1050def main(args):
1051 options = parser.parse_args(args)
1052
1053 with codecs.open(options.spec, "r", encoding="utf-8") as spec_file:
1054 spec_yaml = yaml.safe_load(spec_file)
1055 if not isinstance(spec_yaml, list):
1056 raise ValueError("expected a list of micro-kernels in the spec")
1057
1058 tests = """\
1059// Copyright 2019 Google LLC
1060//
1061// This source code is licensed under the BSD-style license found in the
1062// LICENSE file in the root directory of this source tree.
1063//
1064// Auto-generated file. Do not edit!
1065// Specification: {specification}
1066// Generator: {generator}
1067
1068
1069#include <gtest/gtest.h>
1070
1071#include <xnnpack/common.h>
1072#include <xnnpack/isa-checks.h>
1073
1074#include <xnnpack/argmaxpool.h>
1075#include "argmaxpool-microkernel-tester.h"
1076""".format(specification=options.spec, generator=sys.argv[0])
1077
1078 for ukernel_spec in spec_yaml:
1079 name = ukernel_spec["name"]
1080 primary_tile, incremental_tile, channel_tile, arch, isa = \
1081 split_ukernel_name(name)
1082
1083 # specification can override architecture
1084 arch = ukernel_spec.get("arch", arch)
1085
1086 test_case = generate_test_cases(name, primary_tile, incremental_tile,
1087 channel_tile, isa)
1088 tests += "\n\n" + xnncommon.postprocess_test_case(test_case, arch, isa)
1089
1090 with codecs.open(options.output, "w", encoding="utf-8") as output_file:
1091 output_file.write(tests)
1092
1093
1094if __name__ == "__main__":
1095 main(sys.argv[1:])