25 std::initializer_list<unsigned int> expectedDimensions)
27 return CompareTensorHandleShape<IClTensorHandle>(tensorHandle, expectedDimensions);
32 template <armnn::DataType DataType>
33 static void ClCreateActivationWorkloadTest()
37 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
39 auto workload = CreateActivationWorkloadTest<ClActivationWorkload, DataType>(factory, graph);
43 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
44 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
52 ClCreateActivationWorkloadTest<armnn::DataType::Float32>();
57 ClCreateActivationWorkloadTest<armnn::DataType::Float16>();
60 template <
typename WorkloadType,
61 typename DescriptorType,
64 static void ClCreateElementwiseWorkloadTest()
68 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
70 auto workload = CreateElementwiseWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
73 DescriptorType queueDescriptor = workload->GetData();
74 auto inputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
75 auto inputHandle2 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
76 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
154 template <
typename WorkloadType,
155 typename DescriptorType,
161 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
163 auto workload = CreateElementwiseUnaryWorkloadTest<WorkloadType, DescriptorType, DataType>(factory, graph, op);
165 DescriptorType queueDescriptor = workload->GetData();
167 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
168 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
176 ClCreateElementwiseUnaryWorkloadTest<ClRsqrtWorkload, RsqrtQueueDescriptor, armnn::DataType::Float32>(
177 UnaryOperation::Rsqrt);
180 template <
typename BatchNormalizationWorkloadType, armnn::DataType DataType>
181 static void ClCreateBatchNormalizationWorkloadTest(
DataLayout dataLayout)
185 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
187 auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
188 (factory, graph, dataLayout);
192 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
193 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
197 case DataLayout::NHWC:
235 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
237 auto workload = CreateConvertFp16ToFp32WorkloadTest<ClConvertFp16ToFp32Workload>(factory, graph);
240 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
241 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
245 BOOST_TEST((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
246 BOOST_TEST((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
253 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
255 auto workload = CreateConvertFp32ToFp16WorkloadTest<ClConvertFp32ToFp16Workload>(factory, graph);
258 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
259 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
263 BOOST_TEST((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
264 BOOST_TEST((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
267 template <
typename Convolution2dWorkloadType,
typename armnn::DataType DataType>
268 static void ClConvolution2dWorkloadTest(
DataLayout dataLayout)
272 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
274 auto workload = CreateConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory,
278 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 3, 8, 16})
279 : std::initializer_list<unsigned int>({2, 8, 16, 3});
280 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 2, 2, 10})
281 : std::initializer_list<unsigned int>({2, 2, 10, 2});
285 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Inputs[0]);
286 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Outputs[0]);
287 BOOST_TEST((inputHandle->GetShape() == inputShape));
288 BOOST_TEST((outputHandle->GetShape() == outputShape));
293 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
298 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
303 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
308 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
319 {
"FastMathEnabled",
true }
321 modelOptions.push_back(gpuAcc);
324 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager(), modelOptions);
327 CreateConvolution2dWorkloadFastMathTest<ClConvolution2dWorkload, armnn::DataType::Float32>(factory,
333 auto conv2dWorkload = PolymorphicDowncast<ClConvolution2dWorkload*>(workload.get());
336 ARMNN_ASSERT(conv2dWorkload->GetConvolutionMethod() == arm_compute::ConvolutionMethod::WINOGRAD);
341 using namespace armnn;
347 TensorInfo inputInfo ({ 1, 3, 1, 2 }, inputType, 0.5f, 128);
348 TensorInfo outputInfo({ 1, 3, 1, 3 }, inputType, 1.0f, 128);
350 const std::vector<float> quantScales{ 0.5f, 0.75f, 1.0f };
351 constexpr
unsigned int quantDimension = 0;
353 TensorInfo kernelInfo({ 3, 1, 1, 2 }, kernelType, quantScales, quantDimension);
355 const std::vector<float> biasQuantScales{ 0.25f, 0.375f, 0.5f };
356 TensorInfo biasInfo({ 3 }, biasType, biasQuantScales, quantDimension);
358 std::vector<uint8_t> inputData =
360 138, 108, 138, 108, 138, 108
363 std::vector<int8_t> kernelData =
368 std::vector<int32_t> biasData =
373 std::vector<uint8_t> expectedOutputData =
375 121, 118, 115, 121, 118, 115, 121, 118, 115
389 auto memoryManager = ClWorkloadFactoryHelper::GetMemoryManager();
390 auto clMemoryManager = armnn::PolymorphicPointerDowncast<armnn::ClMemoryManager>(memoryManager);
391 auto tensorHandleFactory = ClWorkloadFactoryHelper::GetTensorHandleFactory(memoryManager);
393 std::unique_ptr<ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputInfo);
394 std::unique_ptr<ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo);
406 queueDescriptor.m_Weight = &weightTensor;
407 queueDescriptor.m_Bias = &biasTensor;
409 AddInputToWorkload(queueDescriptor, workloadInfo, inputInfo, inputHandle.get());
410 AddOutputToWorkload(queueDescriptor, workloadInfo, outputInfo, outputHandle.get());
413 auto context = arm_compute::CLKernelLibrary::get().context();
414 auto device = arm_compute::CLKernelLibrary::get().get_device();
415 auto clCompileContext = arm_compute::CLCompileContext(context, device);
420 BOOST_TEST(clCompileContext.get_built_programs().empty());
422 auto workload = std::make_unique<ClConvolution2dWorkload>(queueDescriptor,
424 clMemoryManager->GetIntraLayerManager(),
428 BOOST_TEST(!clCompileContext.get_built_programs().empty());
431 template <
typename DepthwiseConvolutionWorkloadType,
typename armnn::DataType DataType>
432 static void ClDepthwiseConvolutionWorkloadTest(
DataLayout dataLayout)
436 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
438 auto workload = CreateDepthwiseConvolution2dWorkloadTest<DepthwiseConvolutionWorkloadType, DataType>
439 (factory, graph, dataLayout);
443 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
444 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
447 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
449 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
451 BOOST_TEST((inputHandle->GetShape() == inputShape));
452 BOOST_TEST((outputHandle->GetShape() == outputShape));
457 ClDepthwiseConvolutionWorkloadTest<ClDepthwiseConvolutionWorkload, DataType::Float32>(
DataLayout::NHWC);
460 template <
typename Convolution2dWorkloadType,
typename armnn::DataType DataType>
461 static void ClDirectConvolution2dWorkloadTest()
465 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
467 auto workload = CreateDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory, graph);
471 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
472 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
479 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>();
484 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>();
489 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::QAsymmU8>();
492 template <
typename FullyConnectedWorkloadType,
typename armnn::DataType DataType>
493 static void ClCreateFullyConnectedWorkloadTest()
497 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
500 CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
504 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
505 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
513 ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float32>();
518 ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float16>();
521 template <
typename NormalizationWorkloadType,
typename armnn::DataType DataType>
522 static void ClNormalizationWorkloadTest(
DataLayout dataLayout)
526 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
528 auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
532 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
533 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
536 : std::initializer_list<unsigned int>({3, 1, 5, 5});
538 : std::initializer_list<unsigned int>({3, 1, 5, 5});
540 BOOST_TEST((inputHandle->GetShape() == inputShape));
541 BOOST_TEST((outputHandle->GetShape() == outputShape));
546 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
551 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(
DataLayout::NCHW);
556 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
561 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(
DataLayout::NHWC);
564 template <
typename armnn::DataType DataType>
565 static void ClPooling2dWorkloadTest(
DataLayout dataLayout)
569 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
571 auto workload = CreatePooling2dWorkloadTest<ClPooling2dWorkload, DataType>(factory, graph, dataLayout);
574 : std::initializer_list<unsigned int>({3, 5, 5, 2});
576 : std::initializer_list<unsigned int>({3, 2, 4, 2});
580 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Inputs[0]);
581 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Outputs[0]);
583 BOOST_TEST((inputHandle->GetShape() == inputShape));
584 BOOST_TEST((outputHandle->GetShape() == outputShape));
614 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
616 auto workload = CreatePreluWorkloadTest<ClPreluWorkload>(factory,
625 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
626 auto alphaHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
627 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
629 BOOST_TEST((inputHandle->GetShape() == inputShape));
630 BOOST_TEST((alphaHandle->GetShape() == alphaShape));
631 BOOST_TEST((outputHandle->GetShape() == outputShape));
636 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float16);
641 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float32);
646 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::QAsymmU8);
649 template <
typename armnn::DataType DataType>
650 static void ClCreateReshapeWorkloadTest()
654 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
656 auto workload = CreateReshapeWorkloadTest<ClReshapeWorkload, DataType>(factory, graph);
660 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
661 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
669 ClCreateReshapeWorkloadTest<armnn::DataType::Float32>();
674 ClCreateReshapeWorkloadTest<armnn::DataType::Float16>();
679 ClCreateReshapeWorkloadTest<armnn::DataType::QAsymmU8>();
682 template <
typename SoftmaxWorkloadType,
typename armnn::DataType DataType>
683 static void ClSoftmaxWorkloadTest()
687 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
689 auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
693 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
694 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
700 tensorInfo.SetQuantizationScale(1.f / 256);
704 tensorInfo.SetQuantizationOffset(-128);
705 tensorInfo.SetQuantizationScale(1.f / 256);
715 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float32>();
720 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float16>();
725 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmU8>();
730 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmS8>();
733 template <
typename armnn::DataType DataType>
734 static void ClSplitterWorkloadTest()
738 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
740 auto workload = CreateSplitterWorkloadTest<ClSplitterWorkload, DataType>(factory, graph);
744 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
747 auto outputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
750 auto outputHandle2 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[2]);
753 auto outputHandle0 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
759 ClSplitterWorkloadTest<armnn::DataType::Float32>();
764 ClSplitterWorkloadTest<armnn::DataType::Float16>();
767 template <
typename armnn::DataType DataType>
768 static void ClSplitterConcatTest()
778 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
781 CreateSplitterConcatWorkloadTest<ClSplitterWorkload, ClConcatWorkload, DataType>
784 auto wlSplitter = std::move(workloads.first);
785 auto wlConcat = std::move(workloads.second);
799 bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
800 BOOST_TEST(validDataPointers);
804 bool validSubTensorParents = (mIn0->
GetTensor().parent() == mIn1->
GetTensor().parent())
807 BOOST_TEST(validSubTensorParents);
812 ClSplitterConcatTest<armnn::DataType::Float32>();
817 ClSplitterConcatTest<armnn::DataType::Float16>();
828 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
830 std::unique_ptr<ClSplitterWorkload> wlSplitter;
831 std::unique_ptr<ClActivationWorkload> wlActiv0_0;
832 std::unique_ptr<ClActivationWorkload> wlActiv0_1;
833 std::unique_ptr<ClActivationWorkload> wlActiv1_0;
834 std::unique_ptr<ClActivationWorkload> wlActiv1_1;
838 wlActiv1_0, wlActiv1_1);
851 BOOST_TEST(activ0_0Im);
852 BOOST_TEST(activ0_1Im);
853 BOOST_TEST(activ1_0Im);
854 BOOST_TEST(activ1_1Im);
856 bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
857 (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
859 BOOST_TEST(validDataPointers);
862 #if defined(ARMNNREF_ENABLED) 869 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
871 CreateMemCopyWorkloads<IClTensorHandle>(factory);
876 template <
typename L2NormalizationWorkloadType,
typename armnn::DataType DataType>
877 static void ClL2NormalizationWorkloadTest(
DataLayout dataLayout)
881 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
884 CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
888 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
889 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
892 : std::initializer_list<unsigned int>({ 5, 50, 67, 20 });
894 : std::initializer_list<unsigned int>({ 5, 50, 67, 20 });
896 BOOST_TEST((inputHandle->GetShape() == inputShape));
897 BOOST_TEST((outputHandle->GetShape() == outputShape));
902 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
907 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
912 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(
DataLayout::NCHW);
917 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(
DataLayout::NHWC);
920 template <
typename LogSoftmaxWorkloadType,
typename armnn::DataType DataType>
921 static void ClCreateLogSoftmaxWorkloadTest()
925 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
927 auto workload = CreateLogSoftmaxWorkloadTest<LogSoftmaxWorkloadType, DataType>(factory, graph);
931 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
932 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
940 ClCreateLogSoftmaxWorkloadTest<ClLogSoftmaxWorkload, armnn::DataType::Float32>();
943 template <
typename LstmWorkloadType>
944 static void ClCreateLstmWorkloadTest()
948 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
950 auto workload = CreateLstmWorkloadTest<LstmWorkloadType>(factory, graph);
953 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
954 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
961 ClCreateLstmWorkloadTest<ClLstmFloatWorkload>();
964 template <
typename ResizeWorkloadType,
typename armnn::DataType DataType>
965 static void ClResizeWorkloadTest(
DataLayout dataLayout)
969 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
971 auto workload = CreateResizeBilinearWorkloadTest<ResizeWorkloadType, DataType>(factory, graph, dataLayout);
973 auto queueDescriptor = workload->GetData();
975 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
976 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
993 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
998 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(
DataLayout::NCHW);
1003 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NCHW);
1008 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
1013 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(
DataLayout::NHWC);
1018 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NHWC);
1021 template <
typename MeanWorkloadType,
typename armnn::DataType DataType>
1022 static void ClMeanWorkloadTest()
1026 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1028 auto workload = CreateMeanWorkloadTest<MeanWorkloadType, DataType>(factory, graph);
1032 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1033 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1042 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float32>();
1047 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float16>();
1052 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::QAsymmU8>();
1055 template <
typename ConcatWorkloadType, armnn::DataType DataType>
1056 static void ClCreateConcatWorkloadTest(std::initializer_list<unsigned int> outputShape,
1057 unsigned int concatAxis)
1061 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1063 auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis);
1066 auto inputHandle0 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1067 auto inputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
1068 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1077 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
1082 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
1087 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
1092 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
1097 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
1102 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
1105 template <
typename SpaceToDepthWorkloadType,
typename armnn::DataType DataType>
1106 static void ClSpaceToDepthWorkloadTest()
1110 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1112 auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph);
1115 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1116 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1124 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float32>();
1129 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float16>();
1134 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
1139 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
1142 template <armnn::DataType DataType>
1143 static void ClCreateStackWorkloadTest(
const std::initializer_list<unsigned int>& inputShape,
1144 const std::initializer_list<unsigned int>& outputShape,
1146 unsigned int numInputs)
1150 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1152 auto workload = CreateStackWorkloadTest<ClStackWorkload, DataType>(factory,
1161 for (
unsigned int i = 0; i < numInputs; ++i)
1163 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[i]);
1166 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1172 ClCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1177 ClCreateStackWorkloadTest<armnn::DataType::Float16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1182 ClCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1186 template <
typename QLstmWorkloadType>
1187 static void ClCreateQLstmWorkloadTest()
1190 ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1192 auto workload = CreateQLstmWorkloadTest<QLstmWorkloadType>(factory, graph);
1195 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1197 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1199 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1201 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1203 IAclTensorHandle* outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
1205 BOOST_TEST((outputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1210 ClCreateQLstmWorkloadTest<ClQLstmWorkload>();
1213 template <
typename QuantizedLstmWorkloadType>
1214 static void ClCreateQuantizedLstmWorkloadTest()
1220 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1222 auto workload = CreateQuantizedLstmWorkloadTest<QuantizedLstmWorkloadType>(factory, graph);
1226 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1228 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1230 IAclTensorHandle* cellStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
1232 BOOST_TEST((cellStateInHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1234 IAclTensorHandle* outputStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[2]);
1236 BOOST_TEST((outputStateInHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1238 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
1240 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1242 IAclTensorHandle* outputStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1244 BOOST_TEST((outputStateOutHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1249 ClCreateQuantizedLstmWorkloadTest<ClQuantizedLstmWorkload>();
uint32_t m_PadBottom
Padding bottom value in the height dimension.
bool m_BiasEnabled
Enable/disable bias.
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
std::vector< BackendOptions > ModelOptions
BOOST_AUTO_TEST_CASE(CreateActivationFloatWorkload)
A Convolution2dDescriptor for the Convolution2dLayer.
uint32_t m_PadRight
Padding right value in the width dimension.
Copyright (c) 2021 ARM Limited and Contributors.
void IgnoreUnused(Ts &&...)
LayerDescriptor m_Parameters
virtual arm_compute::DataType GetDataType() const =0
uint32_t m_PadTop
Padding top value in the height dimension.
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
#define ARMNN_ASSERT(COND)
void AllocateAndCopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)
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...
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
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.
Contains information about inputs and outputs to a layer.
void SetQuantizationOffset(int32_t offset)
std::vector< ITensorHandle * > m_Inputs
This layer represents a multiplication operation.
arm_compute::CLSubTensor & GetTensor() override
uint32_t m_PadLeft
Padding left value in the width dimension.
LayerType
When adding a new layer, adapt also the LastLayer enum value in the enum class LayerType below...