Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / ad1b3d7518429e2d16a2695d9b0bbf81b6565ac9 / . / delegate / test / ElementwiseBinaryTest.cpp
blob: effed03e5e9f98fb86c09e6d18a5e01ed345d782 [file] [log] [blame]
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]1//
Ryan OSheaa544f0f2023-01-25 18:10:20 +0000[diff] [blame]2// Copyright © 2020-2021, 2023 Arm Ltd and Contributors. All rights reserved.
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]3// SPDX-License-Identifier: MIT
4//
5
6#include "ElementwiseBinaryTestHelper.hpp"
7
8#include <armnn_delegate.hpp>
9
10#include <flatbuffers/flatbuffers.h>
11#include <tensorflow/lite/interpreter.h>
12#include <tensorflow/lite/kernels/register.h>
13#include <tensorflow/lite/model.h>
Teresa Charlinad1b3d72023-03-14 12:10:28 +0000[diff] [blame^]14#include <schema_generated.h>
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]15#include <tensorflow/lite/version.h>
16
17#include <doctest/doctest.h>
18
19namespace armnnDelegate
20{
21
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]22void AddFP32Test(std::vector<armnn::BackendId>& backends)
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]23{
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]24 std::vector<int32_t> input0Shape { 2, 2, 2, 3 };
25 std::vector<int32_t> input1Shape { 2, 2, 2, 3 };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]26 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 3 };
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]27
28 std::vector<float> input0Values =
29 {
30 0.0f, 2.0f, 1.0f,
31 0.2f, 1.0f, 2.0f,
32
33 1.0f, 2.0f, 1.0f,
34 0.2f, 1.0f, 2.0f,
35
36 0.0f, 2.0f, 1.0f,
37 4.2f, 1.0f, 2.0f,
38
39 0.0f, 0.0f, 1.0f,
40 0.2f, 1.0f, 2.0f,
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]41 };
42
43 std::vector<float> input1Values =
44 {
45 1.0f, 2.0f, 1.0f,
46 0.0f, 1.0f, 2.0f,
47
48 1.0f, 2.0f, -2.0f,
49 0.2f, 1.0f, 2.0f,
50
51 0.0f, 2.0f, 1.0f,
52 4.2f, 0.0f, -3.0f,
53
54 0.0f, 0.0f, 1.0f,
55 0.7f, 1.0f, 5.0f,
56 };
57
58 std::vector<float> expectedOutputValues =
59 {
60 1.0f, 4.0f, 2.0f,
61 0.2f, 2.0f, 4.0f,
62
63 2.0f, 4.0f, -1.0f,
64 0.4f, 2.0f, 4.0f,
65
66 0.0f, 4.0f, 2.0f,
67 8.4f, 1.0f, -1.0f,
68
69 0.0f, 0.0f, 2.0f,
70 0.9f, 2.0f, 7.0f,
71 };
72
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]73 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_ADD,
74 tflite::ActivationFunctionType_NONE,
75 ::tflite::TensorType_FLOAT32,
76 backends,
77 input0Shape,
78 input1Shape,
79 expectedOutputShape,
80 input0Values,
81 input1Values,
82 expectedOutputValues);
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]83}
84
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]85void AddBroadcastTest(std::vector<armnn::BackendId>& backends)
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]86{
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]87 std::vector<int32_t> input0Shape { 1, 3, 2, 1 };
88 std::vector<int32_t> input1Shape { 1, 1, 2, 3 };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]89 std::vector<int32_t> expectedOutputShape { 1, 3, 2, 3 };
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]90
91 std::vector<float> input0Values
92 {
93 0.0f,
94 1.0f,
95
96 2.0f,
97 3.0f,
98
99 4.0f,
100 5.0f,
101 };
102 std::vector<float> input1Values
103 {
104 0.5f, 1.5f, 2.5f,
105 3.5f, 4.5f, 5.5f,
106 };
107 // Set output data
108 std::vector<float> expectedOutputValues
109 {
110 0.5f, 1.5f, 2.5f,
111 4.5f, 5.5f, 6.5f,
112
113 2.5f, 3.5f, 4.5f,
114 6.5f, 7.5f, 8.5f,
115
116 4.5f, 5.5f, 6.5f,
117 8.5f, 9.5f, 10.5f,
118 };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]119
120 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_ADD,
121 tflite::ActivationFunctionType_NONE,
122 ::tflite::TensorType_FLOAT32,
123 backends,
124 input0Shape,
125 input1Shape,
126 expectedOutputShape,
127 input0Values,
128 input1Values,
129 expectedOutputValues);
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]130}
131
Sadik Armaganf7ac72c2021-05-05 15:03:50 +0100[diff] [blame]132void AddConstInputTest(std::vector<armnn::BackendId>& backends)
133{
134 std::vector<int32_t> input0Shape { 1, 3, 2, 1 };
135 std::vector<int32_t> input1Shape { 1 };
136 std::vector<int32_t> expectedOutputShape { 1, 3, 2, 1 };
137
138 std::vector<float> input0Values
139 {
140 0.0f,
141 1.0f,
142
143 2.0f,
144 3.0f,
145
146 4.0f,
147 5.0f,
148 };
149 std::vector<float> input1Values
150 {
151 0.5f
152 };
153 // Set output data
154 std::vector<float> expectedOutputValues
155 {
156 0.5f,
157 1.5f,
158
159 2.5f,
160 3.5f,
161
162 4.5f,
163 5.5f,
164 };
165
166 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_ADD,
167 tflite::ActivationFunctionType_NONE,
168 ::tflite::TensorType_FLOAT32,
169 backends,
170 input0Shape,
171 input1Shape,
172 expectedOutputShape,
173 input0Values,
174 input1Values,
175 expectedOutputValues,
176 1.0f,
177 0,
178 true);
179}
180
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]181void AddActivationTest(std::vector<armnn::BackendId>& backends)
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]182{
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]183 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
184 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]185 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]186
187 std::vector<float> input0Values { 4.0f, 0.8f, 0.7f, -0.8f };
188 std::vector<float> input1Values { 0.7f, -1.2f, 0.8f, 0.5f };
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]189 std::vector<float> expectedOutputValues { 4.7f, 0.0f, 1.5f, 0.0f };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]190
191 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_ADD,
192 tflite::ActivationFunctionType_RELU,
193 ::tflite::TensorType_FLOAT32,
194 backends,
195 input0Shape,
196 input1Shape,
197 expectedOutputShape,
198 input0Values,
199 input1Values,
200 expectedOutputValues);
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]201}
202
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]203void AddUint8Test(std::vector<armnn::BackendId>& backends)
204{
205 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
206 std::vector<int32_t> input1Shape { 1, 2, 2, 3 };
207 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
208
209 std::vector<uint8_t> input0Values =
210 {
211 63, 35, 77, 70, 56, 112,
212 203, 28, 252, 168, 245, 91
213 };
214
215 std::vector<uint8_t> input1Values =
216 {
217 21, 7, 175, 231, 175, 210,
218 126, 161, 63, 21, 105, 126
219 };
220
221 std::vector<uint8_t> expectedOutputValues =
222 {
223 81, 39, 249, 255, 228, 255,
224 255, 186, 255, 186, 255, 214,
225 };
226
227 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_ADD,
228 tflite::ActivationFunctionType_NONE,
229 ::tflite::TensorType_UINT8,
230 backends,
231 input0Shape,
232 input1Shape,
233 expectedOutputShape,
234 input0Values,
235 input1Values,
236 expectedOutputValues, 7.0f, 3);
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]237}
238
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]239void DivFP32Test(std::vector<armnn::BackendId>& backends)
240{
241 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
242 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
243 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
244
245 std::vector<float> input0Values =
246 {
247 2.f, 2.f, 2.f, 2.f, 3.f, 3.f, 3.f, 3.f,
248 4.f, 4.f, 4.f, 4.f, 5.f, 5.f, 5.f, 5.f
249
250 };
251
252 std::vector<float> input1Values =
253 {
254 1.f, 1.f, 1.f, 1.f, 2.f, 2.f, 2.f, 2.f,
255 4.f, 4.f, 4.f, 4.f, 4.f, 4.f, 4.f, 4.f
256 };
257
258 std::vector<float> expectedOutputValues =
259 {
260 2.f, 2.f, 2.f, 2.f, 1.50f, 1.50f, 1.50f, 1.50f,
261 1.f, 1.f, 1.f, 1.f, 1.25f, 1.25f, 1.25f, 1.25f
262 };
263
264 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_DIV,
265 tflite::ActivationFunctionType_NONE,
266 ::tflite::TensorType_FLOAT32,
267 backends,
268 input0Shape,
269 input1Shape,
270 expectedOutputShape,
271 input0Values,
272 input1Values,
273 expectedOutputValues);
274}
275
276void DivBroadcastTest(std::vector<armnn::BackendId>& backends)
277{
278 std::vector<int32_t> input0Shape { 1, 2, 2, 2 };
279 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
280 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 2 };
281
282 std::vector<float> input0Values = { 2, 4, 6, 8, 10, 12, 14, 16 };
283 std::vector<float> input1Values = { 2 };
284 std::vector<float> expectedOutputValues = { 1, 2, 3, 4, 5, 6, 7, 8 };
285
286 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_DIV,
287 tflite::ActivationFunctionType_NONE,
288 ::tflite::TensorType_FLOAT32,
289 backends,
290 input0Shape,
291 input1Shape,
292 expectedOutputShape,
293 input0Values,
294 input1Values,
295 expectedOutputValues);
296}
297
298void DivUint8Test(std::vector<armnn::BackendId>& backends)
299{
300 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
301 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
302 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
303
304 std::vector<uint8_t> input0Values =
305 {
306 2, 2, 2, 2, 3, 3, 3, 3,
307 4, 4, 4, 4, 5, 5, 5, 5
308
309 };
310
311 std::vector<uint8_t> input1Values =
312 {
313 1, 1, 1, 1, 2, 2, 2, 2,
314 4, 4, 4, 4, 4, 4, 4, 4
315 };
316
317 std::vector<uint8_t> expectedOutputValues =
318 {
319 8, 8, 8, 8, 6, 6, 6, 6,
320 4, 4, 4, 4, 5, 5, 5, 5
321 };
322
323 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_DIV,
324 tflite::ActivationFunctionType_NONE,
325 ::tflite::TensorType_UINT8,
326 backends,
327 input0Shape,
328 input1Shape,
329 expectedOutputShape,
330 input0Values,
331 input1Values,
332 expectedOutputValues, 0.25f, 0);
333}
334
Jim Flynn4b2f3472021-10-13 21:20:07 +0100[diff] [blame]335void FloorDivFP32Test(std::vector<armnn::BackendId>& backends)
336{
337 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
338 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
339 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
340
341 std::vector<float> input0Values =
342 {
343 -37.5f, -15.2f, -8.76f, -2.0f, -2.6f, -1.0f, -0.8f, 0.0f,
344 4.0f, 1.6f, 2.0f, 5.2f, 6.0f, 35.04f, 60.8f, 150.0f
345 };
346
347 std::vector<float> input1Values =
348 {
349 1.f, 1.f, 1.f, 1.f, 2.f, 2.f, 2.f, 2.f,
350 4.f, 4.f, 4.f, 4.f, 4.f, 4.f, 4.f, 4.f
351 };
352
353 std::vector<float> expectedOutputValues =
354 {
355 -38.0f, -16.0f, -9.0f, -2.0f, -2.0f, -1.0f, -1.0f, 0.0f,
356 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 8.0f, 15.0f, 37.0f
357 };
358
359 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_FLOOR_DIV,
360 tflite::ActivationFunctionType_NONE,
361 ::tflite::TensorType_FLOAT32,
362 backends,
363 input0Shape,
364 input1Shape,
365 expectedOutputShape,
366 input0Values,
367 input1Values,
368 expectedOutputValues);
369
370}
371
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]372void MaxFP32Test(std::vector<armnn::BackendId>& backends)
373{
374 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
375 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
376 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
377
378 std::vector<float> input0Values =
379 {
380 1.f, 1.f, 5.f, 1.f, 2.f, 2.f, 7.f, 2.f,
381 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
382
383 };
384
385 std::vector<float> input1Values =
386 {
387 2.f, 2.f, 2.f, 2.f, 3.f, 3.f, 3.f, 3.f,
388 4.f, 4.f, 4.f, 4.f, 5.f, 5.f, 5.f, 5.f
389 };
390
391 std::vector<float> expectedOutputValues =
392 {
393 2.f, 2.f, 5.f, 2.f, 3.f, 3.f, 7.f, 3.f,
394 4.f, 4.f, 4.f, 4.f, 5.f, 5.f, 5.f, 5.f
395 };
396
397 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MAXIMUM,
398 tflite::ActivationFunctionType_NONE,
399 ::tflite::TensorType_FLOAT32,
400 backends,
401 input0Shape,
402 input1Shape,
403 expectedOutputShape,
404 input0Values,
405 input1Values,
406 expectedOutputValues);
407}
408
409void MaxBroadcastTest(std::vector<armnn::BackendId>& backends)
410{
411 std::vector<int32_t> input0Shape { 1, 2, 2, 2 };
412 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
413 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 2 };
414
415 std::vector<float> input0Values = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f };
416 std::vector<float> input1Values = { 4.f };
417 std::vector<float> expectedOutputValues = { 4.f, 4.f, 4.f, 4.f, 5.f, 6.f, 7.f, 8.f };
418
419 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MAXIMUM,
420 tflite::ActivationFunctionType_NONE,
421 ::tflite::TensorType_FLOAT32,
422 backends,
423 input0Shape,
424 input1Shape,
425 expectedOutputShape,
426 input0Values,
427 input1Values,
428 expectedOutputValues);
429}
430
431void MaxUint8Test(std::vector<armnn::BackendId>& backends)
432{
433 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
434 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
435 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
436
437 std::vector<uint8_t> input0Values =
438 {
439 1, 1, 1, 1, 7, 8, 9, 9,
440 3, 3, 3, 3, 4, 4, 4, 4
441
442 };
443
444 std::vector<uint8_t> input1Values =
445 {
446 2, 2, 2, 2, 3, 3, 3, 3,
447 4, 4, 4, 4, 5, 5, 5, 5
448 };
449
450 std::vector<uint8_t> expectedOutputValues =
451 {
452 2, 2, 2, 2, 7, 8, 9, 9,
453 4, 4, 4, 4, 5, 5, 5, 5
454 };
455
456 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_MAXIMUM,
457 tflite::ActivationFunctionType_NONE,
458 ::tflite::TensorType_UINT8,
459 backends,
460 input0Shape,
461 input1Shape,
462 expectedOutputShape,
463 input0Values,
464 input1Values,
465 expectedOutputValues, 1.0f, 0);
466}
467
468void MinFP32Test(std::vector<armnn::BackendId>& backends)
469{
470 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
471 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
472 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
473
474 std::vector<float> input0Values =
475 {
476 1.f, 1.f, 5.f, 1.f, 2.f, 2.f, 7.f, 2.f,
477 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
478
479 };
480
481 std::vector<float> input1Values =
482 {
483 2.f, 2.f, 2.f, 2.f, 3.f, 3.f, 3.f, 3.f,
484 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f
485 };
486
487 std::vector<float> expectedOutputValues =
488 {
489 1.f, 1.f, 2.f, 1.f, 2.f, 2.f, 3.f, 2.f,
490 1.f, 1.f, 1.f, 1.f, 4.f, 4.f, 4.f, 4.f
491 };
492
493 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MINIMUM,
494 tflite::ActivationFunctionType_NONE,
495 ::tflite::TensorType_FLOAT32,
496 backends,
497 input0Shape,
498 input1Shape,
499 expectedOutputShape,
500 input0Values,
501 input1Values,
502 expectedOutputValues);
503}
504
505void MinBroadcastTest(std::vector<armnn::BackendId>& backends)
506{
507 std::vector<int32_t> input0Shape { 1, 2, 2, 2 };
508 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
509 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 2 };
510
511 std::vector<float> input0Values = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f };
512
513 std::vector<float> input1Values = { 4.f };
514
515 std::vector<float> expectedOutputValues = { 1.f, 2.f, 3.f, 4.f, 4.f, 4.f, 4.f, 4.f };
516
517 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MINIMUM,
518 tflite::ActivationFunctionType_NONE,
519 ::tflite::TensorType_FLOAT32,
520 backends,
521 input0Shape,
522 input1Shape,
523 expectedOutputShape,
524 input0Values,
525 input1Values,
526 expectedOutputValues);
527}
528
529void MinUint8Test(std::vector<armnn::BackendId>& backends)
530{
531 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
532 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
533 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
534
535 std::vector<uint8_t> input0Values =
536 {
537 1, 1, 1, 1, 7, 8, 9, 9,
538 3, 3, 3, 3, 4, 4, 4, 4
539
540 };
541
542 std::vector<uint8_t> input1Values =
543 {
544 2, 2, 2, 2, 3, 3, 3, 3,
545 4, 4, 4, 4, 5, 5, 5, 5
546 };
547
548 std::vector<uint8_t> expectedOutputValues =
549 {
550 1, 1, 1, 1, 3, 3, 3, 3,
551 3, 3, 3, 3, 4, 4, 4, 4
552 };
553
554 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_MINIMUM,
555 tflite::ActivationFunctionType_NONE,
556 ::tflite::TensorType_UINT8,
557 backends,
558 input0Shape,
559 input1Shape,
560 expectedOutputShape,
561 input0Values,
562 input1Values,
563 expectedOutputValues, 1.0f, 0);
564}
565
566void MulFP32Test(std::vector<armnn::BackendId>& backends)
567{
568 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
569 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
570 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
571
572 std::vector<float> input0Values =
573 {
574 1.f, 1.f, 1.f, 1.f, 2.f, 2.f, 2.f, 2.f,
575 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
576
577 };
578
579 std::vector<float> input1Values =
580 {
581 2.f, 2.f, 2.f, 2.f, 3.f, 3.f, 3.f, 3.f,
582 4.f, 4.f, 4.f, 4.f, 5.f, 5.f, 5.f, 5.f
583 };
584
585 std::vector<float> expectedOutputValues =
586 {
587 2.f, 2.f, 2.f, 2.f, 6.f, 6.f, 6.f, 6.f,
588 12.f, 12.f, 12.f, 12.f, 20.f, 20.f, 20.f, 20.f
589 };
590
591 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MUL,
592 tflite::ActivationFunctionType_NONE,
593 ::tflite::TensorType_FLOAT32,
594 backends,
595 input0Shape,
596 input1Shape,
597 expectedOutputShape,
598 input0Values,
599 input1Values,
600 expectedOutputValues);
601}
602
603void MulBroadcastTest(std::vector<armnn::BackendId>& backends)
604{
605 std::vector<int32_t> input0Shape { 1, 2, 2, 2 };
606 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
607 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 2 };
608
609 std::vector<float> input0Values = { 2, 4, 6, 8, 10, 12, 14, 16 };
610 std::vector<float> input1Values = { 2 };
611 std::vector<float> expectedOutputValues = { 4, 8, 12, 16, 20, 24, 28, 32 };
612
613 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MUL,
614 tflite::ActivationFunctionType_NONE,
615 ::tflite::TensorType_FLOAT32,
616 backends,
617 input0Shape,
618 input1Shape,
619 expectedOutputShape,
620 input0Values,
621 input1Values,
622 expectedOutputValues);
623}
624
625void MulUint8Test(std::vector<armnn::BackendId>& backends)
626{
627 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
628 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
629 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
630
631 std::vector<uint8_t> input0Values =
632 {
633 1, 2, 3, 4, 5, 6,
634 7, 8, 9, 10, 11, 12
635
636 };
637
638 std::vector<uint8_t> input1Values = { 1, 2, 3 };
639
640 std::vector<uint8_t> expectedOutputValues =
641 {
642 1, 4, 9, 4, 10, 18,
643 7, 16, 27, 10, 22, 36
644 };
645
646 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_MUL,
647 tflite::ActivationFunctionType_NONE,
648 ::tflite::TensorType_UINT8,
649 backends,
650 input0Shape,
651 input1Shape,
652 expectedOutputShape,
653 input0Values,
654 input1Values,
655 expectedOutputValues, 1.0f, 0);
656}
657
658void MulActivationTest(std::vector<armnn::BackendId>& backends)
659{
660 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
661 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
662 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
663
664 std::vector<float> input0Values { 4.0f, 0.0f, 1.0f, 0.5f };
665 std::vector<float> input1Values { -2.0f, -1.2f, 2.5f, 2.0f };
666 std::vector<float> expectedOutputValues { 0.0f, 0.0f, 2.5f, 1.0f };
667
668 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MUL,
669 tflite::ActivationFunctionType_RELU,
670 ::tflite::TensorType_FLOAT32,
671 backends,
672 input0Shape,
673 input1Shape,
674 expectedOutputShape,
675 input0Values,
676 input1Values,
677 expectedOutputValues);
678}
679
680void SubFP32Test(std::vector<armnn::BackendId>& backends)
681{
682 std::vector<int32_t> input0Shape { 1, 1, 2, 2 };
683 std::vector<int32_t> input1Shape { 1, 1, 2, 2 };
684 std::vector<int32_t> expectedOutputShape { 1, 1, 2, 2 };
685
686 std::vector<float> input0Values = { 1, 3, 3, -7 };
687 std::vector<float> input1Values = { 1, -1, 0, -2 };
688 std::vector<float> expectedOutputValues = { 0, 4, 3, -5 };
689
690 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_SUB,
691 tflite::ActivationFunctionType_NONE,
692 ::tflite::TensorType_FLOAT32,
693 backends,
694 input0Shape,
695 input1Shape,
696 expectedOutputShape,
697 input0Values,
698 input1Values,
699 expectedOutputValues);
700}
701
702void SubBroadcastTest(std::vector<armnn::BackendId>& backends)
703{
704 std::vector<int32_t> input0Shape { 1, 1, 2, 2 };
705 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
706 std::vector<int32_t> expectedOutputShape { 1, 1, 2, 2 };
707
708 std::vector<float> input0Values = { 2, 3, 4, 5};
709 std::vector<float> input1Values = { 10 };
710 std::vector<float> expectedOutputValues = { -8, -7, -6, -5 };
711
712 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_SUB,
713 tflite::ActivationFunctionType_NONE,
714 ::tflite::TensorType_FLOAT32,
715 backends,
716 input0Shape,
717 input1Shape,
718 expectedOutputShape,
719 input0Values,
720 input1Values,
721 expectedOutputValues);
722}
723
724void SubUint8Test(std::vector<armnn::BackendId>& backends)
725{
726 std::vector<int32_t> input0Shape { 1, 1, 2, 2 };
727 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
728 std::vector<int32_t> expectedOutputShape { 1, 1, 2, 2 };
729
730 std::vector<uint8_t> input0Values = { 10, 12, 14, 16 };
731 std::vector<uint8_t> input1Values = { 2 };
732 std::vector<uint8_t> expectedOutputValues = { 8, 10, 12, 14 };
733
734 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_SUB,
735 tflite::ActivationFunctionType_NONE,
736 ::tflite::TensorType_UINT8,
737 backends,
738 input0Shape,
739 input1Shape,
740 expectedOutputShape,
741 input0Values,
742 input1Values,
743 expectedOutputValues, 1.0f, 0);
744}
745
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]746TEST_SUITE("ElementwiseBinary_GpuAccTests")
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]747{
748
749TEST_CASE ("ADD_FP32_GpuAcc_Test")
750{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]751 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]752 AddFP32Test(backends);
753}
754
755TEST_CASE ("ADD_Broadcast_GpuAcc_Test")
756{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]757 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]758 AddBroadcastTest(backends);
759}
760
761TEST_CASE ("ADD_Activation_GpuAcc_Test")
762{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]763 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]764 AddActivationTest(backends);
765}
766
767TEST_CASE ("ADD_UINT8_GpuAcc_Test")
768{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]769 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]770 AddUint8Test(backends);
771}
772
773TEST_CASE ("DIV_FP32_GpuAcc_Test")
774{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]775 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]776 DivFP32Test(backends);
777}
778
779TEST_CASE ("DIV_Broadcast_GpuAcc_Test")
780{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]781 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]782 DivBroadcastTest(backends);
783}
784
Jim Flynn4b2f3472021-10-13 21:20:07 +0100[diff] [blame]785TEST_CASE ("FLOORDIV_FP32_GpuAcc_Test")
786{
787 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
788 FloorDivFP32Test(backends);
789}
790
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]791TEST_CASE ("MAX_FP32_GpuAcc_Test")
792{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]793 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]794 MaxFP32Test(backends);
795}
796
797TEST_CASE ("MAX_Broadcast_GpuAcc_Test")
798{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]799 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]800 MaxBroadcastTest(backends);
801}
802
803TEST_CASE ("MAX_UINT8_GpuAcc_Test")
804{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]805 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]806 MaxUint8Test(backends);
807}
808
809TEST_CASE ("MIN_FP32_GpuAcc_Test")
810{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]811 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]812 MinFP32Test(backends);
813}
814
815TEST_CASE ("MIN_Broadcast_GpuAcc_Test")
816{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]817 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]818 MinBroadcastTest(backends);
819}
820
821TEST_CASE ("MIN_UINT8_GpuAcc_Test")
822{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]823 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]824 MinUint8Test(backends);
825}
826
827TEST_CASE ("MUL_FP32_GpuAcc_Test")
828{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]829 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]830 MulFP32Test(backends);
831}
832
833TEST_CASE ("MUL_Broadcast_GpuAcc_Test")
834{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]835 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]836 MulBroadcastTest(backends);
837}
838
839TEST_CASE ("MUL_Activation_GpuAcc_Test")
840{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]841 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]842 MulActivationTest(backends);
843}
844
845TEST_CASE ("MUL_UINT8_GpuAcc_Test")
846{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]847 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]848 MulUint8Test(backends);
849}
850
851TEST_CASE ("SUB_FP32_GpuAcc_Test")
852{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]853 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]854 SubFP32Test(backends);
855}
856
857TEST_CASE ("SUB_Broadcast_GpuAcc_Test")
858{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]859 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]860 SubBroadcastTest(backends);
861}
862
863TEST_CASE ("SUB_UINT8_GpuAcc_Test")
864{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]865 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]866 SubUint8Test(backends);
867}
868
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]869} //TEST_SUITE("ElementwiseBinary_GpuAccTests")
870
871
872
873TEST_SUITE("ElementwiseBinary_CpuAccTests")
874{
875
876TEST_CASE ("ADD_FP32_CpuAcc_Test")
877{
878 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
879 AddFP32Test(backends);
880}
881
882TEST_CASE ("ADD_Broadcast_CpuAcc_Test")
883{
884 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
885 AddBroadcastTest(backends);
886}
887
Ryan OSheaa544f0f2023-01-25 18:10:20 +0000[diff] [blame]888TEST_CASE ("ADD_Activation_CpuAcc_Test")
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]889{
890 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
891 AddActivationTest(backends);
892}
893
894TEST_CASE ("ADD_UINT8_CpuAcc_Test")
895{
896 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
897 AddUint8Test(backends);
898}
899
900TEST_CASE ("DIV_FP32_CpuAcc_Test")
901{
902 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
903 DivFP32Test(backends);
904}
905
906TEST_CASE ("DIV_Broadcast_CpuAcc_Test")
907{
908 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
909 DivBroadcastTest(backends);
910}
911
Jim Flynn4b2f3472021-10-13 21:20:07 +0100[diff] [blame]912TEST_CASE ("FLOORDIV_FP32_CpuAcc_Test")
913{
914 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
915 FloorDivFP32Test(backends);
916}
917
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]918TEST_CASE ("MAX_FP32_CpuAcc_Test")
919{
920 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
921 MaxFP32Test(backends);
922}
923
924TEST_CASE ("MAX_Broadcast_CpuAcc_Test")
925{
926 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
927 MaxBroadcastTest(backends);
928}
929
930TEST_CASE ("MAX_UINT8_CpuAcc_Test")
931{
932 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
933 MaxUint8Test(backends);
934}
935
936TEST_CASE ("MIN_FP32_CpuAcc_Test")
937{
938 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
939 MinFP32Test(backends);
940}
941
942TEST_CASE ("MIN_Broadcast_CpuAcc_Test")
943{
944 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
945 MinBroadcastTest(backends);
946}
947
948TEST_CASE ("MIN_UINT8_CpuAcc_Test")
949{
950 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
951 MinUint8Test(backends);
952}
953
954TEST_CASE ("MUL_FP32_CpuAcc_Test")
955{
956 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
957 MulFP32Test(backends);
958}
959
960TEST_CASE ("MUL_Broadcast_CpuAcc_Test")
961{
962 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
963 MulBroadcastTest(backends);
964}
965
966TEST_CASE ("MUL_Actiation_CpuAcc_Test")
967{
968 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
969 MulActivationTest(backends);
970}
971
972TEST_CASE ("MUL_UINT8_CpuAcc_Test")
973{
974 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
975 MulUint8Test(backends);
976}
977
978TEST_CASE ("SUB_FP32_CpuAcc_Test")
979{
980 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
981 SubFP32Test(backends);
982}
983
984TEST_CASE ("SUB_Broadcast_CpuAcc_Test")
985{
986 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
987 SubBroadcastTest(backends);
988}
989
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]990TEST_CASE ("SUB_UINT8_CpuAcc_Test")
991{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]992 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]993 SubUint8Test(backends);
994}
995
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]996} // TEST_SUITE("ElementwiseBinary_CpuAccTests")
997
998
999TEST_SUITE("ElementwiseBinary_CpuRefTests")
1000{
1001
1002TEST_CASE ("ADD_FP32_CpuRef_Test")
1003{
1004 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1005 AddFP32Test(backends);
1006}
1007
1008TEST_CASE ("ADD_Broadcast_CpuRef_Test")
1009{
1010 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1011 AddBroadcastTest(backends);
1012}
1013
Sadik Armaganf7ac72c2021-05-05 15:03:50 +0100[diff] [blame]1014TEST_CASE ("ADD_Constant_Input_CpuRef_Test")
1015{
1016 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1017 AddConstInputTest(backends);
1018}
1019
Ryan OSheaa544f0f2023-01-25 18:10:20 +0000[diff] [blame]1020TEST_CASE ("ADD_Activation_CpuRef_Test")
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]1021{
1022 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1023 AddActivationTest(backends);
1024}
1025
1026TEST_CASE ("ADD_UINT8_CpuRef_Test")
1027{
1028 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1029 AddUint8Test(backends);
1030}
1031
1032TEST_CASE ("DIV_FP32_CpuRef_Test")
1033{
1034 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1035 DivFP32Test(backends);
1036}
1037
1038TEST_CASE ("DIV_Broadcast_CpuRef_Test")
1039{
1040 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1041 DivBroadcastTest(backends);
1042}
1043
Jim Flynn4b2f3472021-10-13 21:20:07 +0100[diff] [blame]1044TEST_CASE ("FLOORDIV_FP32_CpuRef_Test")
1045{
1046 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1047 FloorDivFP32Test(backends);
1048}
1049
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]1050TEST_CASE ("DIV_UINT8_CpuRef_Test")
1051{
1052 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1053 DivUint8Test(backends);
1054}
1055
1056TEST_CASE ("MAX_FP32_CpuRef_Test")
1057{
1058 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1059 MaxFP32Test(backends);
1060}
1061
1062TEST_CASE ("MAX_Broadcast_CpuRef_Test")
1063{
1064 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1065 MaxBroadcastTest(backends);
1066}
1067
1068TEST_CASE ("MAX_UINT8_CpuRef_Test")
1069{
1070 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1071 MaxUint8Test(backends);
1072}
1073
1074TEST_CASE ("MIN_FP32_CpuRef_Test")
1075{
1076 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1077 MinFP32Test(backends);
1078}
1079
1080TEST_CASE ("MIN_Broadcast_CpuRef_Test")
1081{
1082 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1083 MinBroadcastTest(backends);
1084}
1085
1086TEST_CASE ("MIN_UINT8_CpuRef_Test")
1087{
1088 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1089 MinUint8Test(backends);
1090}
1091
1092TEST_CASE ("MUL_FP32_CpuRef_Test")
1093{
1094 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1095 MulFP32Test(backends);
1096}
1097
1098TEST_CASE ("MUL_Broadcast_CpuRef_Test")
1099{
1100 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1101 MulBroadcastTest(backends);
1102}
1103
1104TEST_CASE ("MUL_Actiation_CpuRef_Test")
1105{
1106 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1107 MulActivationTest(backends);
1108}
1109
1110TEST_CASE ("MUL_UINT8_CpuRef_Test")
1111{
1112 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1113 MulUint8Test(backends);
1114}
1115
1116TEST_CASE ("SUB_FP32_CpuRef_Test")
1117{
1118 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1119 SubFP32Test(backends);
1120}
1121
1122TEST_CASE ("SUB_Broadcast_CpuRef_Test")
1123{
1124 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1125 SubBroadcastTest(backends);
1126}
1127
1128TEST_CASE ("SUB_UINT8_CpuRef_Test")
1129{
1130 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1131 SubUint8Test(backends);
1132}
1133
1134} // TEST_SUITE("ElementwiseBinary_CpuRefTests")
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]1135
Jim Flynn4b2f3472021-10-13 21:20:07 +0100[diff] [blame]1136} // namespace armnnDelegate