21 std::initializer_list<unsigned int> expectedDimensions)
23 return CompareTensorHandleShape<IClTensorHandle>(tensorHandle, expectedDimensions);
28 template <armnn::DataType DataType>
29 static void ClCreateActivationWorkloadTest()
33 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
35 auto workload = CreateActivationWorkloadTest<ClActivationWorkload, DataType>(factory, graph);
39 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
40 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
48 ClCreateActivationWorkloadTest<armnn::DataType::Float32>();
53 ClCreateActivationWorkloadTest<armnn::DataType::Float16>();
56 template <
typename WorkloadType,
57 typename DescriptorType,
60 static void ClCreateElementwiseWorkloadTest()
64 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
66 auto workload = CreateElementwiseWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
69 DescriptorType queueDescriptor = workload->GetData();
70 auto inputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
71 auto inputHandle2 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
72 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
150 template <
typename WorkloadType,
151 typename DescriptorType,
157 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
159 auto workload = CreateElementwiseUnaryWorkloadTest<WorkloadType, DescriptorType, DataType>(factory, graph, op);
161 DescriptorType queueDescriptor = workload->GetData();
163 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
164 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
172 ClCreateElementwiseUnaryWorkloadTest<ClRsqrtWorkload, RsqrtQueueDescriptor, armnn::DataType::Float32>(
173 UnaryOperation::Rsqrt);
176 template <
typename BatchNormalizationWorkloadType, armnn::DataType DataType>
177 static void ClCreateBatchNormalizationWorkloadTest(
DataLayout dataLayout)
181 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
183 auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
184 (factory, graph, dataLayout);
188 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
189 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
193 case DataLayout::NHWC:
231 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
233 auto workload = CreateConvertFp16ToFp32WorkloadTest<ClConvertFp16ToFp32Workload>(factory, graph);
236 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
237 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
241 BOOST_TEST((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
242 BOOST_TEST((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
249 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
251 auto workload = CreateConvertFp32ToFp16WorkloadTest<ClConvertFp32ToFp16Workload>(factory, graph);
254 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
255 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
259 BOOST_TEST((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
260 BOOST_TEST((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
263 template <
typename Convolution2dWorkloadType,
typename armnn::DataType DataType>
264 static void ClConvolution2dWorkloadTest(
DataLayout dataLayout)
268 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
270 auto workload = CreateConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory,
274 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 3, 8, 16})
275 : std::initializer_list<unsigned int>({2, 8, 16, 3});
276 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 2, 2, 10})
277 : std::initializer_list<unsigned int>({2, 2, 10, 2});
281 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Inputs[0]);
282 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Outputs[0]);
283 BOOST_TEST((inputHandle->GetShape() == inputShape));
284 BOOST_TEST((outputHandle->GetShape() == outputShape));
289 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
294 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
299 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
304 ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
307 template <
typename DepthwiseConvolutionWorkloadType,
typename armnn::DataType DataType>
308 static void ClDepthwiseConvolutionWorkloadTest(
DataLayout dataLayout)
312 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
314 auto workload = CreateDepthwiseConvolution2dWorkloadTest<DepthwiseConvolutionWorkloadType, DataType>
315 (factory, graph, dataLayout);
319 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
320 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
322 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 2, 2, 5, 5 })
323 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
324 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 2, 2, 5, 5 })
325 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
327 BOOST_TEST((inputHandle->GetShape() == inputShape));
328 BOOST_TEST((outputHandle->GetShape() == outputShape));
333 ClDepthwiseConvolutionWorkloadTest<ClDepthwiseConvolutionWorkload, DataType::Float32>(DataLayout::NHWC);
336 template <
typename Convolution2dWorkloadType,
typename armnn::DataType DataType>
337 static void ClDirectConvolution2dWorkloadTest()
341 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
343 auto workload = CreateDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, DataType>(factory, graph);
347 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
348 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
355 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>();
360 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>();
365 ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::QAsymmU8>();
368 template <
typename FullyConnectedWorkloadType,
typename armnn::DataType DataType>
369 static void ClCreateFullyConnectedWorkloadTest()
373 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
376 CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
380 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
381 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
389 ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float32>();
394 ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float16>();
397 template <
typename NormalizationWorkloadType,
typename armnn::DataType DataType>
398 static void ClNormalizationWorkloadTest(
DataLayout dataLayout)
402 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
404 auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
408 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
409 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
411 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 5, 5, 1})
412 : std::initializer_list<unsigned int>({3, 1, 5, 5});
413 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 5, 5, 1})
414 : std::initializer_list<unsigned int>({3, 1, 5, 5});
416 BOOST_TEST((inputHandle->GetShape() == inputShape));
417 BOOST_TEST((outputHandle->GetShape() == outputShape));
422 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
427 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
432 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
437 ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
440 template <
typename armnn::DataType DataType>
441 static void ClPooling2dWorkloadTest(
DataLayout dataLayout)
445 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
447 auto workload = CreatePooling2dWorkloadTest<ClPooling2dWorkload, DataType>(factory, graph, dataLayout);
449 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 2, 5, 5})
450 : std::initializer_list<unsigned int>({3, 5, 5, 2});
451 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({3, 2, 2, 4})
452 : std::initializer_list<unsigned int>({3, 2, 4, 2});
456 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Inputs[0]);
457 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.
m_Outputs[0]);
459 BOOST_TEST((inputHandle->GetShape() == inputShape));
460 BOOST_TEST((outputHandle->GetShape() == outputShape));
465 ClPooling2dWorkloadTest<armnn::DataType::Float32>(DataLayout::NCHW);
470 ClPooling2dWorkloadTest<armnn::DataType::Float32>(DataLayout::NHWC);
475 ClPooling2dWorkloadTest<armnn::DataType::Float16>(DataLayout::NCHW);
480 ClPooling2dWorkloadTest<armnn::DataType::Float16>(DataLayout::NHWC);
490 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
492 auto workload = CreatePreluWorkloadTest<ClPreluWorkload>(factory,
501 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
502 auto alphaHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
503 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
505 BOOST_TEST((inputHandle->GetShape() == inputShape));
506 BOOST_TEST((alphaHandle->GetShape() == alphaShape));
507 BOOST_TEST((outputHandle->GetShape() == outputShape));
512 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float16);
517 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float32);
522 ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::QAsymmU8);
525 template <
typename armnn::DataType DataType>
526 static void ClCreateReshapeWorkloadTest()
530 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
532 auto workload = CreateReshapeWorkloadTest<ClReshapeWorkload, DataType>(factory, graph);
536 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
537 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
545 ClCreateReshapeWorkloadTest<armnn::DataType::Float32>();
550 ClCreateReshapeWorkloadTest<armnn::DataType::Float16>();
555 ClCreateReshapeWorkloadTest<armnn::DataType::QAsymmU8>();
558 template <
typename SoftmaxWorkloadType,
typename armnn::DataType DataType>
559 static void ClSoftmaxWorkloadTest()
563 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
565 auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
569 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
570 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
576 tensorInfo.SetQuantizationScale(1.f / 256);
580 tensorInfo.SetQuantizationOffset(-128);
581 tensorInfo.SetQuantizationScale(1.f / 256);
591 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float32>();
596 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float16>();
601 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmU8>();
606 ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmS8>();
609 template <
typename armnn::DataType DataType>
610 static void ClSplitterWorkloadTest()
614 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
616 auto workload = CreateSplitterWorkloadTest<ClSplitterWorkload, DataType>(factory, graph);
620 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
623 auto outputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
626 auto outputHandle2 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[2]);
629 auto outputHandle0 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
635 ClSplitterWorkloadTest<armnn::DataType::Float32>();
640 ClSplitterWorkloadTest<armnn::DataType::Float16>();
643 template <
typename armnn::DataType DataType>
644 static void ClSplitterConcatTest()
654 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
657 CreateSplitterConcatWorkloadTest<ClSplitterWorkload, ClConcatWorkload, DataType>
660 auto wlSplitter = std::move(workloads.first);
661 auto wlConcat = std::move(workloads.second);
675 bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
676 BOOST_TEST(validDataPointers);
680 bool validSubTensorParents = (mIn0->
GetTensor().parent() == mIn1->
GetTensor().parent())
683 BOOST_TEST(validSubTensorParents);
688 ClSplitterConcatTest<armnn::DataType::Float32>();
693 ClSplitterConcatTest<armnn::DataType::Float16>();
704 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
706 std::unique_ptr<ClSplitterWorkload> wlSplitter;
707 std::unique_ptr<ClActivationWorkload> wlActiv0_0;
708 std::unique_ptr<ClActivationWorkload> wlActiv0_1;
709 std::unique_ptr<ClActivationWorkload> wlActiv1_0;
710 std::unique_ptr<ClActivationWorkload> wlActiv1_1;
714 wlActiv1_0, wlActiv1_1);
727 BOOST_TEST(activ0_0Im);
728 BOOST_TEST(activ0_1Im);
729 BOOST_TEST(activ1_0Im);
730 BOOST_TEST(activ1_1Im);
732 bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
733 (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
735 BOOST_TEST(validDataPointers);
738 #if defined(ARMNNREF_ENABLED) 745 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
747 CreateMemCopyWorkloads<IClTensorHandle>(factory);
752 template <
typename L2NormalizationWorkloadType,
typename armnn::DataType DataType>
753 static void ClL2NormalizationWorkloadTest(
DataLayout dataLayout)
757 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
760 CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
764 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
765 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
767 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 5, 20, 50, 67 })
768 : std::initializer_list<unsigned int>({ 5, 50, 67, 20 });
769 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 5, 20, 50, 67 })
770 : std::initializer_list<unsigned int>({ 5, 50, 67, 20 });
772 BOOST_TEST((inputHandle->GetShape() == inputShape));
773 BOOST_TEST((outputHandle->GetShape() == outputShape));
778 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
783 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
788 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
793 ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
796 template <
typename LstmWorkloadType>
797 static void ClCreateLstmWorkloadTest()
801 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
803 auto workload = CreateLstmWorkloadTest<LstmWorkloadType>(factory, graph);
806 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
807 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
814 ClCreateLstmWorkloadTest<ClLstmFloatWorkload>();
817 template <
typename ResizeWorkloadType,
typename armnn::DataType DataType>
818 static void ClResizeWorkloadTest(
DataLayout dataLayout)
822 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
824 auto workload = CreateResizeBilinearWorkloadTest<ResizeWorkloadType, DataType>(factory, graph, dataLayout);
826 auto queueDescriptor = workload->GetData();
828 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
829 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
833 case DataLayout::NHWC:
837 case DataLayout::NCHW:
846 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
851 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
856 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
861 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
866 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
871 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
874 template <
typename MeanWorkloadType,
typename armnn::DataType DataType>
875 static void ClMeanWorkloadTest()
879 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
881 auto workload = CreateMeanWorkloadTest<MeanWorkloadType, DataType>(factory, graph);
885 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
886 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
895 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float32>();
900 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float16>();
905 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::QAsymmU8>();
908 template <
typename ConcatWorkloadType, armnn::DataType DataType>
909 static void ClCreateConcatWorkloadTest(std::initializer_list<unsigned int> outputShape,
910 unsigned int concatAxis)
914 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
916 auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis);
919 auto inputHandle0 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
920 auto inputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
921 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
930 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
935 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
940 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
945 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
950 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
955 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
958 template <
typename SpaceToDepthWorkloadType,
typename armnn::DataType DataType>
959 static void ClSpaceToDepthWorkloadTest()
963 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
965 auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph);
968 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
969 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
977 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float32>();
982 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float16>();
987 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
992 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
995 template <armnn::DataType DataType>
996 static void ClCreateStackWorkloadTest(
const std::initializer_list<unsigned int>& inputShape,
997 const std::initializer_list<unsigned int>& outputShape,
999 unsigned int numInputs)
1003 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1005 auto workload = CreateStackWorkloadTest<ClStackWorkload, DataType>(factory,
1014 for (
unsigned int i = 0; i < numInputs; ++i)
1016 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[i]);
1019 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1025 ClCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1030 ClCreateStackWorkloadTest<armnn::DataType::Float16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1035 ClCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1039 template <
typename QLstmWorkloadType>
1040 static void ClCreateQLstmWorkloadTest()
1043 ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1045 auto workload = CreateQLstmWorkloadTest<QLstmWorkloadType>(factory, graph);
1048 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1050 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1052 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1054 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1056 IAclTensorHandle* outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
1058 BOOST_TEST((outputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1063 ClCreateQLstmWorkloadTest<ClQLstmWorkload>();
1066 template <
typename QuantizedLstmWorkloadType>
1067 static void ClCreateQuantizedLstmWorkloadTest()
1073 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1075 auto workload = CreateQuantizedLstmWorkloadTest<QuantizedLstmWorkloadType>(factory, graph);
1079 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1081 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1083 IAclTensorHandle* cellStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
1085 BOOST_TEST((cellStateInHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1087 IAclTensorHandle* outputStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[2]);
1089 BOOST_TEST((outputStateInHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1091 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
1093 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1095 IAclTensorHandle* outputStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1097 BOOST_TEST((outputStateOutHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1102 ClCreateQuantizedLstmWorkloadTest<ClQuantizedLstmWorkload>();
BOOST_AUTO_TEST_CASE(CreateActivationFloatWorkload)
virtual arm_compute::DataType GetDataType() const =0
BOOST_AUTO_TEST_CASE(CheckConvolution2dLayer)
virtual TensorShape GetShape() const =0
Get the number of elements for each dimension ordered from slowest iterating dimension to fastest ite...
This layer represents an addition operation.
BOOST_AUTO_TEST_SUITE_END()
This layer represents a subtraction operation.
std::vector< ITensorHandle * > m_Outputs
boost::test_tools::predicate_result CompareIClTensorHandleShape(IClTensorHandle *tensorHandle, std::initializer_list< unsigned int > expectedDimensions)
This layer represents a division operation.
void SetQuantizationOffset(int32_t offset)
std::vector< ITensorHandle * > m_Inputs
This layer represents a multiplication operation.
arm_compute::CLSubTensor & GetTensor() override