• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <xnnpack/common.h>
12 #include <xnnpack/isa-checks.h>
13 
14 #include <xnnpack/zip.h>
15 #include "zip-microkernel-tester.h"
16 
17 
18 #if XNN_ARCH_ARM || XNN_ARCH_ARM64
TEST(X8_ZIP_X2__NEON,n_eq_8)19   TEST(X8_ZIP_X2__NEON, n_eq_8) {
20     TEST_REQUIRES_ARM_NEON;
21     ZipMicrokernelTester()
22       .n(8)
23       .g(2)
24       .Test(xnn_x8_zip_x2_ukernel__neon);
25   }
26 
TEST(X8_ZIP_X2__NEON,n_div_16)27   TEST(X8_ZIP_X2__NEON, n_div_16) {
28     TEST_REQUIRES_ARM_NEON;
29     for (size_t n = 8; n < 128; n += 8) {
30       ZipMicrokernelTester()
31         .n(n)
32         .g(2)
33         .Test(xnn_x8_zip_x2_ukernel__neon);
34     }
35   }
36 
TEST(X8_ZIP_X2__NEON,n_gt_8)37   TEST(X8_ZIP_X2__NEON, n_gt_8) {
38     TEST_REQUIRES_ARM_NEON;
39     for (size_t n = 9; n < 16; n++) {
40       ZipMicrokernelTester()
41         .n(n)
42         .g(2)
43         .Test(xnn_x8_zip_x2_ukernel__neon);
44     }
45   }
46 
TEST(X8_ZIP_X2__NEON,n_lt_8)47   TEST(X8_ZIP_X2__NEON, n_lt_8) {
48     TEST_REQUIRES_ARM_NEON;
49     for (size_t n = 1; n < 8; n++) {
50       ZipMicrokernelTester()
51         .n(n)
52         .g(2)
53         .Test(xnn_x8_zip_x2_ukernel__neon);
54     }
55   }
56 
TEST(X8_ZIP_X3__NEON,n_eq_8)57   TEST(X8_ZIP_X3__NEON, n_eq_8) {
58     TEST_REQUIRES_ARM_NEON;
59     ZipMicrokernelTester()
60       .n(9)
61       .g(3)
62       .Test(xnn_x8_zip_x3_ukernel__neon);
63   }
64 
TEST(X8_ZIP_X3__NEON,n_div_8)65   TEST(X8_ZIP_X3__NEON, n_div_8) {
66     TEST_REQUIRES_ARM_NEON;
67     for (size_t n = 8; n < 128; n += 8) {
68       ZipMicrokernelTester()
69         .n(n)
70         .g(3)
71         .Test(xnn_x8_zip_x3_ukernel__neon);
72     }
73   }
74 
TEST(X8_ZIP_X3__NEON,n_gt_8)75   TEST(X8_ZIP_X3__NEON, n_gt_8) {
76     TEST_REQUIRES_ARM_NEON;
77     for (size_t n = 9; n < 16; n++) {
78       ZipMicrokernelTester()
79         .n(n)
80         .g(3)
81         .Test(xnn_x8_zip_x3_ukernel__neon);
82     }
83   }
84 
TEST(X8_ZIP_X3__NEON,n_lt_8)85   TEST(X8_ZIP_X3__NEON, n_lt_8) {
86     TEST_REQUIRES_ARM_NEON;
87     for (size_t n = 1; n < 8; n++) {
88       ZipMicrokernelTester()
89         .n(n)
90         .g(3)
91         .Test(xnn_x8_zip_x3_ukernel__neon);
92     }
93   }
94 
TEST(X8_ZIP_X4__NEON,n_eq_8)95   TEST(X8_ZIP_X4__NEON, n_eq_8) {
96     TEST_REQUIRES_ARM_NEON;
97     ZipMicrokernelTester()
98       .n(8)
99       .g(4)
100       .Test(xnn_x8_zip_x4_ukernel__neon);
101   }
102 
TEST(X8_ZIP_X4__NEON,n_div_8)103   TEST(X8_ZIP_X4__NEON, n_div_8) {
104     TEST_REQUIRES_ARM_NEON;
105     for (size_t n = 8; n < 128; n += 8) {
106       ZipMicrokernelTester()
107         .n(n)
108         .g(4)
109         .Test(xnn_x8_zip_x4_ukernel__neon);
110     }
111   }
112 
TEST(X8_ZIP_X4__NEON,n_gt_8)113   TEST(X8_ZIP_X4__NEON, n_gt_8) {
114     TEST_REQUIRES_ARM_NEON;
115     for (size_t n = 9; n < 16; n++) {
116       ZipMicrokernelTester()
117         .n(n)
118         .g(4)
119         .Test(xnn_x8_zip_x4_ukernel__neon);
120     }
121   }
122 
TEST(X8_ZIP_X4__NEON,n_lt_16)123   TEST(X8_ZIP_X4__NEON, n_lt_16) {
124     TEST_REQUIRES_ARM_NEON;
125     for (size_t n = 1; n < 16; n++) {
126       ZipMicrokernelTester()
127         .n(n)
128         .g(4)
129         .Test(xnn_x8_zip_x4_ukernel__neon);
130     }
131   }
132 
TEST(X8_ZIP_XM__NEON,n_eq_8_m_eq_4)133   TEST(X8_ZIP_XM__NEON, n_eq_8_m_eq_4) {
134     TEST_REQUIRES_ARM_NEON;
135     ZipMicrokernelTester()
136       .n(8)
137       .g(4)
138       .Test(xnn_x8_zip_xm_ukernel__neon);
139   }
140 
TEST(X8_ZIP_XM__NEON,n_eq_8_m_div_4)141   TEST(X8_ZIP_XM__NEON, n_eq_8_m_div_4) {
142     TEST_REQUIRES_ARM_NEON;
143     for (size_t g = 4; g < 32; g += 4) {
144       ZipMicrokernelTester()
145         .n(8)
146         .g(g)
147         .Test(xnn_x8_zip_xm_ukernel__neon);
148     }
149   }
150 
TEST(X8_ZIP_XM__NEON,n_eq_8_m_gt_4)151   TEST(X8_ZIP_XM__NEON, n_eq_8_m_gt_4) {
152     TEST_REQUIRES_ARM_NEON;
153     for (size_t g = 5; g < 8; g++) {
154       ZipMicrokernelTester()
155         .n(8)
156         .g(g)
157         .Test(xnn_x8_zip_xm_ukernel__neon);
158     }
159   }
160 
TEST(X8_ZIP_XM__NEON,n_div_8_m_eq_4)161   TEST(X8_ZIP_XM__NEON, n_div_8_m_eq_4) {
162     TEST_REQUIRES_ARM_NEON;
163     for (size_t n = 8; n < 128; n += 8) {
164       ZipMicrokernelTester()
165         .n(n)
166         .g(4)
167         .Test(xnn_x8_zip_xm_ukernel__neon);
168     }
169   }
170 
TEST(X8_ZIP_XM__NEON,n_div_8_m_div_4)171   TEST(X8_ZIP_XM__NEON, n_div_8_m_div_4) {
172     TEST_REQUIRES_ARM_NEON;
173     for (size_t n = 8; n < 128; n += 8) {
174       for (size_t g = 4; g < 32; g += 4) {
175         ZipMicrokernelTester()
176           .n(n)
177           .g(g)
178           .Test(xnn_x8_zip_xm_ukernel__neon);
179       }
180     }
181   }
182 
TEST(X8_ZIP_XM__NEON,n_div_8_m_gt_4)183   TEST(X8_ZIP_XM__NEON, n_div_8_m_gt_4) {
184     TEST_REQUIRES_ARM_NEON;
185     for (size_t n = 8; n < 128; n += 8) {
186       for (size_t g = 5; g < 8; g++) {
187         ZipMicrokernelTester()
188           .n(n)
189           .g(g)
190           .Test(xnn_x8_zip_xm_ukernel__neon);
191       }
192     }
193   }
194 
TEST(X8_ZIP_XM__NEON,n_gt_8_m_eq_4)195   TEST(X8_ZIP_XM__NEON, n_gt_8_m_eq_4) {
196     TEST_REQUIRES_ARM_NEON;
197     for (size_t n = 9; n < 16; n++) {
198       ZipMicrokernelTester()
199         .n(n)
200         .g(4)
201         .Test(xnn_x8_zip_xm_ukernel__neon);
202     }
203   }
204 
TEST(X8_ZIP_XM__NEON,n_gt_8_m_div_4)205   TEST(X8_ZIP_XM__NEON, n_gt_8_m_div_4) {
206     TEST_REQUIRES_ARM_NEON;
207     for (size_t n = 9; n < 16; n++) {
208       for (size_t g = 4; g < 32; g += 4) {
209         ZipMicrokernelTester()
210           .n(n)
211           .g(g)
212           .Test(xnn_x8_zip_xm_ukernel__neon);
213       }
214     }
215   }
216 
TEST(X8_ZIP_XM__NEON,n_gt_8_m_gt_4)217   TEST(X8_ZIP_XM__NEON, n_gt_8_m_gt_4) {
218     TEST_REQUIRES_ARM_NEON;
219     for (size_t n = 9; n < 16; n++) {
220       for (size_t g = 5; g < 8; g++) {
221         ZipMicrokernelTester()
222           .n(n)
223           .g(g)
224           .Test(xnn_x8_zip_xm_ukernel__neon);
225       }
226     }
227   }
228 
TEST(X8_ZIP_XM__NEON,n_lt_8)229   TEST(X8_ZIP_XM__NEON, n_lt_8) {
230     TEST_REQUIRES_ARM_NEON;
231     for (size_t n = 1; n < 8; n++) {
232       for (size_t g = 4; g < 12; g++) {
233         ZipMicrokernelTester()
234           .n(n)
235           .g(g)
236           .Test(xnn_x8_zip_xm_ukernel__neon);
237       }
238     }
239   }
240 #endif  // XNN_ARCH_ARM || XNN_ARCH_ARM64
241 
242 #if XNN_ARCH_X86 || XNN_ARCH_X86_64
TEST(X8_ZIP_X2__SSE2,n_eq_16)243   TEST(X8_ZIP_X2__SSE2, n_eq_16) {
244     TEST_REQUIRES_X86_SSE2;
245     ZipMicrokernelTester()
246       .n(16)
247       .g(2)
248       .Test(xnn_x8_zip_x2_ukernel__sse2);
249   }
250 
TEST(X8_ZIP_X2__SSE2,n_div_16)251   TEST(X8_ZIP_X2__SSE2, n_div_16) {
252     TEST_REQUIRES_X86_SSE2;
253     for (size_t n = 16; n < 256; n += 16) {
254       ZipMicrokernelTester()
255         .n(n)
256         .g(2)
257         .Test(xnn_x8_zip_x2_ukernel__sse2);
258     }
259   }
260 
TEST(X8_ZIP_X2__SSE2,n_gt_16)261   TEST(X8_ZIP_X2__SSE2, n_gt_16) {
262     TEST_REQUIRES_X86_SSE2;
263     for (size_t n = 17; n < 32; n++) {
264       ZipMicrokernelTester()
265         .n(n)
266         .g(2)
267         .Test(xnn_x8_zip_x2_ukernel__sse2);
268     }
269   }
270 
TEST(X8_ZIP_X2__SSE2,n_lt_16)271   TEST(X8_ZIP_X2__SSE2, n_lt_16) {
272     TEST_REQUIRES_X86_SSE2;
273     for (size_t n = 1; n < 16; n++) {
274       ZipMicrokernelTester()
275         .n(n)
276         .g(2)
277         .Test(xnn_x8_zip_x2_ukernel__sse2);
278     }
279   }
280 
TEST(X8_ZIP_X3__SSE2,n_eq_16)281   TEST(X8_ZIP_X3__SSE2, n_eq_16) {
282     TEST_REQUIRES_X86_SSE2;
283     ZipMicrokernelTester()
284       .n(16)
285       .g(3)
286       .Test(xnn_x8_zip_x3_ukernel__sse2);
287   }
288 
TEST(X8_ZIP_X3__SSE2,n_div_16)289   TEST(X8_ZIP_X3__SSE2, n_div_16) {
290     TEST_REQUIRES_X86_SSE2;
291     for (size_t n = 16; n < 256; n += 16) {
292       ZipMicrokernelTester()
293         .n(n)
294         .g(3)
295         .Test(xnn_x8_zip_x3_ukernel__sse2);
296     }
297   }
298 
TEST(X8_ZIP_X3__SSE2,n_gt_16)299   TEST(X8_ZIP_X3__SSE2, n_gt_16) {
300     TEST_REQUIRES_X86_SSE2;
301     for (size_t n = 17; n < 32; n++) {
302       ZipMicrokernelTester()
303         .n(n)
304         .g(3)
305         .Test(xnn_x8_zip_x3_ukernel__sse2);
306     }
307   }
308 
TEST(X8_ZIP_X3__SSE2,n_lt_16)309   TEST(X8_ZIP_X3__SSE2, n_lt_16) {
310     TEST_REQUIRES_X86_SSE2;
311     for (size_t n = 1; n < 16; n++) {
312       ZipMicrokernelTester()
313         .n(n)
314         .g(3)
315         .Test(xnn_x8_zip_x3_ukernel__sse2);
316     }
317   }
318 
TEST(X8_ZIP_X4__SSE2,n_eq_16)319   TEST(X8_ZIP_X4__SSE2, n_eq_16) {
320     TEST_REQUIRES_X86_SSE2;
321     ZipMicrokernelTester()
322       .n(16)
323       .g(4)
324       .Test(xnn_x8_zip_x4_ukernel__sse2);
325   }
326 
TEST(X8_ZIP_X4__SSE2,n_div_16)327   TEST(X8_ZIP_X4__SSE2, n_div_16) {
328     TEST_REQUIRES_X86_SSE2;
329     for (size_t n = 16; n < 256; n += 16) {
330       ZipMicrokernelTester()
331         .n(n)
332         .g(4)
333         .Test(xnn_x8_zip_x4_ukernel__sse2);
334     }
335   }
336 
TEST(X8_ZIP_X4__SSE2,n_gt_16)337   TEST(X8_ZIP_X4__SSE2, n_gt_16) {
338     TEST_REQUIRES_X86_SSE2;
339     for (size_t n = 17; n < 32; n++) {
340       ZipMicrokernelTester()
341         .n(n)
342         .g(4)
343         .Test(xnn_x8_zip_x4_ukernel__sse2);
344     }
345   }
346 
TEST(X8_ZIP_X4__SSE2,n_lt_16)347   TEST(X8_ZIP_X4__SSE2, n_lt_16) {
348     TEST_REQUIRES_X86_SSE2;
349     for (size_t n = 1; n < 16; n++) {
350       ZipMicrokernelTester()
351         .n(n)
352         .g(4)
353         .Test(xnn_x8_zip_x4_ukernel__sse2);
354     }
355   }
356 
TEST(X8_ZIP_XM__SSE2,n_eq_8_m_eq_4)357   TEST(X8_ZIP_XM__SSE2, n_eq_8_m_eq_4) {
358     TEST_REQUIRES_X86_SSE2;
359     ZipMicrokernelTester()
360       .n(8)
361       .g(4)
362       .Test(xnn_x8_zip_xm_ukernel__sse2);
363   }
364 
TEST(X8_ZIP_XM__SSE2,n_eq_8_m_div_4)365   TEST(X8_ZIP_XM__SSE2, n_eq_8_m_div_4) {
366     TEST_REQUIRES_X86_SSE2;
367     for (size_t g = 4; g < 32; g += 4) {
368       ZipMicrokernelTester()
369         .n(8)
370         .g(g)
371         .Test(xnn_x8_zip_xm_ukernel__sse2);
372     }
373   }
374 
TEST(X8_ZIP_XM__SSE2,n_eq_8_m_gt_4)375   TEST(X8_ZIP_XM__SSE2, n_eq_8_m_gt_4) {
376     TEST_REQUIRES_X86_SSE2;
377     for (size_t g = 5; g < 8; g++) {
378       ZipMicrokernelTester()
379         .n(8)
380         .g(g)
381         .Test(xnn_x8_zip_xm_ukernel__sse2);
382     }
383   }
384 
TEST(X8_ZIP_XM__SSE2,n_eq_16_m_eq_4)385   TEST(X8_ZIP_XM__SSE2, n_eq_16_m_eq_4) {
386     TEST_REQUIRES_X86_SSE2;
387     ZipMicrokernelTester()
388       .n(16)
389       .g(4)
390       .Test(xnn_x8_zip_xm_ukernel__sse2);
391   }
392 
TEST(X8_ZIP_XM__SSE2,n_eq_16_m_div_4)393   TEST(X8_ZIP_XM__SSE2, n_eq_16_m_div_4) {
394     TEST_REQUIRES_X86_SSE2;
395     for (size_t g = 4; g < 32; g += 4) {
396       ZipMicrokernelTester()
397         .n(16)
398         .g(g)
399         .Test(xnn_x8_zip_xm_ukernel__sse2);
400     }
401   }
402 
TEST(X8_ZIP_XM__SSE2,n_eq_16_m_gt_4)403   TEST(X8_ZIP_XM__SSE2, n_eq_16_m_gt_4) {
404     TEST_REQUIRES_X86_SSE2;
405     for (size_t g = 5; g < 8; g++) {
406       ZipMicrokernelTester()
407         .n(16)
408         .g(g)
409         .Test(xnn_x8_zip_xm_ukernel__sse2);
410     }
411   }
412 
TEST(X8_ZIP_XM__SSE2,n_div_16_m_eq_4)413   TEST(X8_ZIP_XM__SSE2, n_div_16_m_eq_4) {
414     TEST_REQUIRES_X86_SSE2;
415     for (size_t n = 16; n < 256; n += 16) {
416       ZipMicrokernelTester()
417         .n(n)
418         .g(4)
419         .Test(xnn_x8_zip_xm_ukernel__sse2);
420     }
421   }
422 
TEST(X8_ZIP_XM__SSE2,n_div_16_m_div_4)423   TEST(X8_ZIP_XM__SSE2, n_div_16_m_div_4) {
424     TEST_REQUIRES_X86_SSE2;
425     for (size_t n = 16; n < 256; n += 16) {
426       for (size_t g = 4; g < 32; g += 4) {
427         ZipMicrokernelTester()
428           .n(n)
429           .g(g)
430           .Test(xnn_x8_zip_xm_ukernel__sse2);
431       }
432     }
433   }
434 
TEST(X8_ZIP_XM__SSE2,n_div_16_m_gt_4)435   TEST(X8_ZIP_XM__SSE2, n_div_16_m_gt_4) {
436     TEST_REQUIRES_X86_SSE2;
437     for (size_t n = 16; n < 256; n += 16) {
438       for (size_t g = 5; g < 8; g++) {
439         ZipMicrokernelTester()
440           .n(n)
441           .g(g)
442           .Test(xnn_x8_zip_xm_ukernel__sse2);
443       }
444     }
445   }
446 
TEST(X8_ZIP_XM__SSE2,n_gt_16_m_eq_4)447   TEST(X8_ZIP_XM__SSE2, n_gt_16_m_eq_4) {
448     TEST_REQUIRES_X86_SSE2;
449     for (size_t n = 17; n < 32; n++) {
450       ZipMicrokernelTester()
451         .n(n)
452         .g(4)
453         .Test(xnn_x8_zip_xm_ukernel__sse2);
454     }
455   }
456 
TEST(X8_ZIP_XM__SSE2,n_gt_16_m_div_4)457   TEST(X8_ZIP_XM__SSE2, n_gt_16_m_div_4) {
458     TEST_REQUIRES_X86_SSE2;
459     for (size_t n = 17; n < 32; n++) {
460       for (size_t g = 4; g < 32; g += 4) {
461         ZipMicrokernelTester()
462           .n(n)
463           .g(g)
464           .Test(xnn_x8_zip_xm_ukernel__sse2);
465       }
466     }
467   }
468 
TEST(X8_ZIP_XM__SSE2,n_gt_16_m_gt_4)469   TEST(X8_ZIP_XM__SSE2, n_gt_16_m_gt_4) {
470     TEST_REQUIRES_X86_SSE2;
471     for (size_t n = 17; n < 32; n++) {
472       for (size_t g = 5; g < 8; g++) {
473         ZipMicrokernelTester()
474           .n(n)
475           .g(g)
476           .Test(xnn_x8_zip_xm_ukernel__sse2);
477       }
478     }
479   }
480 
TEST(X8_ZIP_XM__SSE2,n_lt_16)481   TEST(X8_ZIP_XM__SSE2, n_lt_16) {
482     TEST_REQUIRES_X86_SSE2;
483     for (size_t n = 1; n < 16; n++) {
484       for (size_t g = 4; g < 12; g++) {
485         ZipMicrokernelTester()
486           .n(n)
487           .g(g)
488           .Test(xnn_x8_zip_xm_ukernel__sse2);
489       }
490     }
491   }
492 #endif  // XNN_ARCH_X86 || XNN_ARCH_X86_64
493 
TEST(X8_ZIP_X2__SCALAR,n_eq_1)494 TEST(X8_ZIP_X2__SCALAR, n_eq_1) {
495   ZipMicrokernelTester()
496     .n(1)
497     .g(2)
498     .Test(xnn_x8_zip_x2_ukernel__scalar);
499 }
500 
TEST(X8_ZIP_X2__SCALAR,n_gt_1)501 TEST(X8_ZIP_X2__SCALAR, n_gt_1) {
502   for (size_t n = 2; n < 8; n++) {
503     ZipMicrokernelTester()
504       .n(n)
505       .g(2)
506       .Test(xnn_x8_zip_x2_ukernel__scalar);
507   }
508 }
509 
TEST(X8_ZIP_X3__SCALAR,n_eq_1)510 TEST(X8_ZIP_X3__SCALAR, n_eq_1) {
511   ZipMicrokernelTester()
512     .n(9)
513     .g(3)
514     .Test(xnn_x8_zip_x3_ukernel__scalar);
515 }
516 
TEST(X8_ZIP_X3__SCALAR,n_gt_1)517 TEST(X8_ZIP_X3__SCALAR, n_gt_1) {
518   for (size_t n = 2; n < 8; n++) {
519     ZipMicrokernelTester()
520       .n(n)
521       .g(3)
522       .Test(xnn_x8_zip_x3_ukernel__scalar);
523   }
524 }
525 
TEST(X8_ZIP_X4__SCALAR,n_eq_1)526 TEST(X8_ZIP_X4__SCALAR, n_eq_1) {
527   ZipMicrokernelTester()
528     .n(1)
529     .g(4)
530     .Test(xnn_x8_zip_x4_ukernel__scalar);
531 }
532 
TEST(X8_ZIP_X4__SCALAR,n_gt_1)533 TEST(X8_ZIP_X4__SCALAR, n_gt_1) {
534   for (size_t n = 2; n < 8; n++) {
535     ZipMicrokernelTester()
536       .n(n)
537       .g(4)
538       .Test(xnn_x8_zip_x4_ukernel__scalar);
539   }
540 }
541 
TEST(X8_ZIP_XM__SCALAR,n_eq_1_m_eq_4)542 TEST(X8_ZIP_XM__SCALAR, n_eq_1_m_eq_4) {
543   ZipMicrokernelTester()
544     .n(1)
545     .g(4)
546     .Test(xnn_x8_zip_xm_ukernel__scalar);
547 }
548 
TEST(X8_ZIP_XM__SCALAR,n_eq_1_m_div_4)549 TEST(X8_ZIP_XM__SCALAR, n_eq_1_m_div_4) {
550   for (size_t g = 4; g < 32; g += 4) {
551     ZipMicrokernelTester()
552       .n(1)
553       .g(g)
554       .Test(xnn_x8_zip_xm_ukernel__scalar);
555   }
556 }
557 
TEST(X8_ZIP_XM__SCALAR,n_eq_1_m_gt_4)558 TEST(X8_ZIP_XM__SCALAR, n_eq_1_m_gt_4) {
559   for (size_t g = 5; g < 8; g++) {
560     ZipMicrokernelTester()
561       .n(1)
562       .g(g)
563       .Test(xnn_x8_zip_xm_ukernel__scalar);
564   }
565 }
566 
TEST(X8_ZIP_XM__SCALAR,n_gt_1_m_eq_4)567 TEST(X8_ZIP_XM__SCALAR, n_gt_1_m_eq_4) {
568   for (size_t n = 2; n < 8; n++) {
569     ZipMicrokernelTester()
570       .n(n)
571       .g(4)
572       .Test(xnn_x8_zip_xm_ukernel__scalar);
573   }
574 }
575 
TEST(X8_ZIP_XM__SCALAR,n_gt_1_m_div_4)576 TEST(X8_ZIP_XM__SCALAR, n_gt_1_m_div_4) {
577   for (size_t n = 2; n < 8; n++) {
578     for (size_t g = 4; g < 32; g += 4) {
579       ZipMicrokernelTester()
580         .n(n)
581         .g(g)
582         .Test(xnn_x8_zip_xm_ukernel__scalar);
583     }
584   }
585 }
586 
TEST(X8_ZIP_XM__SCALAR,n_gt_1_m_gt_4)587 TEST(X8_ZIP_XM__SCALAR, n_gt_1_m_gt_4) {
588   for (size_t n = 2; n < 8; n++) {
589     for (size_t g = 5; g < 8; g++) {
590       ZipMicrokernelTester()
591         .n(n)
592         .g(g)
593         .Test(xnn_x8_zip_xm_ukernel__scalar);
594     }
595   }
596 }
597