27 #include <doctest/doctest.h> 30 std::initializer_list<unsigned int> expectedDimensions)
32 return CompareTensorHandleShape<IClTensorHandle>(tensorHandle, expectedDimensions);
37 template <armnn::DataType DataType>
38 static void ClCreateActivationWorkloadTest()
42 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
44 auto workload = CreateActivationWorkloadTest<ClActivationWorkload, DataType>(factory, graph);
48 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
49 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
52 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
55 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
60 ClCreateActivationWorkloadTest<armnn::DataType::Float32>();
65 ClCreateActivationWorkloadTest<armnn::DataType::Float16>();
68 template <
typename WorkloadType,
69 typename DescriptorType,
72 static void ClCreateElementwiseWorkloadTest()
76 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
78 auto workload = CreateElementwiseWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
81 DescriptorType queueDescriptor = workload->GetData();
82 auto inputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
83 auto inputHandle2 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
84 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
86 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
88 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
90 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
165 template <
typename WorkloadType,
166 typename DescriptorType,
172 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
174 auto workload = CreateElementwiseUnaryWorkloadTest<WorkloadType, DescriptorType, DataType>(factory, graph, op);
176 DescriptorType queueDescriptor = workload->GetData();
178 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
179 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
182 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
185 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
190 ClCreateElementwiseUnaryWorkloadTest<ClRsqrtWorkload, RsqrtQueueDescriptor, armnn::DataType::Float32>(
191 UnaryOperation::Rsqrt);
194 template <
typename BatchNormalizationWorkloadType, armnn::DataType DataType>
195 static void ClCreateBatchNormalizationWorkloadTest(
DataLayout dataLayout)
199 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
201 auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
202 (factory, graph, dataLayout);
206 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
207 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
212 case DataLayout::NHWC:
214 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
216 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
220 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
222 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
254 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
256 auto workload = CreateConvertFp16ToFp32WorkloadTest<ClConvertFp16ToFp32Workload>(factory, graph);
259 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
260 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
262 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
264 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
265 CHECK((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
266 CHECK((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
273 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
275 auto workload = CreateConvertFp32ToFp16WorkloadTest<ClConvertFp32ToFp16Workload>(factory, graph);
278 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
279 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
282 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
284 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
285 CHECK((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
286 CHECK((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
289 template <
typename Convolution2dWorkloadType,
typename armnn::DataType DataType>
290 static void ClConvolution2dWorkloadTest(
DataLayout dataLayout)
294 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
296 auto workload = CreateConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory,
300 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 3, 8, 16})
301 : std::initializer_list<unsigned int>({2, 8, 16, 3});
302 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 2, 2, 10})
303 : std::initializer_list<unsigned int>({2, 2, 10, 2});
307 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Inputs[0]);
308 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Outputs[0]);
309 CHECK((inputHandle->GetShape() == inputShape));
310 CHECK((outputHandle->GetShape() == outputShape));
315 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
320 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
325 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
330 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
341 {
"FastMathEnabled",
true }
343 modelOptions.push_back(gpuAcc);
346 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager(), modelOptions);
349 CreateConvolution2dWorkloadFastMathTest<ClConvolution2dWorkload, armnn::DataType::Float32>(factory,
355 auto conv2dWorkload = PolymorphicDowncast<ClConvolution2dWorkload*>(workload.get());
358 ARMNN_ASSERT(conv2dWorkload->GetConvolutionMethod() == arm_compute::ConvolutionMethod::WINOGRAD);
367 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
370 CreateConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType::Float32>(factory,
374 TensorShape inputShape = std::initializer_list<unsigned int>({2, 8, 16, 3});
375 TensorShape outputShape = std::initializer_list<unsigned int>({2, 2, 10, 2});
379 auto inputHandle = PolymorphicDowncast<ITensorHandle*>(queueDescriptor.m_Inputs[0]);
380 auto outputHandle = PolymorphicDowncast<ITensorHandle*>(queueDescriptor.m_Outputs[0]);
381 CHECK((inputHandle->GetShape() == inputShape));
382 CHECK((outputHandle->GetShape() == outputShape));
384 CHECK((dynamic_cast<ClTensorHandle*>(inputHandle) !=
nullptr));
385 CHECK((dynamic_cast<ClTensorHandle*>(outputHandle) !=
nullptr));
389 static_cast<MemorySourceFlags>(MemorySource::Malloc));
391 TensorInfo inputInfo({ 2, 8, 16, 3 }, DataType::Float32);
392 TensorInfo outputInfo({ 2, 2, 10, 2 }, DataType::Float32);
400 workload->ReplaceInputTensorHandle(inputImportHandle.get(), 0);
401 workload->ReplaceOutputTensorHandle(outputImportHandle.get(), 0);
404 queueDescriptor = workload->GetData();
405 auto replacedInputHandle = PolymorphicDowncast<ITensorHandle*>(queueDescriptor.m_Inputs[0]);
406 auto replacedOutputHandle = PolymorphicDowncast<ITensorHandle*>(queueDescriptor.m_Outputs[0]);
407 CHECK((replacedInputHandle->GetShape() == inputShape));
408 CHECK((replacedOutputHandle->GetShape() == outputShape));
410 CHECK((inputImportHandle.get() == replacedInputHandle));
411 CHECK((inputImportHandle.get() == replacedInputHandle));
413 CHECK((dynamic_cast<ClTensorHandle*>(replacedInputHandle) ==
nullptr));
414 CHECK((dynamic_cast<ClImportTensorHandle*>(replacedInputHandle) !=
nullptr));
415 CHECK((dynamic_cast<ClTensorHandle*>(replacedOutputHandle) ==
nullptr));
416 CHECK((dynamic_cast<ClImportTensorHandle*>(replacedOutputHandle) !=
nullptr));
421 using namespace armnn;
427 TensorInfo inputInfo ({ 1, 3, 1, 2 }, inputType, 0.5f, 128);
428 TensorInfo outputInfo({ 1, 3, 1, 3 }, inputType, 1.0f, 128);
430 const std::vector<float> quantScales{ 0.5f, 0.75f, 1.0f };
431 constexpr
unsigned int quantDimension = 0;
433 TensorInfo kernelInfo({ 3, 1, 1, 2 }, kernelType, quantScales, quantDimension);
435 const std::vector<float> biasQuantScales{ 0.25f, 0.375f, 0.5f };
436 TensorInfo biasInfo({ 3 }, biasType, biasQuantScales, quantDimension);
438 std::vector<uint8_t> inputData =
440 138, 108, 138, 108, 138, 108
443 std::vector<int8_t> kernelData =
448 std::vector<int32_t> biasData =
453 std::vector<uint8_t> expectedOutputData =
455 121, 118, 115, 121, 118, 115, 121, 118, 115
469 auto memoryManager = ClWorkloadFactoryHelper::GetMemoryManager();
470 auto clMemoryManager = armnn::PolymorphicPointerDowncast<armnn::ClMemoryManager>(memoryManager);
471 auto tensorHandleFactory = ClWorkloadFactoryHelper::GetTensorHandleFactory(memoryManager);
473 std::unique_ptr<ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputInfo);
474 std::unique_ptr<armnn::ITensorHandle> weightsHandle = tensorHandleFactory.CreateTensorHandle(kernelInfo);
475 std::unique_ptr<armnn::ITensorHandle> biasHandle = tensorHandleFactory.CreateTensorHandle(biasInfo);
476 std::unique_ptr<ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo);
488 queueDescriptor.m_Weight = &weightTensor;
489 queueDescriptor.m_Bias = &biasTensor;
491 AddInputToWorkload(queueDescriptor, workloadInfo, inputInfo, inputHandle.get());
492 AddInputToWorkload(queueDescriptor, workloadInfo, kernelInfo, weightsHandle.get());
493 AddInputToWorkload(queueDescriptor, workloadInfo, biasInfo, biasHandle.get());
494 AddOutputToWorkload(queueDescriptor, workloadInfo, outputInfo, outputHandle.get());
497 auto context = arm_compute::CLKernelLibrary::get().context();
498 auto device = arm_compute::CLKernelLibrary::get().get_device();
499 auto clCompileContext = arm_compute::CLCompileContext(context, device);
504 CHECK(clCompileContext.get_built_programs().empty());
506 auto workload = std::make_unique<ClConvolution2dWorkload>(queueDescriptor,
508 clMemoryManager->GetIntraLayerManager(),
512 CHECK(!clCompileContext.get_built_programs().empty());
515 template <
typename DepthwiseConvolutionWorkloadType,
typename armnn::DataType DataType>
516 static void ClDepthwiseConvolutionWorkloadTest(
DataLayout dataLayout)
520 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
522 auto workload = CreateDepthwiseConvolution2dWorkloadTest<DepthwiseConvolutionWorkloadType, DataType>
523 (factory, graph, dataLayout);
527 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
528 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
531 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
533 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
535 CHECK((inputHandle->GetShape() == inputShape));
536 CHECK((outputHandle->GetShape() == outputShape));
541 ClDepthwiseConvolutionWorkloadTest<ClDepthwiseConvolutionWorkload, DataType::Float32>(
DataLayout::NHWC);
544 template <
typename Convolution2dWorkloadType,
typename armnn::DataType DataType>
545 static void ClDirectConvolution2dWorkloadTest()
549 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
551 auto workload = CreateDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory, graph);
555 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
556 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
558 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
560 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
565 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>();
570 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>();
575 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::QAsymmU8>();
578 template <
typename FullyConnectedWorkloadType,
typename armnn::DataType DataType>
579 static void ClCreateFullyConnectedWorkloadTest()
583 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
586 CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
590 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
591 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
593 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
595 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
601 ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float32>();
606 ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float16>();
609 template <
typename NormalizationWorkloadType,
typename armnn::DataType DataType>
610 static void ClNormalizationWorkloadTest(
DataLayout dataLayout)
614 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
616 auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
620 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
621 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
624 : std::initializer_list<unsigned int>({3, 1, 5, 5});
626 : std::initializer_list<unsigned int>({3, 1, 5, 5});
628 CHECK((inputHandle->GetShape() == inputShape));
629 CHECK((outputHandle->GetShape() == outputShape));
634 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
639 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(
DataLayout::NCHW);
644 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
649 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(
DataLayout::NHWC);
652 template <
typename armnn::DataType DataType>
653 static void ClPooling2dWorkloadTest(
DataLayout dataLayout)
657 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
659 auto workload = CreatePooling2dWorkloadTest<ClPooling2dWorkload, DataType>(factory, graph, dataLayout);
662 : std::initializer_list<unsigned int>({3, 5, 5, 2});
664 : std::initializer_list<unsigned int>({3, 2, 4, 2});
668 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Inputs[0]);
669 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Outputs[0]);
671 CHECK((inputHandle->GetShape() == inputShape));
672 CHECK((outputHandle->GetShape() == outputShape));
702 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
704 auto workload = CreatePreluWorkloadTest<ClPreluWorkload>(factory,
713 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
714 auto alphaHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
715 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
717 CHECK((inputHandle->GetShape() == inputShape));
718 CHECK((alphaHandle->GetShape() == alphaShape));
719 CHECK((outputHandle->GetShape() == outputShape));
724 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float16);
729 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::Float32);
734 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
DataType::QAsymmU8);
737 template <
typename armnn::DataType DataType>
738 static void ClCreateReshapeWorkloadTest()
742 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
744 auto workload = CreateReshapeWorkloadTest<ClReshapeWorkload, DataType>(factory, graph);
748 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
749 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
752 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
754 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
759 ClCreateReshapeWorkloadTest<armnn::DataType::Float32>();
764 ClCreateReshapeWorkloadTest<armnn::DataType::Float16>();
769 ClCreateReshapeWorkloadTest<armnn::DataType::QAsymmU8>();
772 template <
typename SoftmaxWorkloadType,
typename armnn::DataType DataType>
773 static void ClSoftmaxWorkloadTest()
777 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
779 auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
783 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
784 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
790 tensorInfo.SetQuantizationScale(1.f / 256);
794 tensorInfo.SetQuantizationOffset(-128);
795 tensorInfo.SetQuantizationScale(1.f / 256);
799 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
801 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
807 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float32>();
812 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float16>();
817 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmU8>();
822 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmS8>();
825 template <
typename armnn::DataType DataType>
826 static void ClSplitterWorkloadTest()
830 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
832 auto workload = CreateSplitterWorkloadTest<ClSplitterWorkload, DataType>(factory, graph);
836 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
838 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
840 auto outputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
842 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
844 auto outputHandle2 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[2]);
846 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
848 auto outputHandle0 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
850 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
855 ClSplitterWorkloadTest<armnn::DataType::Float32>();
860 ClSplitterWorkloadTest<armnn::DataType::Float16>();
863 template <
typename armnn::DataType DataType>
864 static void ClSplitterConcatTest()
874 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
877 CreateSplitterConcatWorkloadTest<ClSplitterWorkload, ClConcatWorkload, DataType>
880 auto wlSplitter = std::move(workloads.first);
881 auto wlConcat = std::move(workloads.second);
895 bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
896 CHECK(validDataPointers);
900 bool validSubTensorParents = (mIn0->
GetTensor().parent() == mIn1->
GetTensor().parent())
903 CHECK(validSubTensorParents);
908 ClSplitterConcatTest<armnn::DataType::Float32>();
913 ClSplitterConcatTest<armnn::DataType::Float16>();
924 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
926 std::unique_ptr<ClSplitterWorkload> wlSplitter;
927 std::unique_ptr<ClActivationWorkload> wlActiv0_0;
928 std::unique_ptr<ClActivationWorkload> wlActiv0_1;
929 std::unique_ptr<ClActivationWorkload> wlActiv1_0;
930 std::unique_ptr<ClActivationWorkload> wlActiv1_1;
934 wlActiv1_0, wlActiv1_1);
952 bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
953 (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
955 CHECK(validDataPointers);
958 #if defined(ARMNNREF_ENABLED) 965 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
967 CreateMemCopyWorkloads<IClTensorHandle>(factory);
972 template <
typename L2NormalizationWorkloadType,
typename armnn::DataType DataType>
973 static void ClL2NormalizationWorkloadTest(
DataLayout dataLayout)
977 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
980 CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
984 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
985 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
988 : std::initializer_list<unsigned int>({ 5, 50, 67, 20 });
990 : std::initializer_list<unsigned int>({ 5, 50, 67, 20 });
992 CHECK((inputHandle->GetShape() == inputShape));
993 CHECK((outputHandle->GetShape() == outputShape));
998 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
1003 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
1008 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(
DataLayout::NCHW);
1013 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(
DataLayout::NHWC);
1016 template <
typename LogSoftmaxWorkloadType,
typename armnn::DataType DataType>
1017 static void ClCreateLogSoftmaxWorkloadTest()
1021 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1023 auto workload = CreateLogSoftmaxWorkloadTest<LogSoftmaxWorkloadType, DataType>(factory, graph);
1027 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1028 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1031 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1033 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1038 ClCreateLogSoftmaxWorkloadTest<ClLogSoftmaxWorkload, armnn::DataType::Float32>();
1041 template <
typename LstmWorkloadType>
1042 static void ClCreateLstmWorkloadTest()
1046 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1048 auto workload = CreateLstmWorkloadTest<LstmWorkloadType>(factory, graph);
1051 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1052 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
1054 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1056 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1061 ClCreateLstmWorkloadTest<ClLstmFloatWorkload>();
1064 template <
typename ResizeWorkloadType,
typename armnn::DataType DataType>
1065 static void ClResizeWorkloadTest(
DataLayout dataLayout)
1069 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1071 auto workload = CreateResizeBilinearWorkloadTest<ResizeWorkloadType, DataType>(factory, graph, dataLayout);
1073 auto queueDescriptor = workload->GetData();
1075 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1076 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1083 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1085 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1089 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1091 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1097 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(
DataLayout::NCHW);
1102 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(
DataLayout::NCHW);
1107 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NCHW);
1112 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(
DataLayout::NHWC);
1117 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(
DataLayout::NHWC);
1122 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(
DataLayout::NHWC);
1125 template <
typename MeanWorkloadType,
typename armnn::DataType DataType>
1126 static void ClMeanWorkloadTest()
1130 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1132 auto workload = CreateMeanWorkloadTest<MeanWorkloadType, DataType>(factory, graph);
1136 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1137 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1141 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1143 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1148 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float32>();
1153 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float16>();
1158 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::QAsymmU8>();
1161 template <
typename ConcatWorkloadType, armnn::DataType DataType>
1162 static void ClCreateConcatWorkloadTest(std::initializer_list<unsigned int> outputShape,
1163 unsigned int concatAxis)
1167 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1169 auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis);
1172 auto inputHandle0 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1173 auto inputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
1174 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1177 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1179 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1181 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1186 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
1191 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
1196 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
1201 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
1206 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
1211 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
1214 template <
typename SpaceToDepthWorkloadType,
typename armnn::DataType DataType>
1215 static void ClSpaceToDepthWorkloadTest()
1219 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1221 auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph);
1224 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
1225 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1228 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1230 CHECK_MESSAGE(predResult.m_Result, predResult.m_Message.str());
1235 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float32>();
1240 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float16>();
1245 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
1250 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
1253 template <armnn::DataType DataType>
1254 static void ClCreateStackWorkloadTest(
const std::initializer_list<unsigned int>& inputShape,
1255 const std::initializer_list<unsigned int>& outputShape,
1257 unsigned int numInputs)
1261 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1263 auto workload = CreateStackWorkloadTest<ClStackWorkload, DataType>(factory,
1272 for (
unsigned int i = 0; i < numInputs; ++i)
1274 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[i]);
1276 CHECK_MESSAGE(predResult1.m_Result, predResult1.m_Message.str());
1278 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1280 CHECK_MESSAGE(predResult2.m_Result, predResult2.m_Message.str());
1285 ClCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1290 ClCreateStackWorkloadTest<armnn::DataType::Float16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1295 ClCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1299 template <
typename QLstmWorkloadType>
1300 static void ClCreateQLstmWorkloadTest()
1303 ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1305 auto workload = CreateQLstmWorkloadTest<QLstmWorkloadType>(factory, graph);
1308 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1310 CHECK((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1312 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1314 CHECK((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1316 IAclTensorHandle* outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
1318 CHECK((outputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1323 ClCreateQLstmWorkloadTest<ClQLstmWorkload>();
1326 template <
typename QuantizedLstmWorkloadType>
1327 static void ClCreateQuantizedLstmWorkloadTest()
1333 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1335 auto workload = CreateQuantizedLstmWorkloadTest<QuantizedLstmWorkloadType>(factory, graph);
1339 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1341 CHECK((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1343 IAclTensorHandle* cellStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
1345 CHECK((cellStateInHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1347 IAclTensorHandle* outputStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[2]);
1349 CHECK((outputStateInHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1351 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
1353 CHECK((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1355 IAclTensorHandle* outputStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1357 CHECK((outputStateOutHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1362 ClCreateQuantizedLstmWorkloadTest<ClQuantizedLstmWorkload>();
1365 template <armnn::DataType DataType>
1366 static void ClCreateActivationWorkloadReplaceFunctionsTest()
1368 std::shared_ptr<ClMemoryManager> memoryManager = std::make_shared<ClMemoryManager>(
1369 std::make_unique<arm_compute::CLBufferAllocator>());
1374 auto workloadPtr = CreateActivationWorkloadTest<ClActivationWorkload, DataType>(factory, graph);
1380 unique_ptr<ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputInfo,
true);
1381 inputHandle->Manage();
1382 inputHandle->Allocate();
1383 unique_ptr<ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputInfo,
true);
1384 outputHandle->Manage();
1385 outputHandle->Allocate();
1387 unsigned int slot = 0;
1389 CHECK_THROWS_AS(workloadPtr->ReplaceOutputTensorHandle(outputHandle.get(), slot),
UnimplementedException);
1392 TEST_CASE(
"ClReplaceFunctionsfromFloat32toFloat16ActivationWorkload")
1394 ClCreateActivationWorkloadReplaceFunctionsTest<armnn::DataType::Float32>();
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
void AllocateAndCopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)
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)
This factory creates ClImportTensorHandles that refer to imported memory tensors. ...
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
std::unique_ptr< ITensorHandle > CreateTensorHandle(const TensorInfo &tensorInfo) const override
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...