23 std::initializer_list<unsigned int> expectedDimensions)
25 return CompareTensorHandleShape<IClTensorHandle>(tensorHandle, expectedDimensions);
30 template <armnn::DataType DataType>
31 static void ClCreateActivationWorkloadTest()
35 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
37 auto workload = CreateActivationWorkloadTest<ClActivationWorkload, DataType>(factory, graph);
41 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
42 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
50 ClCreateActivationWorkloadTest<armnn::DataType::Float32>();
55 ClCreateActivationWorkloadTest<armnn::DataType::Float16>();
58 template <
typename WorkloadType,
59 typename DescriptorType,
62 static void ClCreateElementwiseWorkloadTest()
66 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
68 auto workload = CreateElementwiseWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
71 DescriptorType queueDescriptor = workload->GetData();
72 auto inputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
73 auto inputHandle2 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
74 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
152 template <
typename WorkloadType,
153 typename DescriptorType,
159 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
161 auto workload = CreateElementwiseUnaryWorkloadTest<WorkloadType, DescriptorType, DataType>(factory, graph, op);
163 DescriptorType queueDescriptor = workload->GetData();
165 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
166 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
174 ClCreateElementwiseUnaryWorkloadTest<ClRsqrtWorkload, RsqrtQueueDescriptor, armnn::DataType::Float32>(
175 UnaryOperation::Rsqrt);
178 template <
typename BatchNormalizationWorkloadType, armnn::DataType DataType>
179 static void ClCreateBatchNormalizationWorkloadTest(
DataLayout dataLayout)
183 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
185 auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
186 (factory, graph, dataLayout);
190 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
191 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
195 case DataLayout::NHWC:
233 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
235 auto workload = CreateConvertFp16ToFp32WorkloadTest<ClConvertFp16ToFp32Workload>(factory, graph);
238 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
239 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
243 BOOST_TEST((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
244 BOOST_TEST((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
251 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
253 auto workload = CreateConvertFp32ToFp16WorkloadTest<ClConvertFp32ToFp16Workload>(factory, graph);
256 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
257 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
261 BOOST_TEST((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
262 BOOST_TEST((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
265 template <
typename Convolution2dWorkloadType,
typename armnn::DataType DataType>
266 static void ClConvolution2dWorkloadTest(
DataLayout dataLayout)
270 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
272 auto workload = CreateConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory,
276 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 3, 8, 16})
277 : std::initializer_list<unsigned int>({2, 8, 16, 3});
278 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 2, 2, 10})
279 : std::initializer_list<unsigned int>({2, 2, 10, 2});
283 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Inputs[0]);
284 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Outputs[0]);
285 BOOST_TEST((inputHandle->GetShape() == inputShape));
286 BOOST_TEST((outputHandle->GetShape() == outputShape));
291 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
296 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
301 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
306 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
317 {
"FastMathEnabled",
true }
319 modelOptions.push_back(gpuAcc);
322 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager(), modelOptions);
325 CreateConvolution2dWorkloadFastMathTest<ClConvolution2dWorkload, armnn::DataType::Float32>(factory,
331 auto conv2dWorkload = PolymorphicDowncast<ClConvolution2dWorkload*>(workload.get());
334 ARMNN_ASSERT(conv2dWorkload->GetConvolutionMethod() == arm_compute::ConvolutionMethod::WINOGRAD);
337 template <
typename DepthwiseConvolutionWorkloadType,
typename armnn::DataType DataType>
338 static void ClDepthwiseConvolutionWorkloadTest(
DataLayout dataLayout)
342 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
344 auto workload = CreateDepthwiseConvolution2dWorkloadTest<DepthwiseConvolutionWorkloadType, DataType>
345 (factory, graph, dataLayout);
349 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
350 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
352 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 2, 2, 5, 5 })
353 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
354 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 2, 2, 5, 5 })
355 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
357 BOOST_TEST((inputHandle->GetShape() == inputShape));
358 BOOST_TEST((outputHandle->GetShape() == outputShape));
363 ClDepthwiseConvolutionWorkloadTest<ClDepthwiseConvolutionWorkload, DataType::Float32>(DataLayout::NHWC);
366 template <
typename Convolution2dWorkloadType,
typename armnn::DataType DataType>
367 static void ClDirectConvolution2dWorkloadTest()
371 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
373 auto workload = CreateDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory, graph);
377 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
378 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
385 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>();
390 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>();
395 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::QAsymmU8>();
398 template <
typename FullyConnectedWorkloadType,
typename armnn::DataType DataType>
399 static void ClCreateFullyConnectedWorkloadTest()
403 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
406 CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
410 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
411 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
419 ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float32>();
424 ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float16>();
427 template <
typename NormalizationWorkloadType,
typename armnn::DataType DataType>
428 static void ClNormalizationWorkloadTest(
DataLayout dataLayout)
432 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
434 auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
438 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
439 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
441 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 5, 5, 1})
442 : std::initializer_list<unsigned int>({3, 1, 5, 5});
443 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 5, 5, 1})
444 : std::initializer_list<unsigned int>({3, 1, 5, 5});
446 BOOST_TEST((inputHandle->GetShape() == inputShape));
447 BOOST_TEST((outputHandle->GetShape() == outputShape));
452 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
457 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
462 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
467 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
470 template <
typename armnn::DataType DataType>
471 static void ClPooling2dWorkloadTest(
DataLayout dataLayout)
475 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
477 auto workload = CreatePooling2dWorkloadTest<ClPooling2dWorkload, DataType>(factory, graph, dataLayout);
479 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 2, 5, 5})
480 : std::initializer_list<unsigned int>({3, 5, 5, 2});
481 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 2, 2, 4})
482 : std::initializer_list<unsigned int>({3, 2, 4, 2});
486 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Inputs[0]);
487 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Outputs[0]);
489 BOOST_TEST((inputHandle->GetShape() == inputShape));
490 BOOST_TEST((outputHandle->GetShape() == outputShape));
495 ClPooling2dWorkloadTest<armnn::DataType::Float32>(DataLayout::NCHW);
500 ClPooling2dWorkloadTest<armnn::DataType::Float32>(DataLayout::NHWC);
505 ClPooling2dWorkloadTest<armnn::DataType::Float16>(DataLayout::NCHW);
510 ClPooling2dWorkloadTest<armnn::DataType::Float16>(DataLayout::NHWC);
520 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
522 auto workload = CreatePreluWorkloadTest<ClPreluWorkload>(factory,
531 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
532 auto alphaHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
533 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
535 BOOST_TEST((inputHandle->GetShape() == inputShape));
536 BOOST_TEST((alphaHandle->GetShape() == alphaShape));
537 BOOST_TEST((outputHandle->GetShape() == outputShape));
542 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float16);
547 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float32);
552 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::QAsymmU8);
555 template <
typename armnn::DataType DataType>
556 static void ClCreateReshapeWorkloadTest()
560 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
562 auto workload = CreateReshapeWorkloadTest<ClReshapeWorkload, DataType>(factory, graph);
566 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
567 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
575 ClCreateReshapeWorkloadTest<armnn::DataType::Float32>();
580 ClCreateReshapeWorkloadTest<armnn::DataType::Float16>();
585 ClCreateReshapeWorkloadTest<armnn::DataType::QAsymmU8>();
588 template <
typename SoftmaxWorkloadType,
typename armnn::DataType DataType>
589 static void ClSoftmaxWorkloadTest()
593 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
595 auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
599 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
600 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
606 tensorInfo.SetQuantizationScale(1.f / 256);
610 tensorInfo.SetQuantizationOffset(-128);
611 tensorInfo.SetQuantizationScale(1.f / 256);
621 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float32>();
626 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float16>();
631 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmU8>();
636 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmS8>();
639 template <
typename armnn::DataType DataType>
640 static void ClSplitterWorkloadTest()
644 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
646 auto workload = CreateSplitterWorkloadTest<ClSplitterWorkload, DataType>(factory, graph);
650 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
653 auto outputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
656 auto outputHandle2 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[2]);
659 auto outputHandle0 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
665 ClSplitterWorkloadTest<armnn::DataType::Float32>();
670 ClSplitterWorkloadTest<armnn::DataType::Float16>();
673 template <
typename armnn::DataType DataType>
674 static void ClSplitterConcatTest()
684 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
687 CreateSplitterConcatWorkloadTest<ClSplitterWorkload, ClConcatWorkload, DataType>
690 auto wlSplitter = std::move(workloads.first);
691 auto wlConcat = std::move(workloads.second);
705 bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
706 BOOST_TEST(validDataPointers);
710 bool validSubTensorParents = (mIn0->
GetTensor().parent() == mIn1->
GetTensor().parent())
713 BOOST_TEST(validSubTensorParents);
718 ClSplitterConcatTest<armnn::DataType::Float32>();
723 ClSplitterConcatTest<armnn::DataType::Float16>();
734 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
736 std::unique_ptr<ClSplitterWorkload> wlSplitter;
737 std::unique_ptr<ClActivationWorkload> wlActiv0_0;
738 std::unique_ptr<ClActivationWorkload> wlActiv0_1;
739 std::unique_ptr<ClActivationWorkload> wlActiv1_0;
740 std::unique_ptr<ClActivationWorkload> wlActiv1_1;
744 wlActiv1_0, wlActiv1_1);
757 BOOST_TEST(activ0_0Im);
758 BOOST_TEST(activ0_1Im);
759 BOOST_TEST(activ1_0Im);
760 BOOST_TEST(activ1_1Im);
762 bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
763 (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
765 BOOST_TEST(validDataPointers);
768 #if defined(ARMNNREF_ENABLED) 775 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
777 CreateMemCopyWorkloads<IClTensorHandle>(factory);
782 template <
typename L2NormalizationWorkloadType,
typename armnn::DataType DataType>
783 static void ClL2NormalizationWorkloadTest(
DataLayout dataLayout)
787 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
790 CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
794 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
795 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
797 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 5, 20, 50, 67 })
798 : std::initializer_list<unsigned int>({ 5, 50, 67, 20 });
799 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 5, 20, 50, 67 })
800 : std::initializer_list<unsigned int>({ 5, 50, 67, 20 });
802 BOOST_TEST((inputHandle->GetShape() == inputShape));
803 BOOST_TEST((outputHandle->GetShape() == outputShape));
808 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
813 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
818 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
823 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
826 template <
typename LogSoftmaxWorkloadType,
typename armnn::DataType DataType>
827 static void ClCreateLogSoftmaxWorkloadTest()
831 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
833 auto workload = CreateLogSoftmaxWorkloadTest<LogSoftmaxWorkloadType, DataType>(factory, graph);
837 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
838 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
846 ClCreateLogSoftmaxWorkloadTest<ClLogSoftmaxWorkload, armnn::DataType::Float32>();
849 template <
typename LstmWorkloadType>
850 static void ClCreateLstmWorkloadTest()
854 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
856 auto workload = CreateLstmWorkloadTest<LstmWorkloadType>(factory, graph);
859 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
860 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
867 ClCreateLstmWorkloadTest<ClLstmFloatWorkload>();
870 template <
typename ResizeWorkloadType,
typename armnn::DataType DataType>
871 static void ClResizeWorkloadTest(
DataLayout dataLayout)
875 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
877 auto workload = CreateResizeBilinearWorkloadTest<ResizeWorkloadType, DataType>(factory, graph, dataLayout);
879 auto queueDescriptor = workload->GetData();
881 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
882 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
886 case DataLayout::NHWC:
890 case DataLayout::NCHW:
899 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
904 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
909 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
914 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
919 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
924 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
927 template <
typename MeanWorkloadType,
typename armnn::DataType DataType>
928 static void ClMeanWorkloadTest()
932 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
934 auto workload = CreateMeanWorkloadTest<MeanWorkloadType, DataType>(factory, graph);
938 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
939 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
948 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float32>();
953 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float16>();
958 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::QAsymmU8>();
961 template <
typename ConcatWorkloadType, armnn::DataType DataType>
962 static void ClCreateConcatWorkloadTest(std::initializer_list<unsigned int> outputShape,
963 unsigned int concatAxis)
967 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
969 auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis);
972 auto inputHandle0 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
973 auto inputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
974 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
983 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
988 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
993 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
998 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
1003 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
1008 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
1011 template <
typename SpaceToDepthWorkloadType,
typename armnn::DataType DataType>
1012 static void ClSpaceToDepthWorkloadTest()
1016 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1018 auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph);
1021 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1022 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1030 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float32>();
1035 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float16>();
1040 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
1045 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
1048 template <armnn::DataType DataType>
1049 static void ClCreateStackWorkloadTest(
const std::initializer_list<unsigned int>& inputShape,
1050 const std::initializer_list<unsigned int>& outputShape,
1052 unsigned int numInputs)
1056 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1058 auto workload = CreateStackWorkloadTest<ClStackWorkload, DataType>(factory,
1067 for (
unsigned int i = 0; i < numInputs; ++i)
1069 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[i]);
1072 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1078 ClCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1083 ClCreateStackWorkloadTest<armnn::DataType::Float16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1088 ClCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1092 template <
typename QLstmWorkloadType>
1093 static void ClCreateQLstmWorkloadTest()
1096 ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1098 auto workload = CreateQLstmWorkloadTest<QLstmWorkloadType>(factory, graph);
1101 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1103 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1105 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1107 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1109 IAclTensorHandle* outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
1111 BOOST_TEST((outputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1116 ClCreateQLstmWorkloadTest<ClQLstmWorkload>();
1119 template <
typename QuantizedLstmWorkloadType>
1120 static void ClCreateQuantizedLstmWorkloadTest()
1126 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1128 auto workload = CreateQuantizedLstmWorkloadTest<QuantizedLstmWorkloadType>(factory, graph);
1132 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1134 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1136 IAclTensorHandle* cellStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
1138 BOOST_TEST((cellStateInHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1140 IAclTensorHandle* outputStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[2]);
1142 BOOST_TEST((outputStateInHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1144 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
1146 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1148 IAclTensorHandle* outputStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1150 BOOST_TEST((outputStateOutHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1155 ClCreateQuantizedLstmWorkloadTest<ClQuantizedLstmWorkload>();
std::vector< BackendOptions > ModelOptions
BOOST_AUTO_TEST_CASE(CreateActivationFloatWorkload)
void IgnoreUnused(Ts &&...)
virtual arm_compute::DataType GetDataType() const =0
#define ARMNN_ASSERT(COND)
BOOST_AUTO_TEST_CASE(CheckConvolution2dLayer)
virtual TensorShape GetShape() const =0
Get the number of elements for each dimension ordered from slowest iterating dimension to fastest ite...
This layer represents an addition operation.
Struct for the users to pass backend specific options.
BOOST_AUTO_TEST_SUITE_END()
This layer represents a subtraction operation.
std::vector< ITensorHandle * > m_Outputs
boost::test_tools::predicate_result CompareIClTensorHandleShape(IClTensorHandle *tensorHandle, std::initializer_list< unsigned int > expectedDimensions)
This layer represents a division operation.
void SetQuantizationOffset(int32_t offset)
std::vector< ITensorHandle * > m_Inputs
This layer represents a multiplication operation.
arm_compute::CLSubTensor & GetTensor() override