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 LogSoftmaxWorkloadType,
typename armnn::DataType DataType>
797 static void ClCreateLogSoftmaxWorkloadTest()
801 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
803 auto workload = CreateLogSoftmaxWorkloadTest<LogSoftmaxWorkloadType, DataType>(factory, graph);
807 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
808 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
816 ClCreateLogSoftmaxWorkloadTest<ClLogSoftmaxWorkload, armnn::DataType::Float32>();
819 template <
typename LstmWorkloadType>
820 static void ClCreateLstmWorkloadTest()
824 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
826 auto workload = CreateLstmWorkloadTest<LstmWorkloadType>(factory, graph);
829 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
830 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[1]);
837 ClCreateLstmWorkloadTest<ClLstmFloatWorkload>();
840 template <
typename ResizeWorkloadType,
typename armnn::DataType DataType>
841 static void ClResizeWorkloadTest(
DataLayout dataLayout)
845 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
847 auto workload = CreateResizeBilinearWorkloadTest<ResizeWorkloadType, DataType>(factory, graph, dataLayout);
849 auto queueDescriptor = workload->GetData();
851 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
852 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
856 case DataLayout::NHWC:
860 case DataLayout::NCHW:
869 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
874 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
879 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
884 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
889 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
894 ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
897 template <
typename MeanWorkloadType,
typename armnn::DataType DataType>
898 static void ClMeanWorkloadTest()
902 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
904 auto workload = CreateMeanWorkloadTest<MeanWorkloadType, DataType>(factory, graph);
908 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
909 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
918 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float32>();
923 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float16>();
928 ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::QAsymmU8>();
931 template <
typename ConcatWorkloadType, armnn::DataType DataType>
932 static void ClCreateConcatWorkloadTest(std::initializer_list<unsigned int> outputShape,
933 unsigned int concatAxis)
937 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
939 auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis);
942 auto inputHandle0 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
943 auto inputHandle1 = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[1]);
944 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
953 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
958 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
963 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
968 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
973 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
978 ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
981 template <
typename SpaceToDepthWorkloadType,
typename armnn::DataType DataType>
982 static void ClSpaceToDepthWorkloadTest()
986 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
988 auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph);
991 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
992 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1000 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float32>();
1005 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float16>();
1010 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
1015 ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
1018 template <armnn::DataType DataType>
1019 static void ClCreateStackWorkloadTest(
const std::initializer_list<unsigned int>& inputShape,
1020 const std::initializer_list<unsigned int>& outputShape,
1022 unsigned int numInputs)
1026 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1028 auto workload = CreateStackWorkloadTest<ClStackWorkload, DataType>(factory,
1037 for (
unsigned int i = 0; i < numInputs; ++i)
1039 auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[i]);
1042 auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
1048 ClCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1053 ClCreateStackWorkloadTest<armnn::DataType::Float16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1058 ClCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1062 template <
typename QLstmWorkloadType>
1063 static void ClCreateQLstmWorkloadTest()
1066 ClWorkloadFactory factory = ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1068 auto workload = CreateQLstmWorkloadTest<QLstmWorkloadType>(factory, graph);
1071 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1073 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1075 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1077 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1079 IAclTensorHandle* outputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
1081 BOOST_TEST((outputHandle->
GetDataType() == arm_compute::DataType::QASYMM8_SIGNED));
1086 ClCreateQLstmWorkloadTest<ClQLstmWorkload>();
1089 template <
typename QuantizedLstmWorkloadType>
1090 static void ClCreateQuantizedLstmWorkloadTest()
1096 ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
1098 auto workload = CreateQuantizedLstmWorkloadTest<QuantizedLstmWorkloadType>(factory, graph);
1102 IAclTensorHandle* inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
1104 BOOST_TEST((inputHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1106 IAclTensorHandle* cellStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[1]);
1108 BOOST_TEST((cellStateInHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1110 IAclTensorHandle* outputStateInHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[2]);
1112 BOOST_TEST((outputStateInHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1114 IAclTensorHandle* cellStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
1116 BOOST_TEST((cellStateOutHandle->
GetDataType() == arm_compute::DataType::QSYMM16));
1118 IAclTensorHandle* outputStateOutHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
1120 BOOST_TEST((outputStateOutHandle->
GetDataType() == arm_compute::DataType::QASYMM8));
1125 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