24 #include <doctest/doctest.h> 27 std::initializer_list<unsigned int> expectedDimensions)
29 return CompareTensorHandleShape<IClTensorHandle>(tensorHandle, expectedDimensions);
34 template <armnn::DataType DataType>
35 static void ClCreateActivationWorkloadTest()
39 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
41 auto workload = CreateActivationWorkloadTest<ClActivationWorkload, DataType>(factory, graph);
45 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
46 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
49 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
52 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
57 ClCreateActivationWorkloadTest<armnn::DataType::Float32>();
62 ClCreateActivationWorkloadTest<armnn::DataType::Float16>();
65 template <
typename WorkloadType,
66 typename DescriptorType,
69 static void ClCreateElementwiseWorkloadTest()
73 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
75 auto workload = CreateElementwiseWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
78 DescriptorType queueDescriptor = workload->GetData();
79 auto inputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
80 auto inputHandle2 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
81 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
83 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
85 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
87 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
162 template <
typename WorkloadType,
163 typename DescriptorType,
169 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
171 auto workload = CreateElementwiseUnaryWorkloadTest<WorkloadType, DescriptorType, DataType>(factory, graph, op);
173 DescriptorType queueDescriptor = workload->GetData();
175 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
176 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
179 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
182 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
187 ClCreateElementwiseUnaryWorkloadTest<ClRsqrtWorkload, RsqrtQueueDescriptor, armnn::DataType::Float32>(
188 UnaryOperation::Rsqrt);
191 template <
typename BatchNormalizationWorkloadType, armnn::DataType DataType>
192 static void ClCreateBatchNormalizationWorkloadTest(
DataLayout dataLayout)
196 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
198 auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
199 (factory, graph, dataLayout);
203 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
204 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
209 case DataLayout::NHWC:
211 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
213 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
217 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
219 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
251 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
253 auto workload = CreateConvertFp16ToFp32WorkloadTest<ClConvertFp16ToFp32Workload>(factory, graph);
256 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
257 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
259 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
261 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
262 CHECK((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
263 CHECK((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
270 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
272 auto workload = CreateConvertFp32ToFp16WorkloadTest<ClConvertFp32ToFp16Workload>(factory, graph);
275 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
276 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
279 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
281 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
282 CHECK((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
283 CHECK((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
286 template <
typename Convolution2dWorkloadType,
typename armnn::DataType DataType>
287 static void ClConvolution2dWorkloadTest(
DataLayout dataLayout)
291 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
293 auto workload = CreateConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory,
297 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 3, 8, 16})
298 : std::initializer_list<unsigned int>({2, 8, 16, 3});
299 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 2, 2, 10})
300 : std::initializer_list<unsigned int>({2, 2, 10, 2});
304 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Inputs[0]);
305 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Outputs[0]);
306 CHECK((inputHandle->GetShape() == inputShape));
307 CHECK((outputHandle->GetShape() == outputShape));
312 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
317 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
322 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
327 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
338 {
"FastMathEnabled",
true }
340 modelOptions.push_back(gpuAcc);
343 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager(), modelOptions);
346 CreateConvolution2dWorkloadFastMathTest<ClConvolution2dWorkload, armnn::DataType::Float32>(factory,
352 auto conv2dWorkload = PolymorphicDowncast<ClConvolution2dWorkload*>(workload.get());
355 ARMNN_ASSERT(conv2dWorkload->GetConvolutionMethod() == arm_compute::ConvolutionMethod::WINOGRAD);
360 using namespace armnn;
366 TensorInfo inputInfo ({ 1, 3, 1, 2 }, inputType, 0.5f, 128);
367 TensorInfo outputInfo({ 1, 3, 1, 3 }, inputType, 1.0f, 128);
369 const std::vector<float> quantScales{ 0.5f, 0.75f, 1.0f };
370 constexpr
unsigned int quantDimension = 0;
372 TensorInfo kernelInfo({ 3, 1, 1, 2 }, kernelType, quantScales, quantDimension);
374 const std::vector<float> biasQuantScales{ 0.25f, 0.375f, 0.5f };
375 TensorInfo biasInfo({ 3 }, biasType, biasQuantScales, quantDimension);
377 std::vector<uint8_t> inputData =
379 138, 108, 138, 108, 138, 108
382 std::vector<int8_t> kernelData =
387 std::vector<int32_t> biasData =
392 std::vector<uint8_t> expectedOutputData =
394 121, 118, 115, 121, 118, 115, 121, 118, 115
408 auto memoryManager = ClWorkloadFactoryHelper::GetMemoryManager();
409 auto clMemoryManager = armnn::PolymorphicPointerDowncast<armnn::ClMemoryManager>(memoryManager);
410 auto tensorHandleFactory = ClWorkloadFactoryHelper::GetTensorHandleFactory(memoryManager);
412 std::unique_ptr<ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputInfo);
413 std::unique_ptr<ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo);
425 queueDescriptor.m_Weight = &weightTensor;
426 queueDescriptor.m_Bias = &biasTensor;
428 AddInputToWorkload(queueDescriptor, workloadInfo, inputInfo, inputHandle.get());
429 AddOutputToWorkload(queueDescriptor, workloadInfo, outputInfo, outputHandle.get());
432 auto context = arm_compute::CLKernelLibrary::get().context();
433 auto device = arm_compute::CLKernelLibrary::get().get_device();
434 auto clCompileContext = arm_compute::CLCompileContext(context, device);
439 CHECK(clCompileContext.get_built_programs().empty());
441 auto workload = std::make_unique<ClConvolution2dWorkload>(queueDescriptor,
443 clMemoryManager->GetIntraLayerManager(),
447 CHECK(!clCompileContext.get_built_programs().empty());
450 template <
typename DepthwiseConvolutionWorkloadType,
typename armnn::DataType DataType>
451 static void ClDepthwiseConvolutionWorkloadTest(
DataLayout dataLayout)
455 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
457 auto workload = CreateDepthwiseConvolution2dWorkloadTest<DepthwiseConvolutionWorkloadType, DataType>
458 (factory, graph, dataLayout);
462 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
463 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
466 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
468 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
470 CHECK((inputHandle->GetShape() == inputShape));
471 CHECK((outputHandle->GetShape() == outputShape));
476 ClDepthwiseConvolutionWorkloadTest<ClDepthwiseConvolutionWorkload, DataType::Float32>(
DataLayout::NHWC);
479 template <
typename Convolution2dWorkloadType,
typename armnn::DataType DataType>
480 static void ClDirectConvolution2dWorkloadTest()
484 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
486 auto workload = CreateDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory, graph);
490 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
491 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
493 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
495 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
500 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>();
505 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>();
510 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::QAsymmU8>();
513 template <
typename FullyConnectedWorkloadType,
typename armnn::DataType DataType>
514 static void ClCreateFullyConnectedWorkloadTest()
518 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
521 CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
525 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
526 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
528 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
530 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
536 ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float32>();
541 ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float16>();
544 template <
typename NormalizationWorkloadType,
typename armnn::DataType DataType>
545 static void ClNormalizationWorkloadTest(
DataLayout dataLayout)
549 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
551 auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
555 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
556 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
559 : std::initializer_list<unsigned int>({3, 1, 5, 5});
561 : std::initializer_list<unsigned int>({3, 1, 5, 5});
563 CHECK((inputHandle->GetShape() == inputShape));
564 CHECK((outputHandle->GetShape() == outputShape));
569 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
574 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(
DataLayout::NCHW);
579 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
584 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(
DataLayout::NHWC);
587 template <
typename armnn::DataType DataType>
588 static void ClPooling2dWorkloadTest(
DataLayout dataLayout)
592 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
594 auto workload = CreatePooling2dWorkloadTest<ClPooling2dWorkload, DataType>(factory, graph, dataLayout);
597 : std::initializer_list<unsigned int>({3, 5, 5, 2});
599 : std::initializer_list<unsigned int>({3, 2, 4, 2});
603 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Inputs[0]);
604 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Outputs[0]);
606 CHECK((inputHandle->GetShape() == inputShape));
607 CHECK((outputHandle->GetShape() == outputShape));
637 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
639 auto workload = CreatePreluWorkloadTest<ClPreluWorkload>(factory,
648 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
649 auto alphaHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
650 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
652 CHECK((inputHandle->GetShape() == inputShape));
653 CHECK((alphaHandle->GetShape() == alphaShape));
654 CHECK((outputHandle->GetShape() == outputShape));
659 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float16);
664 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float32);
669 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::QAsymmU8);
672 template <
typename armnn::DataType DataType>
673 static void ClCreateReshapeWorkloadTest()
677 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
679 auto workload = CreateReshapeWorkloadTest<ClReshapeWorkload, DataType>(factory, graph);
683 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
684 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
687 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
689 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
694 ClCreateReshapeWorkloadTest<armnn::DataType::Float32>();
699 ClCreateReshapeWorkloadTest<armnn::DataType::Float16>();
704 ClCreateReshapeWorkloadTest<armnn::DataType::QAsymmU8>();
707 template <
typename SoftmaxWorkloadType,
typename armnn::DataType DataType>
708 static void ClSoftmaxWorkloadTest()
712 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
714 auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
718 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
719 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
725 tensorInfo.SetQuantizationScale(1.f / 256);
729 tensorInfo.SetQuantizationOffset(-128);
730 tensorInfo.SetQuantizationScale(1.f / 256);
734 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
736 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
742 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float32>();
747 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float16>();
752 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmU8>();
757 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmS8>();
760 template <
typename armnn::DataType DataType>
761 static void ClSplitterWorkloadTest()
765 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
767 auto workload = CreateSplitterWorkloadTest<ClSplitterWorkload, DataType>(factory, graph);
771 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
773 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
775 auto outputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
777 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
779 auto outputHandle2 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[2]);
781 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
783 auto outputHandle0 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
785 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
790 ClSplitterWorkloadTest<armnn::DataType::Float32>();
795 ClSplitterWorkloadTest<armnn::DataType::Float16>();
798 template <
typename armnn::DataType DataType>
799 static void ClSplitterConcatTest()
809 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
812 CreateSplitterConcatWorkloadTest<ClSplitterWorkload, ClConcatWorkload, DataType>
815 auto wlSplitter = std::move(workloads.first);
816 auto wlConcat = std::move(workloads.second);
830 bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
831 CHECK(validDataPointers);
835 bool validSubTensorParents = (mIn0->
GetTensor().parent() == mIn1->
GetTensor().parent())
838 CHECK(validSubTensorParents);
843 ClSplitterConcatTest<armnn::DataType::Float32>();
848 ClSplitterConcatTest<armnn::DataType::Float16>();
859 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
861 std::unique_ptr<ClSplitterWorkload> wlSplitter;
862 std::unique_ptr<ClActivationWorkload> wlActiv0_0;
863 std::unique_ptr<ClActivationWorkload> wlActiv0_1;
864 std::unique_ptr<ClActivationWorkload> wlActiv1_0;
865 std::unique_ptr<ClActivationWorkload> wlActiv1_1;
869 wlActiv1_0, wlActiv1_1);
887 bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
888 (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
890 CHECK(validDataPointers);
893 #if defined(ARMNNREF_ENABLED) 900 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
902 CreateMemCopyWorkloads<IClTensorHandle>(factory);
907 template <
typename L2NormalizationWorkloadType,
typename armnn::DataType DataType>
908 static void ClL2NormalizationWorkloadTest(
DataLayout dataLayout)
912 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
915 CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
919 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
920 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
923 : std::initializer_list<unsigned int>({ 5, 50, 67, 20 });
925 : std::initializer_list<unsigned int>({ 5, 50, 67, 20 });
927 CHECK((inputHandle->GetShape() == inputShape));
928 CHECK((outputHandle->GetShape() == outputShape));
933 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
938 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
943 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(
DataLayout::NCHW);
948 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(
DataLayout::NHWC);
951 template <
typename LogSoftmaxWorkloadType,
typename armnn::DataType DataType>
952 static void ClCreateLogSoftmaxWorkloadTest()
956 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
958 auto workload = CreateLogSoftmaxWorkloadTest<LogSoftmaxWorkloadType, DataType>(factory, graph);
962 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
963 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
966 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
968 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
973 ClCreateLogSoftmaxWorkloadTest<ClLogSoftmaxWorkload, armnn::DataType::Float32>();
976 template <
typename LstmWorkloadType>
977 static void ClCreateLstmWorkloadTest()
981 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
983 auto workload = CreateLstmWorkloadTest<LstmWorkloadType>(factory, graph);
986 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
987 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
989 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
991 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
996 ClCreateLstmWorkloadTest<ClLstmFloatWorkload>();
999 template <
typename ResizeWorkloadType,
typename armnn::DataType DataType>
1000 static void ClResizeWorkloadTest(
DataLayout dataLayout)
1004 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1006 auto workload = CreateResizeBilinearWorkloadTest<ResizeWorkloadType, DataType>(factory, graph, dataLayout);
1008 auto queueDescriptor = workload->GetData();
1010 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1011 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1018 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1020 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1024 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1026 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1032 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
1037 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(
DataLayout::NCHW);
1042 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NCHW);
1047 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
1052 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(
DataLayout::NHWC);
1057 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NHWC);
1060 template <
typename MeanWorkloadType,
typename armnn::DataType DataType>
1061 static void ClMeanWorkloadTest()
1065 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1067 auto workload = CreateMeanWorkloadTest<MeanWorkloadType, DataType>(factory, graph);
1071 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1072 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1076 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1078 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1083 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float32>();
1088 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float16>();
1093 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::QAsymmU8>();
1096 template <
typename ConcatWorkloadType, armnn::DataType DataType>
1097 static void ClCreateConcatWorkloadTest(std::initializer_list<unsigned int> outputShape,
1098 unsigned int concatAxis)
1102 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1104 auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis);
1107 auto inputHandle0 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1108 auto inputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
1109 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1112 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1114 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1116 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1121 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
1126 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
1131 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
1136 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
1141 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
1146 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
1149 template <
typename SpaceToDepthWorkloadType,
typename armnn::DataType DataType>
1150 static void ClSpaceToDepthWorkloadTest()
1154 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1156 auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph);
1159 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1160 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1163 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1165 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1170 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float32>();
1175 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float16>();
1180 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
1185 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
1188 template <armnn::DataType DataType>
1189 static void ClCreateStackWorkloadTest(
const std::initializer_list<unsigned int>& inputShape,
1190 const std::initializer_list<unsigned int>& outputShape,
1192 unsigned int numInputs)
1196 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1198 auto workload = CreateStackWorkloadTest<ClStackWorkload, DataType>(factory,
1207 for (
unsigned int i = 0; i < numInputs; ++i)
1209 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[i]);
1211 CHECK_MESSAGE(predResult1.m_Result, predResult1.m_Message.str());
1213 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1215 CHECK_MESSAGE(predResult2.m_Result, predResult2.m_Message.str());
1220 ClCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1225 ClCreateStackWorkloadTest<armnn::DataType::Float16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1230 ClCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1234 template <
typename QLstmWorkloadType>
1235 static void ClCreateQLstmWorkloadTest()
1238 ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1240 auto workload = CreateQLstmWorkloadTest<QLstmWorkloadType>(factory, graph);
1243 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1245 CHECK((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1247 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1249 CHECK((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1251 IAclTensorHandle* outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
1253 CHECK((outputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1258 ClCreateQLstmWorkloadTest<ClQLstmWorkload>();
1261 template <
typename QuantizedLstmWorkloadType>
1262 static void ClCreateQuantizedLstmWorkloadTest()
1268 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1270 auto workload = CreateQuantizedLstmWorkloadTest<QuantizedLstmWorkloadType>(factory, graph);
1274 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1276 CHECK((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1278 IAclTensorHandle* cellStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
1280 CHECK((cellStateInHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1282 IAclTensorHandle* outputStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[2]);
1284 CHECK((outputStateInHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1286 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
1288 CHECK((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1290 IAclTensorHandle* outputStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1292 CHECK((outputStateOutHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1297 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).
armnn::PredicateResult CompareIClTensorHandleShape(IClTensorHandle *tensorHandle, std::initializer_list< unsigned int > expectedDimensions)
TEST_SUITE("CreateWorkloadCl")
std::vector< BackendOptions > ModelOptions
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.
TEST_CASE_FIXTURE(ClContextControlFixture, "CopyBetweenNeonAndGpu")
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)
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.
This layer represents a subtraction operation.
std::vector< ITensorHandle * > m_Outputs
This layer represents a division operation.
Contains information about TensorInfos of a layer.
void SetQuantizationOffset(int32_t offset)
std::vector< ITensorHandle * > m_Inputs
This layer represents a multiplication operation.
arm_compute::CLSubTensor & GetTensor() override
Depthwise Convolution 2D layer workload data.
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...