1 //
2 // Copyright © 2017-2023 Arm Ltd and Contributors. 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/BatchToSpaceNdEndToEndTestImpl.hpp>
12 #include <backendsCommon/test/BatchMatMulEndToEndTestImpl.hpp>
13 #include <backendsCommon/test/ChannelShuffleEndToEndTestImpl.hpp>
14 #include <backendsCommon/test/ComparisonEndToEndTestImpl.hpp>
15 #include <backendsCommon/test/ConcatEndToEndTestImpl.hpp>
16 #include <backendsCommon/test/Convolution2dEndToEndTestImpl.hpp>
17 #include <backendsCommon/test/Convolution3dEndToEndTestImpl.hpp>
18 #include <backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp>
19 #include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp>
20 #include <backendsCommon/test/DetectionPostProcessEndToEndTestImpl.hpp>
21 #include <backendsCommon/test/ElementwiseBinaryEndToEndTestImpl.hpp>
22 #include <backendsCommon/test/ElementwiseUnaryEndToEndTestImpl.hpp>
23 #include <backendsCommon/test/FillEndToEndTestImpl.hpp>
24 #include <backendsCommon/test/FullyConnectedEndToEndTestImpl.hpp>
25 #include <backendsCommon/test/GatherEndToEndTestImpl.hpp>
26 #include <backendsCommon/test/GatherNdEndToEndTestImpl.hpp>
27 #include <backendsCommon/test/InstanceNormalizationEndToEndTestImpl.hpp>
28 #include <backendsCommon/test/LogSoftmaxEndToEndTestImpl.hpp>
29 #include <backendsCommon/test/PreluEndToEndTestImpl.hpp>
30 #include <backendsCommon/test/QLstmEndToEndTestImpl.hpp>
31 #include <backendsCommon/test/RankEndToEndTestImpl.hpp>
32 #include <backendsCommon/test/ReduceEndToEndTestImpl.hpp>
33 #include <backendsCommon/test/ReshapeEndToEndTestImpl.hpp>
34 #include <backendsCommon/test/ResizeEndToEndTestImpl.hpp>
35 #include <backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp>
36 #include <backendsCommon/test/SplitterEndToEndTestImpl.hpp>
37 #include <backendsCommon/test/StridedSliceAsyncEndToEndTest.hpp>
38 #include <backendsCommon/test/TransposeConvolution2dEndToEndTestImpl.hpp>
39 #include <backendsCommon/test/TransposeEndToEndTestImpl.hpp>
40
41 #include <doctest/doctest.h>
42
43 TEST_SUITE("RefEndToEnd")
44 {
45 std::vector<armnn::BackendId> defaultBackends = {armnn::Compute::CpuRef};
46
47 // ElementwiseUnary
48 // Abs
49 TEST_CASE("RefAbsEndToEndTestFloat32")
50 {
51 ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
52 UnaryOperation::Abs);
53 }
54
55 TEST_CASE("RefAbsEndToEndTestUint8")
56 {
57 ElementwiseUnarySimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
58 UnaryOperation::Abs);
59 }
60
61 TEST_CASE("RefAbsEndToEndTestInt16")
62 {
63 ElementwiseUnarySimpleEndToEnd<armnn::DataType::QSymmS16>(defaultBackends,
64 UnaryOperation::Abs);
65 }
66
67 // Rsqrt
68 TEST_CASE("RefRsqrtEndToEndTestFloat32")
69 {
70 ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
71 UnaryOperation::Rsqrt);
72 }
73
74 TEST_CASE("RefRsqrtEndToEndTestUint8")
75 {
76 ElementwiseUnarySimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
77 UnaryOperation::Rsqrt);
78 }
79
80 TEST_CASE("RefRsqrtEndToEndTestInt16")
81 {
82 ElementwiseUnarySimpleEndToEnd<armnn::DataType::QSymmS16>(defaultBackends,
83 UnaryOperation::Rsqrt);
84 }
85
86 // Addition
87 TEST_CASE("RefAdditionEndtoEndFloat32")
88 {
89 AdditionEndToEnd<armnn::DataType::Float32>(defaultBackends);
90 }
91
92 TEST_CASE("RefAdditionEndtoEndUint8")
93 {
94 AdditionEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
95 }
96
97 // Constant
98 TEST_CASE("ConstantUsage_Ref_Float32")
99 {
100 CHECK(ConstantUsageFloat32Test(defaultBackends));
101 }
102
103 TEST_CASE("ConstantUsage_Ref_Uint8")
104 {
105 CHECK(ConstantUsageUint8Test(defaultBackends));
106 }
107
108 TEST_CASE("Unsigned8")
109 {
110 using namespace armnn;
111
112 // Create runtime in which test will run
113 armnn::IRuntime::CreationOptions options;
114 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
115
116 // Builds up the structure of the network.
117 armnn::INetworkPtr net(INetwork::Create());
118
119 IConnectableLayer* input = net->AddInputLayer(0, "input");
120 IConnectableLayer* softmax = net->AddSoftmaxLayer(SoftmaxDescriptor(), "softmax");
121 IConnectableLayer* output = net->AddOutputLayer(0, "output");
122
123 input->GetOutputSlot(0).Connect(softmax->GetInputSlot(0));
124 softmax->GetOutputSlot(0).Connect(output->GetInputSlot(0));
125
126 // Sets the tensors in the network.
127 TensorInfo inputTensorInfo(TensorShape({1, 5}), DataType::QAsymmU8);
128 inputTensorInfo.SetQuantizationOffset(100);
129 inputTensorInfo.SetQuantizationScale(10000.0f);
130 input->GetOutputSlot(0).SetTensorInfo(inputTensorInfo);
131
132 TensorInfo outputTensorInfo(TensorShape({1, 5}), DataType::QAsymmU8);
133 outputTensorInfo.SetQuantizationOffset(0);
134 outputTensorInfo.SetQuantizationScale(1.0f/255.0f);
135 softmax->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
136
137 // optimize the network
138 IOptimizedNetworkPtr optNet = Optimize(*net, defaultBackends, runtime->GetDeviceSpec());
139
140 // Loads it into the runtime.
141 NetworkId netId;
142 auto error = runtime->LoadNetwork(netId, std::move(optNet));
143 CHECK(error == Status::Success);
144
145 // Creates structures for input & output.
146 std::vector<uint8_t> inputData
147 {
148 1, 10, 3, 200, 5 // Some inputs - one of which is sufficiently larger than the others to saturate softmax.
149 };
150 std::vector<uint8_t> outputData(5);
151
152 TensorInfo inputTensorInfo2 = runtime->GetInputTensorInfo(netId, 0);
153 inputTensorInfo2.SetConstant(true);
154 armnn::InputTensors inputTensors
155 {
156 {0, armnn::ConstTensor(inputTensorInfo2, inputData.data())}
157 };
158 armnn::OutputTensors outputTensors
159 {
160 {0, armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())}
161 };
162
163 // Does the inference.
164 runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
165
166 // Checks the results.
167 CHECK(outputData[0] == 0);
168 CHECK(outputData[1] == 0);
169 CHECK(outputData[2] == 0);
170 CHECK(outputData[3] == 255); // softmax has been saturated.
171 CHECK(outputData[4] == 0);
172 }
173
174 TEST_CASE("TrivialAdd")
175 {
176 // This test was designed to match "AddTwo" in android nn/runtime/test/TestTrivialModel.cpp.
177
178 using namespace armnn;
179
180 // Create runtime in which test will run
181 armnn::IRuntime::CreationOptions options;
182 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
183
184 // Builds up the structure of the network.
185 armnn::INetworkPtr net(INetwork::Create());
186
187 IConnectableLayer* input1 = net->AddInputLayer(0);
188 IConnectableLayer* input2 = net->AddInputLayer(1);
189 IConnectableLayer* add = net->AddElementwiseBinaryLayer(ElementwiseBinaryDescriptor(BinaryOperation::Add));
190 IConnectableLayer* output = net->AddOutputLayer(0);
191
192 input1->GetOutputSlot(0).Connect(add->GetInputSlot(0));
193 input2->GetOutputSlot(0).Connect(add->GetInputSlot(1));
194 add->GetOutputSlot(0).Connect(output->GetInputSlot(0));
195
196 // Sets the tensors in the network.
197 TensorInfo tensorInfo(TensorShape({3, 4}), DataType::Float32);
198 input1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
199 input2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
200 add->GetOutputSlot(0).SetTensorInfo(tensorInfo);
201
202 // optimize the network
203 IOptimizedNetworkPtr optNet = Optimize(*net, defaultBackends, runtime->GetDeviceSpec());
204
205 // Loads it into the runtime.
206 NetworkId netId;
207 runtime->LoadNetwork(netId, std::move(optNet));
208
209 // Creates structures for input & output - matching android nn test.
210 std::vector<float> input1Data
211 {
212 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
213 };
214 std::vector<float> input2Data
215 {
216 100.f, 200.f, 300.f, 400.f, 500.f, 600.f, 700.f, 800.f, 900.f, 1000.f, 1100.f, 1200.f
217 };
218 std::vector<float> outputData(12);
219
220 TensorInfo inputTensorInfo = runtime->GetInputTensorInfo(netId, 0);
221 inputTensorInfo.SetConstant(true);
222 InputTensors inputTensors
223 {
224 {0,armnn::ConstTensor(inputTensorInfo, input1Data.data())},
225 {1,armnn::ConstTensor(inputTensorInfo, input2Data.data())}
226 };
227 OutputTensors outputTensors
228 {
229 {0,armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())}
230 };
231
232 // Does the inference.
233 runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
234
235 // Checks the results
236 CHECK(outputData[0] == 101);
237 CHECK(outputData[1] == 202);
238 CHECK(outputData[2] == 303);
239 CHECK(outputData[3] == 404);
240 CHECK(outputData[4] == 505);
241 CHECK(outputData[5] == 606);
242 CHECK(outputData[6] == 707);
243 CHECK(outputData[7] == 808);
244 CHECK(outputData[8] == 909);
245 CHECK(outputData[9] == 1010);
246 CHECK(outputData[10] == 1111);
247 CHECK(outputData[11] == 1212);
248 }
249
250 TEST_CASE("MultipleOutputs")
251 {
252 using namespace armnn;
253
254 // Create runtime in which test will run
255 armnn::IRuntime::CreationOptions options;
256 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
257
258 // Builds up the structure of the network.
259 INetworkPtr net(INetwork::Create());
260
261 IConnectableLayer* input = net->AddInputLayer(0);
262
263 // ReLu1
264 ActivationDescriptor activation1Descriptor;
265 activation1Descriptor.m_Function = ActivationFunction::BoundedReLu;
266 activation1Descriptor.m_A = 1.f;
267 activation1Descriptor.m_B = -1.f;
268 IConnectableLayer* activation1 = net->AddActivationLayer(activation1Descriptor);
269
270 // ReLu6
271 ActivationDescriptor activation2Descriptor;
272 activation2Descriptor.m_Function = ActivationFunction::BoundedReLu;
273 activation2Descriptor.m_A = 6.0f;
274 IConnectableLayer* activation2 = net->AddActivationLayer(activation2Descriptor);
275
276 // BoundedReLu(min=2, max=5)
277 ActivationDescriptor activation3Descriptor;
278 activation3Descriptor.m_Function = ActivationFunction::BoundedReLu;
279 activation3Descriptor.m_A = 5.0f;
280 activation3Descriptor.m_B = 2.0f;
281 IConnectableLayer* activation3 = net->AddActivationLayer(activation3Descriptor);
282
283 IConnectableLayer* output1 = net->AddOutputLayer(0);
284 IConnectableLayer* output2 = net->AddOutputLayer(1);
285 IConnectableLayer* output3 = net->AddOutputLayer(2);
286
287 input->GetOutputSlot(0).Connect(activation1->GetInputSlot(0));
288 input->GetOutputSlot(0).Connect(activation2->GetInputSlot(0));
289 input->GetOutputSlot(0).Connect(activation3->GetInputSlot(0));
290
291 activation1->GetOutputSlot(0).Connect(output1->GetInputSlot(0));
292 activation2->GetOutputSlot(0).Connect(output2->GetInputSlot(0));
293 activation3->GetOutputSlot(0).Connect(output3->GetInputSlot(0));
294
295 // Sets the tensors in the network.
296 TensorInfo tensorInfo(TensorShape({ 10 }), DataType::Float32);
297 input->GetOutputSlot(0).SetTensorInfo(tensorInfo);
298 activation1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
299 activation2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
300 activation3->GetOutputSlot(0).SetTensorInfo(tensorInfo);
301
302 // optimize the network
303 IOptimizedNetworkPtr optNet = Optimize(*net, defaultBackends, runtime->GetDeviceSpec());
304
305 // Loads it into the runtime.
306 NetworkId netId;
307 runtime->LoadNetwork(netId, std::move(optNet));
308
309 // Creates structures for input & output.
310 const std::vector<float> inputData{ 3.f, 5.f, 2.f, 3.f, 7.f, 0.f, -2.f, -1.f, 3.f, 3.f };
311
312 std::vector<float> output1Data(inputData.size());
313 std::vector<float> output2Data(inputData.size());
314 std::vector<float> output3Data(inputData.size());
315
316 TensorInfo inputTensorInfo = runtime->GetInputTensorInfo(netId, 0);
317 inputTensorInfo.SetConstant(true);
318 InputTensors inputTensors
319 {
320 {0,armnn::ConstTensor(inputTensorInfo, inputData.data())}
321 };
322 OutputTensors outputTensors
323 {
324 {0,armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), output1Data.data())},
325 {1,armnn::Tensor(runtime->GetOutputTensorInfo(netId, 1), output2Data.data())},
326 {2,armnn::Tensor(runtime->GetOutputTensorInfo(netId, 2), output3Data.data())}
327 };
328
329 // Does the inference.
330 runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
331
332 // Checks the results.
333 CHECK(output1Data == std::vector<float>({ 1.f, 1.f, 1.f, 1.f, 1.f, 0.f, -1.f, -1.f, 1.f, 1.f })); // ReLu1
334 CHECK(output2Data == std::vector<float>({ 3.f, 5.f, 2.f, 3.f, 6.f, 0.f, 0.f, 0.f, 3.f, 3.f })); // ReLu6
335 CHECK(output3Data == std::vector<float>({ 3.f, 5.f, 2.f, 3.f, 5.f, 2.f, 2.f, 2.f, 3.f, 3.f })); // [2, 5]
336 }
337
338 TEST_CASE("TrivialMin")
339 {
340 using namespace armnn;
341
342 // Create runtime in which test will run
343 armnn::IRuntime::CreationOptions options;
344 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
345
346 // Builds up the structure of the network.
347 armnn::INetworkPtr net(INetwork::Create());
348
349 IConnectableLayer* input1 = net->AddInputLayer(0);
350 IConnectableLayer* input2 = net->AddInputLayer(1);
351 IConnectableLayer* min = net->AddElementwiseBinaryLayer(ElementwiseBinaryDescriptor(BinaryOperation::Minimum));
352 IConnectableLayer* output = net->AddOutputLayer(0);
353
354 input1->GetOutputSlot(0).Connect(min->GetInputSlot(0));
355 input2->GetOutputSlot(0).Connect(min->GetInputSlot(1));
356 min->GetOutputSlot(0).Connect(output->GetInputSlot(0));
357
358 // Sets the tensors in the network.
359 TensorInfo tensorInfo(TensorShape({1, 1, 1, 4}), DataType::Float32);
360 input1->GetOutputSlot(0).SetTensorInfo(tensorInfo);
361 input2->GetOutputSlot(0).SetTensorInfo(tensorInfo);
362 min->GetOutputSlot(0).SetTensorInfo(tensorInfo);
363
364 // optimize the network
365 IOptimizedNetworkPtr optNet = Optimize(*net, defaultBackends, runtime->GetDeviceSpec());
366
367 // Loads it into the runtime.
368 NetworkId netId;
369 runtime->LoadNetwork(netId, std::move(optNet));
370
371 // Creates structures for input & output - matching android nn test.
372 std::vector<float> input1Data
373 {
374 1.0f, 2.0f, 3.0f, 4.0f
375 };
376 std::vector<float> input2Data
377 {
378 2.0f, 1.0f, 5.0f, 2.0f
379 };
380 std::vector<float> outputData(4);
381
382 TensorInfo inputTensorInfo = runtime->GetInputTensorInfo(netId, 0);
383 inputTensorInfo.SetConstant(true);
384 InputTensors inputTensors
385 {
386 {0,armnn::ConstTensor(inputTensorInfo, input1Data.data())},
387 {1,armnn::ConstTensor(inputTensorInfo, input2Data.data())}
388 };
389 OutputTensors outputTensors
390 {
391 {0,armnn::Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())}
392 };
393
394 // Does the inference.
395 runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
396
397 // Checks the results
398 CHECK(outputData[0] == 1);
399 CHECK(outputData[1] == 1);
400 CHECK(outputData[2] == 3);
401 CHECK(outputData[3] == 2);
402 }
403
404 TEST_CASE("RefEqualSimpleEndToEndTest")
405 {
406 const std::vector<uint8_t> expectedOutput({ 1, 1, 1, 1, 0, 0, 0, 0,
407 0, 0, 0, 0, 1, 1, 1, 1 });
408
409 ComparisonSimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
410 ComparisonOperation::Equal,
411 expectedOutput);
412 }
413
414 TEST_CASE("RefGreaterSimpleEndToEndTest")
415 {
416 const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0, 1, 1, 1, 1,
417 0, 0, 0, 0, 0, 0, 0, 0 });
418
419 ComparisonSimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
420 ComparisonOperation::Greater,
421 expectedOutput);
422 }
423
424 TEST_CASE("RefEqualSimpleEndToEndUint8Test")
425 {
426 const std::vector<uint8_t> expectedOutput({ 1, 1, 1, 1, 0, 0, 0, 0,
427 0, 0, 0, 0, 1, 1, 1, 1 });
428
429 ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
430 ComparisonOperation::Equal,
431 expectedOutput);
432 }
433
434 TEST_CASE("RefGreaterSimpleEndToEndUint8Test")
435 {
436 const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0, 1, 1, 1, 1,
437 0, 0, 0, 0, 0, 0, 0, 0 });
438
439 ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
440 ComparisonOperation::Greater,
441 expectedOutput);
442 }
443
444 TEST_CASE("RefEqualBroadcastEndToEndTest")
445 {
446 const std::vector<uint8_t> expectedOutput({ 1, 0, 1, 1, 0, 0,
447 0, 0, 0, 0, 0, 0 });
448
449 ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(defaultBackends,
450 ComparisonOperation::Equal,
451 expectedOutput);
452 }
453
454 TEST_CASE("RefGreaterBroadcastEndToEndTest")
455 {
456 const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
457 1, 1, 1, 1, 1, 1 });
458
459 ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(defaultBackends,
460 ComparisonOperation::Greater,
461 expectedOutput);
462 }
463
464 TEST_CASE("RefEqualBroadcastEndToEndUint8Test")
465 {
466 const std::vector<uint8_t > expectedOutput({ 1, 0, 1, 1, 0, 0,
467 0, 0, 0, 0, 0, 0 });
468
469 ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
470 ComparisonOperation::Equal,
471 expectedOutput);
472 }
473
474 TEST_CASE("RefGreaterBroadcastEndToEndUint8Test")
475 {
476 const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
477 1, 1, 1, 1, 1, 1 });
478
479 ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
480 ComparisonOperation::Greater,
481 expectedOutput);
482 }
483
484 TEST_CASE("RefBatchMatMulEndToEndFloat32Test")
485 {
486 BatchMatMulEndToEnd<armnn::DataType::Float32>(defaultBackends);
487 }
488
489 TEST_CASE("RefBatchToSpaceNdEndToEndFloat32NHWCTest")
490 {
491 BatchToSpaceNdEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
492 }
493
494 TEST_CASE("RefBatchToSpaceNdEndToEndUint8NHWCTest")
495 {
496 BatchToSpaceNdEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC);
497 }
498
499 TEST_CASE("RefBatchToSpaceNdEndToEndQSymm16NHWCTest")
500 {
501 BatchToSpaceNdEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC);
502 }
503
504 TEST_CASE("RefBatchToSpaceNdEndToEndFloat32NCHWTest")
505 {
506 BatchToSpaceNdEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
507 }
508
509 TEST_CASE("RefBatchToSpaceNdEndToEndUint8NCHWTest")
510 {
511 BatchToSpaceNdEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW);
512 }
513
514 TEST_CASE("RefBatchToSpaceNdEndToEndQSymm16NCHWTest")
515 {
516 BatchToSpaceNdEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW);
517 }
518
519 TEST_CASE("RefBatchToSpaceNdEndToEndComplexFloat32NHWCTest")
520 {
521 BatchToSpaceNdComplexEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
522 }
523
524 TEST_CASE("RefBatchToSpaceNdEndToEndComplexUint8NHWCTest")
525 {
526 BatchToSpaceNdComplexEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC);
527 }
528
529 TEST_CASE("RefBatchToSpaceNdEndToEndComplexQSymm16NHWCTest")
530 {
531 BatchToSpaceNdComplexEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC);
532 }
533
534 TEST_CASE("RefBatchToSpaceNdEndToEndComplexFloat32NCHWTest")
535 {
536 BatchToSpaceNdComplexEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
537 }
538
539 TEST_CASE("RefBatchToSpaceNdEndToEndComplexUint8NCHWTest")
540 {
541 BatchToSpaceNdComplexEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW);
542 }
543
544 TEST_CASE("RefBatchToSpaceNdEndToEndComplexQSymm16NCHWTest")
545 {
546 BatchToSpaceNdComplexEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW);
547 }
548
549 TEST_CASE("RefChannelShuffleFloatTest")
550 {
551 ChannelShuffleEndToEnd<armnn::DataType::Float32>(defaultBackends);
552 }
553
554 TEST_CASE("RefChannelShuffleUint8Test")
555 {
556 ChannelShuffleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
557 }
558
559 TEST_CASE("RefConcatEndToEndDim0Test")
560 {
561 ConcatDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
562 }
563
564 TEST_CASE("RefConcatEndToEndDim0Uint8Test")
565 {
566 ConcatDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
567 }
568
569 TEST_CASE("RefConcatEndToEndDim1Test")
570 {
571 ConcatDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
572 }
573
574 TEST_CASE("RefConcatEndToEndDim1Uint8Test")
575 {
576 ConcatDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
577 }
578
579 TEST_CASE("RefConcatEndToEndDim2Test")
580 {
581 ConcatDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
582 }
583
584 TEST_CASE("RefConcatEndToEndDim2Uint8Test")
585 {
586 ConcatDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
587 }
588
589 TEST_CASE("RefConcatEndToEndDim3Test")
590 {
591 ConcatDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
592 }
593
594 TEST_CASE("RefConcatEndToEndDim3Uint8Test")
595 {
596 ConcatDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
597 }
598
599 TEST_CASE("RefConvolution2dFloat32Test")
600 {
601 Convolution2dEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
602 }
603
604 TEST_CASE("RefConvolution2dNchwFloat32Test")
605 {
606 Convolution2dEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
607 }
608
609 TEST_CASE("RefConvolution2dFloat16Test")
610 {
611 Convolution2dEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NHWC);
612 }
613
614 TEST_CASE("RefConvolution3dFloat32Test")
615 {
616 Convolution3dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(defaultBackends,
617 armnn::DataLayout::NDHWC);
618 }
619
620 TEST_CASE("RefConvolution3dNcdhwFloat32Test")
621 {
622 Convolution3dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(defaultBackends,
623 armnn::DataLayout::NCDHW);
624 }
625
626 TEST_CASE("RefConvolution3dFloat16Test")
627 {
628 Convolution3dEndToEnd<armnn::DataType::Float16, armnn::DataType::Float16>(defaultBackends,
629 armnn::DataLayout::NDHWC);
630 }
631
632 TEST_CASE("RefConvolution3dUint8Test")
633 {
634 Convolution3dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(defaultBackends,
635 armnn::DataLayout::NDHWC);
636 }
637
638 TEST_CASE("RefConvolution3dInt8Test")
639 {
640 Convolution3dEndToEnd<armnn::DataType::QAsymmS8, armnn::DataType::Signed32>(defaultBackends,
641 armnn::DataLayout::NDHWC);
642 }
643
644 TEST_CASE("RefEluEndToEndTestFloat32")
645 {
646 EluEndToEndTest<armnn::DataType::Float32>(defaultBackends);
647 }
648
649 TEST_CASE("RefEluEndToEndTestFloat16")
650 {
651 EluEndToEndTest<armnn::DataType::Float16>(defaultBackends);
652 }
653
654 TEST_CASE("RefEluEndToEndTestQAsymmS8")
655 {
656 EluEndToEndTest<armnn::DataType::QAsymmS8>(defaultBackends);
657 }
658
659 TEST_CASE("RefEluEndToEndTestQAsymmU8")
660 {
661 EluEndToEndTest<armnn::DataType::QAsymmU8>(defaultBackends);
662 }
663
664 TEST_CASE("RefEluEndToEndTestQSymmS16")
665 {
666 EluEndToEndTest<armnn::DataType::QSymmS16>(defaultBackends);
667 }
668
669 TEST_CASE("RefFillEndToEndTest")
670 {
671 FillEndToEnd<armnn::DataType::Float32>(defaultBackends);
672 }
673
674 TEST_CASE("RefFillEndToEndTestFloat16")
675 {
676 FillEndToEnd<armnn::DataType::Float16>(defaultBackends);
677 }
678
679 TEST_CASE("RefFillEndToEndTestInt32")
680 {
681 FillEndToEnd<armnn::DataType::Signed32>(defaultBackends);
682 }
683
684 TEST_CASE("RefFullyConnectedEndToEndTestFloat32")
685 {
686 FullyConnectedWithDynamicWeightsEndToEnd<armnn::DataType::Float32>(defaultBackends);
687 }
688
689 TEST_CASE("RefFullyConnectedEndToEndTestNonConstantWeightsConstantBiasesFloat32")
690 {
691 FullyConnectedWithDynamicOrConstantInputsEndToEnd<armnn::DataType::Float32>(defaultBackends, true, true);
692 }
693
694 TEST_CASE("RefFullyConnectedEndToEndTestConstantWeightsNonConstantBiasesFloat32")
695 {
696 FullyConnectedWithDynamicOrConstantInputsEndToEnd<armnn::DataType::Float32>(defaultBackends, true, false);
697 }
698
699 TEST_CASE("RefFullyConnectedEndToEndTestConstantWeightsTensorInfoNotSet")
700 {
701 FullyConnectedErrorChecking<armnn::DataType::Float32>(defaultBackends, false, true, true, true, false);
702 }
703
704 TEST_CASE("RefFullyConnectedEndToEndTestWeightsNotConnectedExplicitCheck")
705 {
706 FullyConnectedErrorChecking<armnn::DataType::Float32>(defaultBackends, true, true, false, true, true);
707 }
708
709 TEST_CASE("RefFullyConnectedEndToEndTestBiasNotConnectedExplicitCheck")
710 {
711 FullyConnectedErrorChecking<armnn::DataType::Float32>(defaultBackends, true, true, true, false, true);
712 }
713
714 TEST_CASE("RefFullyConnectedEndToEndTestWeightsAndBiasNotConnected")
715 {
716 FullyConnectedErrorChecking<armnn::DataType::Float32>(defaultBackends, false, true, false, false, true);
717 }
718
719 TEST_CASE("RefFullyConnectedEndToEndTestBiasDisabledConnectBias")
720 {
721 FullyConnectedErrorChecking<armnn::DataType::Float32>(defaultBackends, true, false, false, true, true);
722 }
723
724 TEST_CASE("RefGatherFloatTest")
725 {
726 GatherEndToEnd<armnn::DataType::Float32>(defaultBackends);
727 }
728
729 TEST_CASE("RefGatherUint8Test")
730 {
731 GatherEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
732 }
733
734 TEST_CASE("RefGatherInt16Test")
735 {
736 GatherEndToEnd<armnn::DataType::QSymmS16>(defaultBackends);
737 }
738
739 TEST_CASE("RefGatherMultiDimFloatTest")
740 {
741 GatherMultiDimEndToEnd<armnn::DataType::Float32>(defaultBackends);
742 }
743
744 TEST_CASE("RefGatherMultiDimUint8Test")
745 {
746 GatherMultiDimEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
747 }
748
749 TEST_CASE("RefGatherMultiDimInt16Test")
750 {
751 GatherMultiDimEndToEnd<armnn::DataType::QSymmS16>(defaultBackends);
752 }
753
754 TEST_CASE("RefGatherNdFloatTest")
755 {
756 GatherNdEndToEnd<armnn::DataType::Float32>(defaultBackends);
757 }
758
759 TEST_CASE("RefGatherNdUint8Test")
760 {
761 GatherNdEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
762 }
763
764 TEST_CASE("RefGatherNdInt16Test")
765 {
766 GatherNdEndToEnd<armnn::DataType::QSymmS16>(defaultBackends);
767 }
768
769 TEST_CASE("RefGatherNdMultiDimFloatTest")
770 {
771 GatherNdMultiDimEndToEnd<armnn::DataType::Float32>(defaultBackends);
772 }
773
774 TEST_CASE("RefGatherNdMultiDimUint8Test")
775 {
776 GatherNdMultiDimEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
777 }
778
779 TEST_CASE("RefGatherNdMultiDimInt16Test")
780 {
781 GatherNdMultiDimEndToEnd<armnn::DataType::QSymmS16>(defaultBackends);
782 }
783
784 // DepthToSpace
785 TEST_CASE("DephtToSpaceEndToEndNchwFloat32")
786 {
787 DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
788 }
789
790 TEST_CASE("DephtToSpaceEndToEndNchwFloat16")
791 {
792 DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NCHW);
793 }
794
795 TEST_CASE("DephtToSpaceEndToEndNchwUint8")
796 {
797 DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW);
798 }
799
800 TEST_CASE("DephtToSpaceEndToEndNchwInt16")
801 {
802 DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW);
803 }
804
805 TEST_CASE("DephtToSpaceEndToEndNhwcFloat32")
806 {
807 DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
808 }
809
810 TEST_CASE("DephtToSpaceEndToEndNhwcFloat16")
811 {
812 DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NHWC);
813 }
814
815 TEST_CASE("DephtToSpaceEndToEndNhwcUint8")
816 {
817 DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC);
818 }
819
820 TEST_CASE("DephtToSpaceEndToEndNhwcInt16")
821 {
822 DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC);
823 }
824
825 // Dequantize
826 TEST_CASE("DequantizeEndToEndSimpleTest")
827 {
828 DequantizeEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
829 }
830
831 TEST_CASE("DequantizeEndToEndOffsetTest")
832 {
833 DequantizeEndToEndOffset<armnn::DataType::QAsymmU8>(defaultBackends);
834 }
835
836 TEST_CASE("DequantizeEndToEndSimpleInt16Test")
837 {
838 DequantizeEndToEndSimple<armnn::DataType::QSymmS16>(defaultBackends);
839 }
840
841 TEST_CASE("DequantizeEndToEndOffsetInt16Test")
842 {
843 DequantizeEndToEndOffset<armnn::DataType::QSymmS16>(defaultBackends);
844 }
845
846 TEST_CASE("RefDetectionPostProcessRegularNmsTest")
847 {
848 std::vector<float> boxEncodings({
849 0.0f, 0.0f, 0.0f, 0.0f,
850 0.0f, 1.0f, 0.0f, 0.0f,
851 0.0f, -1.0f, 0.0f, 0.0f,
852 0.0f, 0.0f, 0.0f, 0.0f,
853 0.0f, 1.0f, 0.0f, 0.0f,
854 0.0f, 0.0f, 0.0f, 0.0f
855 });
856 std::vector<float> scores({
857 0.0f, 0.9f, 0.8f,
858 0.0f, 0.75f, 0.72f,
859 0.0f, 0.6f, 0.5f,
860 0.0f, 0.93f, 0.95f,
861 0.0f, 0.5f, 0.4f,
862 0.0f, 0.3f, 0.2f
863 });
864 std::vector<float> anchors({
865 0.5f, 0.5f, 1.0f, 1.0f,
866 0.5f, 0.5f, 1.0f, 1.0f,
867 0.5f, 0.5f, 1.0f, 1.0f,
868 0.5f, 10.5f, 1.0f, 1.0f,
869 0.5f, 10.5f, 1.0f, 1.0f,
870 0.5f, 100.5f, 1.0f, 1.0f
871 });
872 DetectionPostProcessRegularNmsEndToEnd<armnn::DataType::Float32>(defaultBackends, boxEncodings, scores, anchors);
873 }
874
QuantizeData(uint8_t * quant,const float * dequant,const TensorInfo & info)875 inline void QuantizeData(uint8_t* quant, const float* dequant, const TensorInfo& info)
876 {
877 for (size_t i = 0; i < info.GetNumElements(); i++)
878 {
879 quant[i] = armnn::Quantize<uint8_t>(dequant[i], info.GetQuantizationScale(), info.GetQuantizationOffset());
880 }
881 }
882
883 TEST_CASE("RefDetectionPostProcessRegularNmsUint8Test")
884 {
885 armnn::TensorInfo boxEncodingsInfo({ 1, 6, 4 }, armnn::DataType::Float32);
886 armnn::TensorInfo scoresInfo({ 1, 6, 3 }, armnn::DataType::Float32);
887 armnn::TensorInfo anchorsInfo({ 6, 4 }, armnn::DataType::Float32);
888
889 boxEncodingsInfo.SetQuantizationScale(1.0f);
890 boxEncodingsInfo.SetQuantizationOffset(1);
891 scoresInfo.SetQuantizationScale(0.01f);
892 scoresInfo.SetQuantizationOffset(0);
893 anchorsInfo.SetQuantizationScale(0.5f);
894 anchorsInfo.SetQuantizationOffset(0);
895
896 std::vector<float> boxEncodings({
897 0.0f, 0.0f, 0.0f, 0.0f,
898 0.0f, 1.0f, 0.0f, 0.0f,
899 0.0f, -1.0f, 0.0f, 0.0f,
900 0.0f, 0.0f, 0.0f, 0.0f,
901 0.0f, 1.0f, 0.0f, 0.0f,
902 0.0f, 0.0f, 0.0f, 0.0f
903 });
904 std::vector<float> scores({
905 0.0f, 0.9f, 0.8f,
906 0.0f, 0.75f, 0.72f,
907 0.0f, 0.6f, 0.5f,
908 0.0f, 0.93f, 0.95f,
909 0.0f, 0.5f, 0.4f,
910 0.0f, 0.3f, 0.2f
911 });
912 std::vector<float> anchors({
913 0.5f, 0.5f, 1.0f, 1.0f,
914 0.5f, 0.5f, 1.0f, 1.0f,
915 0.5f, 0.5f, 1.0f, 1.0f,
916 0.5f, 10.5f, 1.0f, 1.0f,
917 0.5f, 10.5f, 1.0f, 1.0f,
918 0.5f, 100.5f, 1.0f, 1.0f
919 });
920
921 std::vector<uint8_t> qBoxEncodings(boxEncodings.size(), 0);
922 std::vector<uint8_t> qScores(scores.size(), 0);
923 std::vector<uint8_t> qAnchors(anchors.size(), 0);
924 QuantizeData(qBoxEncodings.data(), boxEncodings.data(), boxEncodingsInfo);
925 QuantizeData(qScores.data(), scores.data(), scoresInfo);
926 QuantizeData(qAnchors.data(), anchors.data(), anchorsInfo);
927 DetectionPostProcessRegularNmsEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, qBoxEncodings,
928 qScores, qAnchors,
929 1.0f, 1, 0.01f, 0, 0.5f, 0);
930 }
931
932 TEST_CASE("RefDetectionPostProcessFastNmsTest")
933 {
934 std::vector<float> boxEncodings({
935 0.0f, 0.0f, 0.0f, 0.0f,
936 0.0f, 1.0f, 0.0f, 0.0f,
937 0.0f, -1.0f, 0.0f, 0.0f,
938 0.0f, 0.0f, 0.0f, 0.0f,
939 0.0f, 1.0f, 0.0f, 0.0f,
940 0.0f, 0.0f, 0.0f, 0.0f
941 });
942 std::vector<float> scores({
943 0.0f, 0.9f, 0.8f,
944 0.0f, 0.75f, 0.72f,
945 0.0f, 0.6f, 0.5f,
946 0.0f, 0.93f, 0.95f,
947 0.0f, 0.5f, 0.4f,
948 0.0f, 0.3f, 0.2f
949 });
950 std::vector<float> anchors({
951 0.5f, 0.5f, 1.0f, 1.0f,
952 0.5f, 0.5f, 1.0f, 1.0f,
953 0.5f, 0.5f, 1.0f, 1.0f,
954 0.5f, 10.5f, 1.0f, 1.0f,
955 0.5f, 10.5f, 1.0f, 1.0f,
956 0.5f, 100.5f, 1.0f, 1.0f
957 });
958 DetectionPostProcessFastNmsEndToEnd<armnn::DataType::Float32>(defaultBackends, boxEncodings, scores, anchors);
959 }
960
961 TEST_CASE("RefDetectionPostProcessFastNmsUint8Test")
962 {
963 armnn::TensorInfo boxEncodingsInfo({ 1, 6, 4 }, armnn::DataType::Float32);
964 armnn::TensorInfo scoresInfo({ 1, 6, 3 }, armnn::DataType::Float32);
965 armnn::TensorInfo anchorsInfo({ 6, 4 }, armnn::DataType::Float32);
966
967 boxEncodingsInfo.SetQuantizationScale(1.0f);
968 boxEncodingsInfo.SetQuantizationOffset(1);
969 scoresInfo.SetQuantizationScale(0.01f);
970 scoresInfo.SetQuantizationOffset(0);
971 anchorsInfo.SetQuantizationScale(0.5f);
972 anchorsInfo.SetQuantizationOffset(0);
973
974 std::vector<float> boxEncodings({
975 0.0f, 0.0f, 0.0f, 0.0f,
976 0.0f, 1.0f, 0.0f, 0.0f,
977 0.0f, -1.0f, 0.0f, 0.0f,
978 0.0f, 0.0f, 0.0f, 0.0f,
979 0.0f, 1.0f, 0.0f, 0.0f,
980 0.0f, 0.0f, 0.0f, 0.0f
981 });
982 std::vector<float> scores({
983 0.0f, 0.9f, 0.8f,
984 0.0f, 0.75f, 0.72f,
985 0.0f, 0.6f, 0.5f,
986 0.0f, 0.93f, 0.95f,
987 0.0f, 0.5f, 0.4f,
988 0.0f, 0.3f, 0.2f
989 });
990 std::vector<float> anchors({
991 0.5f, 0.5f, 1.0f, 1.0f,
992 0.5f, 0.5f, 1.0f, 1.0f,
993 0.5f, 0.5f, 1.0f, 1.0f,
994 0.5f, 10.5f, 1.0f, 1.0f,
995 0.5f, 10.5f, 1.0f, 1.0f,
996 0.5f, 100.5f, 1.0f, 1.0f
997 });
998
999 std::vector<uint8_t> qBoxEncodings(boxEncodings.size(), 0);
1000 std::vector<uint8_t> qScores(scores.size(), 0);
1001 std::vector<uint8_t> qAnchors(anchors.size(), 0);
1002 QuantizeData(qBoxEncodings.data(), boxEncodings.data(), boxEncodingsInfo);
1003 QuantizeData(qScores.data(), scores.data(), scoresInfo);
1004 QuantizeData(qAnchors.data(), anchors.data(), anchorsInfo);
1005 DetectionPostProcessFastNmsEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, qBoxEncodings,
1006 qScores, qAnchors,
1007 1.0f, 1, 0.01f, 0, 0.5f, 0);
1008 }
1009
1010 // HardSwish
1011 TEST_CASE("RefHardSwishEndToEndTestFloat32")
1012 {
1013 HardSwishEndToEndTest<armnn::DataType::Float32>(defaultBackends);
1014 }
1015
1016 TEST_CASE("RefHardSwishEndToEndTestFloat16")
1017 {
1018 HardSwishEndToEndTest<armnn::DataType::Float16>(defaultBackends);
1019 }
1020
1021 TEST_CASE("RefHardSwishEndToEndTestQAsymmS8")
1022 {
1023 HardSwishEndToEndTest<armnn::DataType::QAsymmS8>(defaultBackends);
1024 }
1025
1026 TEST_CASE("RefHardSwishEndToEndTestQAsymmU8")
1027 {
1028 HardSwishEndToEndTest<armnn::DataType::QAsymmU8>(defaultBackends);
1029 }
1030
1031 TEST_CASE("RefHardSwishEndToEndTestQSymmS16")
1032 {
1033 HardSwishEndToEndTest<armnn::DataType::QSymmS16>(defaultBackends);
1034 }
1035
1036 // LogSoftmax
1037 TEST_CASE("RefLogSoftmaxEndToEndTest")
1038 {
1039 LogSoftmaxEndToEndTest(defaultBackends);
1040 }
1041
1042 TEST_CASE("RefPreluEndToEndTestFloat32")
1043 {
1044 PreluEndToEndNegativeTest<armnn::DataType::Float32>(defaultBackends);
1045 }
1046
1047 TEST_CASE("RefPreluEndToEndTestUint8")
1048 {
1049 PreluEndToEndPositiveTest<armnn::DataType::QAsymmU8>(defaultBackends);
1050 }
1051
1052 TEST_CASE("RefPreluEndToEndTestQSymm16")
1053 {
1054 PreluEndToEndPositiveTest<armnn::DataType::QSymmS16>(defaultBackends);
1055 }
1056
1057 TEST_CASE("RefSpaceToDepthNhwcEndToEndTest1")
1058 {
1059 SpaceToDepthNhwcEndToEndTest1(defaultBackends);
1060 }
1061
1062 TEST_CASE("RefSpaceToDepthNchwEndToEndTest1")
1063 {
1064 SpaceToDepthNchwEndToEndTest1(defaultBackends);
1065 }
1066
1067 TEST_CASE("RefSpaceToDepthNhwcEndToEndTest2")
1068 {
1069 SpaceToDepthNhwcEndToEndTest2(defaultBackends);
1070 }
1071
1072 TEST_CASE("RefSpaceToDepthNchwEndToEndTest2")
1073 {
1074 SpaceToDepthNchwEndToEndTest2(defaultBackends);
1075 }
1076
1077 TEST_CASE("RefSplitter1dEndToEndTest")
1078 {
1079 Splitter1dEndToEnd<armnn::DataType::Float32>(defaultBackends);
1080 }
1081
1082 TEST_CASE("RefSplitter1dEndToEndUint8Test")
1083 {
1084 Splitter1dEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1085 }
1086
1087 TEST_CASE("RefSplitter2dDim0EndToEndTest")
1088 {
1089 Splitter2dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
1090 }
1091
1092 TEST_CASE("RefSplitter2dDim1EndToEndTest")
1093 {
1094 Splitter2dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
1095 }
1096
1097 TEST_CASE("RefSplitter2dDim0EndToEndUint8Test")
1098 {
1099 Splitter2dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1100 }
1101
1102 TEST_CASE("RefSplitter2dDim1EndToEndUint8Test")
1103 {
1104 Splitter2dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1105 }
1106
1107 TEST_CASE("RefSplitter3dDim0EndToEndTest")
1108 {
1109 Splitter3dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
1110 }
1111
1112 TEST_CASE("RefSplitter3dDim1EndToEndTest")
1113 {
1114 Splitter3dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
1115 }
1116
1117 TEST_CASE("RefSplitter3dDim2EndToEndTest")
1118 {
1119 Splitter3dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
1120 }
1121
1122 TEST_CASE("RefSplitter3dDim0EndToEndUint8Test")
1123 {
1124 Splitter3dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1125 }
1126
1127 TEST_CASE("RefSplitter3dDim1EndToEndUint8Test")
1128 {
1129 Splitter3dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1130 }
1131
1132 TEST_CASE("RefSplitter3dDim2EndToEndUint8Test")
1133 {
1134 Splitter3dDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1135 }
1136
1137 TEST_CASE("RefSplitter4dDim0EndToEndTest")
1138 {
1139 Splitter4dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
1140 }
1141
1142 TEST_CASE("RefSplitter4dDim1EndToEndTest")
1143 {
1144 Splitter4dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
1145 }
1146
1147 TEST_CASE("RefSplitter4dDim2EndToEndTest")
1148 {
1149 Splitter4dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
1150 }
1151
1152 TEST_CASE("RefSplitter4dDim3EndToEndTest")
1153 {
1154 Splitter4dDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
1155 }
1156
1157 TEST_CASE("RefSplitter4dDim0EndToEndUint8Test")
1158 {
1159 Splitter4dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1160 }
1161
1162 TEST_CASE("RefSplitter4dDim1EndToEndUint8Test")
1163 {
1164 Splitter4dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1165 }
1166
1167 TEST_CASE("RefSplitter4dDim2EndToEndUint8Test")
1168 {
1169 Splitter4dDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1170 }
1171
1172 TEST_CASE("RefSplitter4dDim3EndToEndUint8Test")
1173 {
1174 Splitter4dDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1175 }
1176
1177 // TransposeConvolution2d
1178 TEST_CASE("RefTransposeConvolution2dEndToEndFloatNchwTest")
1179 {
1180 TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
1181 defaultBackends, armnn::DataLayout::NCHW);
1182 }
1183
1184 TEST_CASE("RefTransposeConvolution2dEndToEndUint8NchwTest")
1185 {
1186 TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
1187 defaultBackends, armnn::DataLayout::NCHW);
1188 }
1189
1190 TEST_CASE("RefTransposeConvolution2dEndToEndInt16NchwTest")
1191 {
1192 TransposeConvolution2dEndToEnd<armnn::DataType::QSymmS16, armnn::DataType::Signed32>(
1193 defaultBackends, armnn::DataLayout::NCHW);
1194 }
1195
1196 TEST_CASE("RefTransposeConvolution2dEndToEndFloatNhwcTest")
1197 {
1198 TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
1199 defaultBackends, armnn::DataLayout::NHWC);
1200 }
1201
1202 TEST_CASE("RefTransposeConvolution2dEndToEndUint8NhwcTest")
1203 {
1204 TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
1205 defaultBackends, armnn::DataLayout::NHWC);
1206 }
1207
1208 TEST_CASE("RefTransposeConvolution2dEndToEndInt16NhwcTest")
1209 {
1210 TransposeConvolution2dEndToEnd<armnn::DataType::QSymmS16, armnn::DataType::Signed32>(
1211 defaultBackends, armnn::DataLayout::NHWC);
1212 }
1213
1214 // Transpose
1215 TEST_CASE("RefTransposeEndToEndTest")
1216 {
1217 TransposeEndToEnd<armnn::DataType::Float32>(defaultBackends);
1218 }
1219
1220 // Resize Bilinear
1221 TEST_CASE("RefResizeBilinearEndToEndFloatNchwTest")
1222 {
1223 ResizeBilinearEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
1224 }
1225
1226 TEST_CASE("RefResizeBilinearEndToEndUint8NchwTest")
1227 {
1228 ResizeBilinearEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW);
1229 }
1230
1231 TEST_CASE("RefResizeBilinearEndToEndInt16NchwTest")
1232 {
1233 ResizeBilinearEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW);
1234 }
1235
1236 TEST_CASE("RefResizeBilinearEndToEndFloatNhwcTest")
1237 {
1238 ResizeBilinearEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
1239 }
1240
1241 TEST_CASE("RefResizeBilinearEndToEndUint8NhwcTest")
1242 {
1243 ResizeBilinearEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC);
1244 }
1245
1246 TEST_CASE("RefResizeBilinearEndToEndInt16NhwcTest")
1247 {
1248 ResizeBilinearEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC);
1249 }
1250
1251 // Resize NearestNeighbor
1252 TEST_CASE("RefResizeNearestNeighborEndToEndFloatNchwTest")
1253 {
1254 ResizeNearestNeighborEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
1255 }
1256
1257 TEST_CASE("RefResizeNearestNeighborEndToEndUint8NchwTest")
1258 {
1259 ResizeNearestNeighborEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW);
1260 }
1261
1262 TEST_CASE("RefResizeNearestNeighborEndToEndInt16NchwTest")
1263 {
1264 ResizeNearestNeighborEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW);
1265 }
1266
1267 TEST_CASE("RefResizeNearestNeighborEndToEndFloatNhwcTest")
1268 {
1269 ResizeNearestNeighborEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
1270 }
1271
1272 TEST_CASE("RefResizeNearestNeighborEndToEndUint8NhwcTest")
1273 {
1274 ResizeNearestNeighborEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC);
1275 }
1276
1277 TEST_CASE("RefResizeNearestNeighborEndToEndInt16NhwcTest")
1278 {
1279 ResizeNearestNeighborEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC);
1280 }
1281
1282 // InstanceNormalization
1283 TEST_CASE("RefInstanceNormalizationNhwcEndToEndTest1")
1284 {
1285 InstanceNormalizationNhwcEndToEndTest1(defaultBackends);
1286 }
1287
1288 TEST_CASE("RefInstanceNormalizationNchwEndToEndTest1")
1289 {
1290 InstanceNormalizationNchwEndToEndTest1(defaultBackends);
1291 }
1292
1293 TEST_CASE("RefInstanceNormalizationNhwcEndToEndTest2")
1294 {
1295 InstanceNormalizationNhwcEndToEndTest2(defaultBackends);
1296 }
1297
1298 TEST_CASE("RefInstanceNormalizationNchwEndToEndTest2")
1299 {
1300 InstanceNormalizationNchwEndToEndTest2(defaultBackends);
1301 }
1302
1303 // ArgMinMax
1304 TEST_CASE("RefArgMaxSimpleTest")
1305 {
1306 ArgMaxEndToEndSimple<armnn::DataType::Float32>(defaultBackends);
1307 }
1308
1309 TEST_CASE("RefArgMaxSimpleUint8Test")
1310 {
1311 ArgMaxEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
1312 }
1313
1314 TEST_CASE("RefArgMinSimpleTest")
1315 {
1316 ArgMinEndToEndSimple<armnn::DataType::Float32>(defaultBackends);
1317 }
1318
1319 TEST_CASE("RefArgMinSimpleUint8Test")
1320 {
1321 ArgMinEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
1322 }
1323
1324 TEST_CASE("RefArgMaxAxis0Test")
1325 {
1326 ArgMaxAxis0EndToEnd<armnn::DataType::Float32>(defaultBackends);
1327 }
1328
1329 TEST_CASE("RefArgMaxAxis0Uint8Test")
1330 {
1331 ArgMaxAxis0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1332 }
1333
1334 TEST_CASE("RefArgMinAxis0Test")
1335 {
1336 ArgMinAxis0EndToEnd<armnn::DataType::Float32>(defaultBackends);
1337 }
1338
1339 TEST_CASE("RefArgMinAxis0Uint8Test")
1340 {
1341
1342 ArgMinAxis0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1343 }
1344
1345 TEST_CASE("RefArgMaxAxis1Test")
1346 {
1347 ArgMaxAxis1EndToEnd<armnn::DataType::Float32>(defaultBackends);
1348 }
1349
1350 TEST_CASE("RefArgMaxAxis1Uint8Test")
1351 {
1352 ArgMaxAxis1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1353 }
1354
1355 TEST_CASE("RefArgMinAxis1Test")
1356 {
1357 ArgMinAxis1EndToEnd<armnn::DataType::Float32>(defaultBackends);
1358 }
1359
1360 TEST_CASE("RefArgMinAxis1Uint8Test")
1361 {
1362
1363 ArgMinAxis1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1364 }
1365
1366 TEST_CASE("RefArgMaxAxis2Test")
1367 {
1368 ArgMaxAxis2EndToEnd<armnn::DataType::Float32>(defaultBackends);
1369 }
1370
1371 TEST_CASE("RefArgMaxAxis2Uint8Test")
1372 {
1373 ArgMaxAxis2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1374 }
1375
1376 TEST_CASE("RefArgMinAxis2Test")
1377 {
1378 ArgMinAxis2EndToEnd<armnn::DataType::Float32>(defaultBackends);
1379 }
1380
1381 TEST_CASE("RefArgMinAxis2Uint8Test")
1382 {
1383
1384 ArgMinAxis2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1385 }
1386
1387 TEST_CASE("RefArgMaxAxis3Test")
1388 {
1389 ArgMaxAxis3EndToEnd<armnn::DataType::Float32>(defaultBackends);
1390 }
1391
1392 TEST_CASE("RefArgMaxAxis3Uint8Test")
1393 {
1394 ArgMaxAxis3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1395 }
1396
1397 TEST_CASE("RefArgMinAxis3Test")
1398 {
1399 ArgMinAxis3EndToEnd<armnn::DataType::Float32>(defaultBackends);
1400 }
1401
1402 TEST_CASE("RefArgMinAxis3Uint8Test")
1403 {
1404
1405 ArgMinAxis3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
1406 }
1407
1408 TEST_CASE("RefQLstmEndToEndTest")
1409 {
1410 QLstmEndToEnd(defaultBackends);
1411 }
1412
1413 TEST_CASE("RefRankEndToEndTest")
1414 {
1415 RankEndToEnd<armnn::DataType::Float32>(defaultBackends);
1416 }
1417
1418 TEST_CASE("RefRankEndToEndTestFloat16")
1419 {
1420 RankEndToEnd<armnn::DataType::Float16>(defaultBackends);
1421 }
1422
1423 TEST_CASE("RefRankEndToEndTestInt32")
1424 {
1425 RankEndToEnd<armnn::DataType::Signed32>(defaultBackends);
1426 }
1427
1428 TEST_CASE("RefRankEndToEndTestQAsymmS8")
1429 {
1430 RankEndToEnd<armnn::DataType::QAsymmS8>(defaultBackends);
1431 }
1432
1433 TEST_CASE("RefRankEndToEndTestQSymmS16")
1434 {
1435 RankEndToEnd<armnn::DataType::QSymmS16>(defaultBackends);
1436 }
1437
1438 TEST_CASE("RefRankEndToEndTestQSymmS8")
1439 {
1440 RankEndToEnd<armnn::DataType::QSymmS8>(defaultBackends);
1441 }
1442
1443 // Reduce
1444 TEST_CASE("RefReduceEndToEndTest")
1445 {
1446 ReduceEndToEnd<armnn::DataType::Float32>(defaultBackends);
1447 }
1448
1449 TEST_CASE("RefReduceEndToEndTestFloat16")
1450 {
1451 ReduceEndToEnd<armnn::DataType::Float16>(defaultBackends);
1452 }
1453
1454 // Reshape
1455 TEST_CASE("RefReshapeEndToEndTest")
1456 {
1457 ReshapeEndToEnd<armnn::DataType::Float32>(defaultBackends);
1458 }
1459
1460 TEST_CASE("RefReshapeEndToEndTestFloat16")
1461 {
1462 ReshapeEndToEndFloat16<armnn::DataType::Float16>(defaultBackends);
1463 }
1464
1465 TEST_CASE("RefForceImportWithAlignedBuffersEndToEndTest")
1466 {
1467 ForceImportWithAlignedBuffersEndToEndTest(defaultBackends);
1468 }
1469
1470 TEST_CASE("RefForceImportWithMisalignedInputBuffersEndToEndTest")
1471 {
1472 ForceImportWithMisalignedInputBuffersEndToEndTest(defaultBackends);
1473 }
1474
1475 TEST_CASE("RefForceImportWithMisalignedOutputBuffersEndToEndTest")
1476 {
1477 ForceImportWithMisalignedOutputBuffersEndToEndTest(defaultBackends);
1478 }
1479
1480 TEST_CASE("RefForceImportWithMisalignedInputAndOutputBuffersEndToEndTest")
1481 {
1482 ForceImportWithMisalignedInputAndOutputBuffersEndToEndTest(defaultBackends);
1483 }
1484
1485 TEST_CASE("RefForceImportRepeatedInferencesEndToEndTest")
1486 {
1487 ForceImportRepeatedInferencesEndToEndTest(defaultBackends);
1488 }
1489
1490 TEST_CASE("RefForceImportRepeatedInferencesInvertedEndToEndTest")
1491 {
1492 ForceImportRepeatedInferencesInvertedEndToEndTest(defaultBackends);
1493 }
1494
1495 #if !defined(__ANDROID__)
1496 // Only run these tests on non Android platforms
1497 TEST_CASE("RefImportNonAlignedPointerTest")
1498 {
1499 ImportNonAlignedInputPointerTest(defaultBackends);
1500 }
1501
1502 TEST_CASE("RefExportNonAlignedPointerTest")
1503 {
1504 ExportNonAlignedOutputPointerTest(defaultBackends);
1505 }
1506
1507 TEST_CASE("RefImportAlignedPointerTest")
1508 {
1509 ImportAlignedPointerTest(defaultBackends);
1510 }
1511
1512 TEST_CASE("RefImportOnlyWorkload")
1513 {
1514 ImportOnlyWorkload(defaultBackends);
1515 }
1516
1517 TEST_CASE("RefExportOnlyWorkload")
1518 {
1519 ExportOnlyWorkload(defaultBackends);
1520 }
1521
1522 TEST_CASE("RefImportAndExportWorkload")
1523 {
1524 ImportAndExportWorkload(defaultBackends);
1525 }
1526
1527 TEST_CASE("RefExportOutputWithSeveralOutputSlotConnectionsTest")
1528 {
1529 ExportOutputWithSeveralOutputSlotConnectionsTest(defaultBackends);
1530 }
1531
1532 TEST_CASE("RefStridedSliceInvalidSliceEndToEndTest")
1533 {
1534 StridedSliceInvalidSliceEndToEndTest(defaultBackends);
1535 }
1536
1537 TEST_CASE("RefThreadSafeFP32StridedSlicedEndToEndTest")
1538 {
1539 armnn::experimental::StridedSlicedEndToEndTest<armnn::DataType::Float32>(defaultBackends, 1);
1540 }
1541
1542 TEST_CASE("RefAsyncFP32StridedSlicedMultiThreadedEndToEndTest")
1543 {
1544 armnn::experimental::StridedSlicedMultiThreadedEndToEndTest<armnn::DataType::Float32>(defaultBackends);
1545 }
1546
1547 TEST_CASE("RefAsyncFP32StridedSlicedScheduledMultiThreadedEndToEndTest")
1548 {
1549 armnn::experimental::StridedSlicedEndToEndTest<armnn::DataType::Float32>(defaultBackends, 3);
1550 }
1551
1552 TEST_CASE("RefAddEndToEndTestFloat32")
1553 {
1554 ElementwiseBinarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends, BinaryOperation::Add);
1555 }
1556 TEST_CASE("RefAddEndToEndTestUint8")
1557 {
1558 ElementwiseBinarySimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, BinaryOperation::Add);
1559 }
1560 TEST_CASE("RefDivEndToEndTestFloat32")
1561 {
1562 ElementwiseBinarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends, BinaryOperation::Div);
1563 }
1564 TEST_CASE("RefDivEndToEndTestUint8")
1565 {
1566 ElementwiseBinarySimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, BinaryOperation::Div);
1567 }
1568 TEST_CASE("RefMulEndToEndTestFloat32")
1569 {
1570 ElementwiseBinarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends, BinaryOperation::Mul);
1571 }
1572 TEST_CASE("RefMulEndToEndTestUint8")
1573 {
1574 ElementwiseBinarySimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, BinaryOperation::Mul);
1575 }
1576 TEST_CASE("RefSubEndToEndTestFloat32")
1577 {
1578 ElementwiseBinarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends, BinaryOperation::Sub);
1579 }
1580 TEST_CASE("RefSubEndToEndTestUint8")
1581 {
1582 ElementwiseBinarySimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, BinaryOperation::Sub);
1583 }
1584 TEST_CASE("RefMaximumEndToEndTestFloat32")
1585 {
1586 ElementwiseBinarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends, BinaryOperation::Maximum);
1587 }
1588 TEST_CASE("RefMaximumEndToEndTestUint8")
1589 {
1590 ElementwiseBinarySimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, BinaryOperation::Maximum);
1591 }
1592 TEST_CASE("RefMinimumEndToEndTestFloat32")
1593 {
1594 ElementwiseBinarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends, BinaryOperation::Minimum);
1595 }
1596 TEST_CASE("RefMinimumEndToEndTestUint8")
1597 {
1598 ElementwiseBinarySimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, BinaryOperation::Minimum);
1599 }
1600 #endif
1601
1602 }
1603