xref: /aosp_15_r20/external/armnn/src/backends/cl/test/ClEndToEndTests.cpp (revision 89c4ff92f2867872bb9e2354d150bf0c8c502810)
1 //
2 // Copyright © 2017-2023 Arm Ltd. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5 
6 #include <backendsCommon/test/EndToEndTestImpl.hpp>
7 
8 #include <backendsCommon/test/ActivationEndToEndTestImpl.hpp>
9 #include <backendsCommon/test/AdditionEndToEndTestImpl.hpp>
10 #include <backendsCommon/test/ArgMinMaxEndToEndTestImpl.hpp>
11 #include <backendsCommon/test/ComparisonEndToEndTestImpl.hpp>
12 #include <backendsCommon/test/ConcatEndToEndTestImpl.hpp>
13 #include <backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp>
14 #include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp>
15 #include <backendsCommon/test/ElementwiseUnaryEndToEndTestImpl.hpp>
16 #include <backendsCommon/test/FillEndToEndTestImpl.hpp>
17 #include <backendsCommon/test/InstanceNormalizationEndToEndTestImpl.hpp>
18 #include <backendsCommon/test/PreluEndToEndTestImpl.hpp>
19 #include <backendsCommon/test/QLstmEndToEndTestImpl.hpp>
20 #include <backendsCommon/test/QuantizedLstmEndToEndTestImpl.hpp>
21 #include <backendsCommon/test/ReduceEndToEndTestImpl.hpp>
22 #include <backendsCommon/test/ReshapeEndToEndTestImpl.hpp>
23 #include <backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp>
24 #include <backendsCommon/test/SplitterEndToEndTestImpl.hpp>
25 #include <backendsCommon/test/TransposeConvolution2dEndToEndTestImpl.hpp>
26 #include <backendsCommon/test/TransposeEndToEndTestImpl.hpp>
27 
28 #include <doctest/doctest.h>
29 
30 TEST_SUITE("ClEndToEnd")
31 {
32 std::vector<armnn::BackendId> clDefaultBackends = {armnn::Compute::GpuAcc};
33 
34 // ElementwiseUnary
35 // Abs
36 TEST_CASE("ClAbsEndToEndTestFloat32")
37 {
38     ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
39                                                              UnaryOperation::Abs);
40 }
41 // Rsqrt
42 TEST_CASE("ClRsqrtEndToEndTestFloat32")
43 {
44     ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
45                                                              UnaryOperation::Rsqrt);
46 }
47 
48 // Addition
49 TEST_CASE("ClAdditionEndToEndFloat32Test")
50 {
51     AdditionEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
52 }
53 
54 TEST_CASE("ClAdditionEndToEndUint8Test")
55 {
56     AdditionEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
57 }
58 
59 // Constant
60 TEST_CASE("ConstantUsage_Cl_Float32")
61 {
62     ConstantUsageFloat32Test(clDefaultBackends);
63 }
64 
65 TEST_CASE("ClConcatEndToEndDim0Test")
66 {
67     ConcatDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
68 }
69 
70 TEST_CASE("ClConcatEndToEndDim0Uint8Test")
71 {
72     ConcatDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
73 }
74 
75 TEST_CASE("ClConcatEndToEndDim1Test")
76 {
77     ConcatDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
78 }
79 
80 TEST_CASE("ClConcatEndToEndDim1Uint8Test")
81 {
82     ConcatDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
83 }
84 
85 TEST_CASE("ClConcatEndToEndDim3Test")
86 {
87     ConcatDim3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
88 }
89 
90 TEST_CASE("ClConcatEndToEndDim3Uint8Test")
91 {
92     ConcatDim3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
93 }
94 
95 // DepthToSpace
96 TEST_CASE("DephtToSpaceEndToEndNchwFloat32")
97 {
98     DepthToSpaceEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NCHW);
99 }
100 
101 TEST_CASE("DephtToSpaceEndToEndNchwFloat16")
102 {
103     DepthToSpaceEndToEnd<armnn::DataType::Float16>(clDefaultBackends, armnn::DataLayout::NCHW);
104 }
105 
106 TEST_CASE("DephtToSpaceEndToEndNchwUint8")
107 {
108     DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, armnn::DataLayout::NCHW);
109 }
110 
111 TEST_CASE("DephtToSpaceEndToEndNchwInt16")
112 {
113     DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(clDefaultBackends, armnn::DataLayout::NCHW);
114 }
115 
116 TEST_CASE("DephtToSpaceEndToEndNhwcFloat32")
117 {
118     DepthToSpaceEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NHWC);
119 }
120 
121 TEST_CASE("DephtToSpaceEndToEndNhwcFloat16")
122 {
123     DepthToSpaceEndToEnd<armnn::DataType::Float16>(clDefaultBackends, armnn::DataLayout::NHWC);
124 }
125 
126 TEST_CASE("DephtToSpaceEndToEndNhwcUint8")
127 {
128     DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, armnn::DataLayout::NHWC);
129 }
130 
131 TEST_CASE("DephtToSpaceEndToEndNhwcInt16")
132 {
133     DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(clDefaultBackends, armnn::DataLayout::NHWC);
134 }
135 
136 // Dequantize
137 TEST_CASE("DequantizeEndToEndSimpleTest")
138 {
139     DequantizeEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends);
140 }
141 
142 TEST_CASE("DequantizeEndToEndOffsetTest")
143 {
144     DequantizeEndToEndOffset<armnn::DataType::QAsymmU8>(clDefaultBackends);
145 }
146 
147 TEST_CASE("ClStridedSliceInvalidSliceEndToEndTest")
148 {
149     StridedSliceInvalidSliceEndToEndTest(clDefaultBackends);
150 }
151 
152 TEST_CASE("ClEluEndToEndTestFloat32")
153 {
154     EluEndToEndTest<armnn::DataType::Float32>(clDefaultBackends);
155 }
156 
157 TEST_CASE("ClEluEndToEndTestFloat16")
158 {
159     EluEndToEndTest<armnn::DataType::Float16>(clDefaultBackends);
160 }
161 
162 TEST_CASE("ClGreaterSimpleEndToEndTest")
163 {
164     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
165                                                 0, 0, 0, 0,  0, 0, 0, 0 });
166 
167     ComparisonSimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
168                                                        ComparisonOperation::Greater,
169                                                        expectedOutput);
170 }
171 
172 TEST_CASE("ClGreaterSimpleEndToEndUint8Test")
173 {
174     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
175                                                 0, 0, 0, 0,  0, 0, 0, 0 });
176 
177     ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends,
178                                                                ComparisonOperation::Greater,
179                                                                expectedOutput);
180 }
181 
182 TEST_CASE("ClGreaterBroadcastEndToEndTest")
183 {
184     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
185                                                 1, 1, 1, 1, 1, 1 });
186 
187     ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(clDefaultBackends,
188                                                           ComparisonOperation::Greater,
189                                                           expectedOutput);
190 }
191 
192 TEST_CASE("ClGreaterBroadcastEndToEndUint8Test")
193 {
194     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
195                                                 1, 1, 1, 1, 1, 1 });
196 
197     ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends,
198                                                                   ComparisonOperation::Greater,
199                                                                   expectedOutput);
200 }
201 
202 // HardSwish
203 TEST_CASE("ClHardSwishEndToEndTestFloat32")
204 {
205     HardSwishEndToEndTest<armnn::DataType::Float32>(clDefaultBackends);
206 }
207 
208 TEST_CASE("ClHardSwishEndToEndTestFloat16")
209 {
210     HardSwishEndToEndTest<armnn::DataType::Float16>(clDefaultBackends);
211 }
212 
213 TEST_CASE("ClHardSwishEndToEndTestQAsymmS8")
214 {
215     HardSwishEndToEndTest<armnn::DataType::QAsymmS8>(clDefaultBackends);
216 }
217 
218 TEST_CASE("ClHardSwishEndToEndTestQAsymmU8")
219 {
220     HardSwishEndToEndTest<armnn::DataType::QAsymmU8>(clDefaultBackends);
221 }
222 
223 TEST_CASE("ClHardSwishEndToEndTestQSymmS16")
224 {
225     HardSwishEndToEndTest<armnn::DataType::QSymmS16>(clDefaultBackends);
226 }
227 
228 // InstanceNormalization
229 TEST_CASE("ClInstanceNormalizationNhwcEndToEndTest1")
230 {
231     InstanceNormalizationNhwcEndToEndTest1(clDefaultBackends);
232 }
233 
234 TEST_CASE("ClInstanceNormalizationNchwEndToEndTest1")
235 {
236     InstanceNormalizationNchwEndToEndTest1(clDefaultBackends);
237 }
238 
239 TEST_CASE("ClInstanceNormalizationNhwcEndToEndTest2")
240 {
241     InstanceNormalizationNhwcEndToEndTest2(clDefaultBackends);
242 }
243 
244 TEST_CASE("ClInstanceNormalizationNchwEndToEndTest2")
245 {
246     InstanceNormalizationNchwEndToEndTest2(clDefaultBackends);
247 }
248 
249 // Fill
250 TEST_CASE("ClFillEndToEndTest")
251 {
252     FillEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
253 }
254 
255 TEST_CASE("RefFillEndToEndTestFloat16")
256 {
257     FillEndToEnd<armnn::DataType::Float16>(clDefaultBackends);
258 }
259 
260 TEST_CASE("ClFillEndToEndTestInt32")
261 {
262     FillEndToEnd<armnn::DataType::Signed32>(clDefaultBackends);
263 }
264 
265 // Prelu
266 TEST_CASE("ClPreluEndToEndFloat32Test")
267 {
268     PreluEndToEndNegativeTest<armnn::DataType::Float32>(clDefaultBackends);
269 }
270 
271 TEST_CASE("ClPreluEndToEndTestUint8")
272 {
273     PreluEndToEndPositiveTest<armnn::DataType::QAsymmU8>(clDefaultBackends);
274 }
275 
276 // Reduce
277 TEST_CASE("ClReduceEndToEndTest")
278 {
279     ReduceEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
280 }
281 
282 TEST_CASE("ClReduceEndToEndTestFloat16")
283 {
284     ReduceEndToEnd<armnn::DataType::Float16>(clDefaultBackends);
285 }
286 
287 // Reshape
288 TEST_CASE("ClReshapeEndToEndTest")
289 {
290     ReshapeEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
291 }
292 
293 TEST_CASE("ClReshapeEndToEndTestFloat16")
294 {
295     ReshapeEndToEndFloat16<armnn::DataType::Float16>(clDefaultBackends);
296 }
297 
298 // Space to depth
299 TEST_CASE("ClSpaceToDepthNhwcEndToEndTest1")
300 {
301     SpaceToDepthNhwcEndToEndTest1(clDefaultBackends);
302 }
303 
304 TEST_CASE("ClSpaceToDepthNchwEndToEndTest1")
305 {
306     SpaceToDepthNchwEndToEndTest1(clDefaultBackends);
307 }
308 
309 TEST_CASE("ClSpaceToDepthNhwcEndToEndTest2")
310 {
311     SpaceToDepthNhwcEndToEndTest2(clDefaultBackends);
312 }
313 
314 TEST_CASE("ClSpaceToDepthNchwEndToEndTest2")
315 {
316     SpaceToDepthNchwEndToEndTest2(clDefaultBackends);
317 }
318 
319 // Split
320 TEST_CASE("ClSplitter1dEndToEndTest")
321 {
322     Splitter1dEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
323 }
324 
325 TEST_CASE("ClSplitter1dEndToEndUint8Test")
326 {
327     Splitter1dEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
328 }
329 
330 TEST_CASE("ClSplitter2dDim0EndToEndTest")
331 {
332     Splitter2dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
333 }
334 
335 TEST_CASE("ClSplitter2dDim1EndToEndTest")
336 {
337     Splitter2dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
338 }
339 
340 TEST_CASE("ClSplitter2dDim0EndToEndUint8Test")
341 {
342     Splitter2dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
343 }
344 
345 TEST_CASE("ClSplitter2dDim1EndToEndUint8Test")
346 {
347     Splitter2dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
348 }
349 
350 TEST_CASE("ClSplitter3dDim0EndToEndTest")
351 {
352     Splitter3dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
353 }
354 
355 TEST_CASE("ClSplitter3dDim1EndToEndTest")
356 {
357     Splitter3dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
358 }
359 
360 TEST_CASE("ClSplitter3dDim2EndToEndTest")
361 {
362     Splitter3dDim2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
363 }
364 
365 TEST_CASE("ClSplitter3dDim0EndToEndUint8Test")
366 {
367     Splitter3dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
368 }
369 
370 TEST_CASE("ClSplitter3dDim1EndToEndUint8Test")
371 {
372     Splitter3dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
373 }
374 
375 TEST_CASE("ClSplitter3dDim2EndToEndUint8Test")
376 {
377     Splitter3dDim2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
378 }
379 
380 TEST_CASE("ClSplitter4dDim0EndToEndTest")
381 {
382     Splitter4dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
383 }
384 
385 TEST_CASE("ClSplitter4dDim1EndToEndTest")
386 {
387     Splitter4dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
388 }
389 
390 TEST_CASE("ClSplitter4dDim2EndToEndTest")
391 {
392     Splitter4dDim2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
393 }
394 
395 TEST_CASE("ClSplitter4dDim3EndToEndTest")
396 {
397     Splitter4dDim3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
398 }
399 
400 TEST_CASE("ClSplitter4dDim0EndToEndUint8Test")
401 {
402     Splitter4dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
403 }
404 
405 TEST_CASE("ClSplitter4dDim1EndToEndUint8Test")
406 {
407     Splitter4dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
408 }
409 
410 TEST_CASE("ClSplitter4dDim2EndToEndUint8Test")
411 {
412     Splitter4dDim2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
413 }
414 
415 TEST_CASE("ClSplitter4dDim3EndToEndUint8Test")
416 {
417     Splitter4dDim3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
418 }
419 
420 // TransposeConvolution2d
421 TEST_CASE("ClTransposeConvolution2dEndToEndFloatNchwTest")
422 {
423     TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
424         clDefaultBackends, armnn::DataLayout::NCHW);
425 }
426 
427 TEST_CASE("ClTransposeConvolution2dEndToEndUint8NchwTest")
428 {
429     TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
430         clDefaultBackends, armnn::DataLayout::NCHW);
431 }
432 
433 TEST_CASE("ClTransposeConvolution2dEndToEndFloatNhwcTest")
434 {
435     TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
436         clDefaultBackends, armnn::DataLayout::NHWC);
437 }
438 
439 TEST_CASE("ClTransposeConvolution2dEndToEndUint8NhwcTest")
440 {
441     TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
442         clDefaultBackends, armnn::DataLayout::NHWC);
443 }
444 
445 // Transpose
446 TEST_CASE("ClTransposeEndToEndTest")
447 {
448 TransposeEndToEnd<armnn::DataType::Float32>(clDefaultBackends);
449 }
450 
451 TEST_CASE("ClQuantizedLstmEndToEndTest")
452 {
453     QuantizedLstmEndToEnd(clDefaultBackends);
454 }
455 
456 // ArgMinMax
457 TEST_CASE("ClArgMaxSimpleTest")
458 {
459     ArgMaxEndToEndSimple<armnn::DataType::Float32>(clDefaultBackends);
460 }
461 
462 TEST_CASE("ClArgMinSimpleTest")
463 {
464     ArgMinEndToEndSimple<armnn::DataType::Float32>(clDefaultBackends);
465 }
466 
467 TEST_CASE("ClArgMaxAxis0Test")
468 {
469     ArgMaxAxis0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
470 }
471 
472 TEST_CASE("ClArgMinAxis0Test")
473 {
474     ArgMinAxis0EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
475 }
476 
477 TEST_CASE("ClArgMaxAxis1Test")
478 {
479     ArgMaxAxis1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
480 }
481 
482 TEST_CASE("ClArgMinAxis1Test")
483 {
484     ArgMinAxis1EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
485 }
486 
487 TEST_CASE("ClArgMaxAxis2Test")
488 {
489     ArgMaxAxis2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
490 }
491 
492 TEST_CASE("ClArgMinAxis2Test")
493 {
494     ArgMinAxis2EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
495 }
496 
497 TEST_CASE("ClArgMaxAxis3Test")
498 {
499     ArgMaxAxis3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
500 }
501 
502 TEST_CASE("ClArgMinAxis3Test")
503 {
504     ArgMinAxis3EndToEnd<armnn::DataType::Float32>(clDefaultBackends);
505 }
506 
507 TEST_CASE("ClArgMaxSimpleTestQAsymmU8")
508 {
509     ArgMaxEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends);
510 }
511 
512 TEST_CASE("ClArgMinSimpleTestQAsymmU8")
513 {
514     ArgMinEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends);
515 }
516 
517 TEST_CASE("ClArgMaxAxis0TestQAsymmU8")
518 {
519     ArgMaxAxis0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
520 }
521 
522 TEST_CASE("ClArgMinAxis0TestQAsymmU8")
523 {
524     ArgMinAxis0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
525 }
526 
527 TEST_CASE("ClArgMaxAxis1TestQAsymmU8")
528 {
529     ArgMaxAxis1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
530 }
531 
532 TEST_CASE("ClArgMinAxis1TestQAsymmU8")
533 {
534     ArgMinAxis1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
535 }
536 
537 TEST_CASE("ClArgMaxAxis2TestQAsymmU8")
538 {
539     ArgMaxAxis2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
540 }
541 
542 TEST_CASE("ClArgMinAxis2TestQAsymmU8")
543 {
544     ArgMinAxis2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
545 }
546 
547 TEST_CASE("ClArgMaxAxis3TestQAsymmU8")
548 {
549     ArgMaxAxis3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
550 }
551 
552 TEST_CASE("ClArgMinAxis3TestQAsymmU8")
553 {
554     ArgMinAxis3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends);
555 }
556 
557 TEST_CASE("ClQLstmEndToEndTest")
558 {
559     QLstmEndToEnd(clDefaultBackends);
560 }
561 
562 TEST_CASE("ClForceImportWithMisalignedInputBuffersEndToEndTest"
563           // Currently, the CL workload for activation does not support tensor handle replacement so this test case
564           // will always fail.
skip(true)565           * doctest::skip(true))
566 {
567     ForceImportWithMisalignedInputBuffersEndToEndTest(clDefaultBackends);
568 }
569 
570 TEST_CASE("ClForceImportWithMisalignedOutputBuffersEndToEndTest"
571           // Currently, the CL workload for activation does not support tensor handle replacement so this test case
572           // will always fail.
skip(true)573           * doctest::skip(true))
574 {
575     ForceImportWithMisalignedOutputBuffersEndToEndTest(clDefaultBackends);
576 }
577 
578 TEST_CASE("ClForceImportWithMisalignedInputAndOutputBuffersEndToEndTest")
579 {
580     ForceImportWithMisalignedInputAndOutputBuffersEndToEndTest(clDefaultBackends);
581 }
582 
583 }
584