16 template<
typename Workload>
17 void CheckInputOutput(std::unique_ptr<Workload> workload,
const TensorInfo& inputInfo,
const TensorInfo& outputInfo)
19 auto queueDescriptor = workload->GetData();
20 auto inputHandle = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Inputs[0]);
21 auto outputHandle = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Outputs[0]);
22 BOOST_TEST((inputHandle->GetTensorInfo() == inputInfo));
23 BOOST_TEST((outputHandle->GetTensorInfo() == outputInfo));
26 template <
typename Workload>
27 void CheckInputsOutput(std::unique_ptr<Workload> workload,
32 auto queueDescriptor = workload->GetData();
33 auto inputHandle0 = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Inputs[0]);
34 auto inputHandle1 = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Inputs[1]);
35 auto outputHandle = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Outputs[0]);
36 BOOST_TEST((inputHandle0->GetTensorInfo() == inputInfo0));
37 BOOST_TEST((inputHandle1->GetTensorInfo() == inputInfo1));
38 BOOST_TEST((outputHandle->GetTensorInfo() == outputInfo));
43 std::shared_ptr<RefMemoryManager> memoryManager = std::make_shared<RefMemoryManager>();
52 template <
typename ActivationWorkloadType, armnn::DataType DataType>
53 static void RefCreateActivationWorkloadTest()
57 auto workload = CreateActivationWorkloadTest<ActivationWorkloadType, DataType>(factory, graph);
60 CheckInputOutput(std::move(workload),
67 RefCreateActivationWorkloadTest<RefActivationWorkload, armnn::DataType::Float32>();
72 RefCreateActivationWorkloadTest<RefActivationWorkload, armnn::DataType::QAsymmU8>();
75 template <
typename WorkloadType,
76 typename DescriptorType,
79 static void RefCreateElementwiseWorkloadTest()
83 auto workload = CreateElementwiseWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(
86 CheckInputsOutput(std::move(workload),
98 auto workload = CreateSubtractionWithBlobWorkloadTest<RefSubtractionWorkload<>,
103 CheckInputsOutput(std::move(workload),
115 auto workload = CreateAdditionWithBlobWorkloadTest<RefAdditionWorkload<>,
119 CheckInputsOutput(std::move(workload),
131 auto workload = CreateMultiplicationWithBlobWorkloadTest<RefMultiplicationWorkload<>,
135 CheckInputsOutput(std::move(workload),
143 RefCreateElementwiseWorkloadTest<RefAdditionWorkload<>,
151 RefCreateElementwiseWorkloadTest<RefAdditionWorkload<>,
159 RefCreateElementwiseWorkloadTest<RefAdditionWorkload<>,
167 RefCreateElementwiseWorkloadTest<RefAdditionWorkload<int32_t>,
175 RefCreateElementwiseWorkloadTest<RefSubtractionWorkload<>,
183 RefCreateElementwiseWorkloadTest<RefSubtractionWorkload<>,
191 RefCreateElementwiseWorkloadTest<RefSubtractionWorkload<>,
199 RefCreateElementwiseWorkloadTest<RefSubtractionWorkload<>,
207 RefCreateElementwiseWorkloadTest<RefSubtractionWorkload<int32_t>,
215 RefCreateElementwiseWorkloadTest<RefMultiplicationWorkload<>,
223 RefCreateElementwiseWorkloadTest<RefMultiplicationWorkload<>,
231 RefCreateElementwiseWorkloadTest<RefMultiplicationWorkload<>,
239 RefCreateElementwiseWorkloadTest<RefMultiplicationWorkload<int32_t>,
247 RefCreateElementwiseWorkloadTest<RefDivisionWorkload<>,
255 RefCreateElementwiseWorkloadTest<RefDivisionWorkload<>,
263 RefCreateElementwiseWorkloadTest<RefDivisionWorkload<>,
271 RefCreateElementwiseWorkloadTest<RefDivisionWorkload<>,
279 RefCreateElementwiseWorkloadTest<RefDivisionWorkload<int32_t>,
285 template <
typename BatchNormalizationWorkloadType, armnn::DataType DataType>
286 static void RefCreateBatchNormalizationWorkloadTest(
DataLayout dataLayout)
290 auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>(factory,
299 case DataLayout::NHWC:
300 inputShape = { 2, 4, 4, 3 };
301 outputShape = { 2, 4, 4, 3 };
303 case DataLayout::NCHW:
305 inputShape = { 2, 3, 4, 4 };
306 outputShape = { 2, 3, 4, 4 };
325 inputShape = { 2, 4, 4, 3 };
326 outputShape = { 2, 4, 4, 3 };
329 CheckInputOutput(std::move(workload),
TensorInfo(inputShape, dataType),
TensorInfo(outputShape, dataType));
334 RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload,armnn::DataType::Float32>
340 RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::Float32>
346 RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload,armnn::DataType::Float16>
352 RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::Float16>
358 RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QAsymmU8>
364 RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QAsymmU8>
370 RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QSymmS16>
376 RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QSymmS16>
384 auto workload = CreateConvertFp16ToFp32WorkloadTest<RefConvertFp16ToFp32Workload>(factory, graph);
388 std::move(workload),
TensorInfo({1, 3, 2, 3}, DataType::Float16),
TensorInfo({1, 3, 2, 3}, DataType::Float32));
395 auto workload = CreateConvertFp32ToFp16WorkloadTest<RefConvertFp32ToFp16Workload>(factory, graph);
399 std::move(workload),
TensorInfo({1, 3, 2, 3}, DataType::Float32),
TensorInfo({1, 3, 2, 3}, DataType::Float16));
402 static void RefCreateConvolution2dWorkloadTest(
DataLayout dataLayout = DataLayout::NCHW)
406 auto workload = CreateConvolution2dWorkloadTest<RefConvolution2dWorkload, DataType::Float32>
407 (factory, graph, dataLayout);
409 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 3, 8, 16})
410 : std::initializer_list<unsigned int>({2, 8, 16, 3});
411 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 2, 2, 10})
412 : std::initializer_list<unsigned int>({2, 2, 10, 2});
415 CheckInputOutput(std::move(workload),
422 RefCreateConvolution2dWorkloadTest(DataLayout::NCHW);
427 RefCreateConvolution2dWorkloadTest(DataLayout::NHWC);
435 auto workload = CreateConvolution2dFusedActivationWithBlobWorkloadTest<RefConvolution2dWorkload, DataType::Float32>
436 (factory, graph, dataLayout);
438 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 3, 8, 16})
439 : std::initializer_list<unsigned int>({2, 8, 16, 3});
440 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({2, 2, 2, 10})
441 : std::initializer_list<unsigned int>({2, 2, 10, 2});
444 CheckInputOutput(std::move(workload),
449 static void RefCreateDepthwiseConvolutionWorkloadTest(
DataLayout dataLayout)
453 auto workload = CreateDepthwiseConvolution2dWorkloadTest<RefDepthwiseConvolution2dWorkload, DataType::Float32>
454 (factory, graph, dataLayout);
456 TensorShape inputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 2, 2, 5, 5 })
457 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
458 TensorShape outputShape = (dataLayout == DataLayout::NCHW) ? std::initializer_list<unsigned int>({ 2, 2, 5, 5 })
459 : std::initializer_list<unsigned int>({ 2, 5, 5, 2 });
462 CheckInputOutput(std::move(workload),
469 RefCreateDepthwiseConvolutionWorkloadTest(DataLayout::NHWC);
480 float inputsQScale = 0.0f;
481 float outputQScale = 0.0f;
482 CheckInputOutput(std::move(workload),
487 template <
typename FullyConnectedWorkloadType, armnn::DataType DataType>
488 static void RefCreateFullyConnectedWorkloadTest()
492 auto workload = CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType, DataType>(factory, graph);
497 CheckInputOutput(std::move(workload),
504 RefCreateFullyConnectedWorkloadTest<RefFullyConnectedWorkload, armnn::DataType::Float32>();
509 RefCreateFullyConnectedWorkloadTest<RefFullyConnectedWorkload, armnn::DataType::QAsymmU8>();
514 RefCreateFullyConnectedWorkloadTest<RefFullyConnectedWorkload, armnn::DataType::QSymmS16>();
517 template <
typename NormalizationWorkloadType, armnn::DataType DataType>
518 static void RefCreateNormalizationWorkloadTest(
DataLayout dataLayout)
522 auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
529 case DataLayout::NHWC:
530 inputShape = { 3, 1, 5, 5 };
531 outputShape = { 3, 1, 5, 5 };
533 case DataLayout::NCHW:
535 inputShape = { 3, 5, 5, 1 };
536 outputShape = { 3, 5, 5, 1 };
546 RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
551 RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
556 RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
561 RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
566 RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::QSymmS16>(DataLayout::NCHW);
571 RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::QSymmS16>(DataLayout::NHWC);
574 template <
typename Pooling2dWorkloadType, armnn::DataType DataType>
575 static void RefCreatePooling2dWorkloadTest(
DataLayout dataLayout)
579 auto workload = CreatePooling2dWorkloadTest<Pooling2dWorkloadType, DataType>(factory, graph, dataLayout);
586 case DataLayout::NHWC:
587 inputShape = { 3, 5, 5, 2 };
588 outputShape = { 3, 2, 4, 2 };
590 case DataLayout::NCHW:
592 inputShape = { 3, 2, 5, 5 };
593 outputShape = { 3, 2, 2, 4 };
597 CheckInputOutput(std::move(workload),
604 RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
609 RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
614 RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
619 RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
624 RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::QSymmS16>(DataLayout::NCHW);
629 RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::QSymmS16>(DataLayout::NHWC);
632 template <
typename SoftmaxWorkloadType, armnn::DataType DataType>
633 static void RefCreateSoftmaxWorkloadTest()
637 auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
645 tensorInfo.SetQuantizationScale(1.f / 256);
649 tensorInfo.SetQuantizationOffset(-128);
650 tensorInfo.SetQuantizationScale(1.f / 256);
660 RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::Float32>();
665 RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::Float16>();
670 RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::QAsymmU8>();
675 RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::QSymmS16>();
678 template <
typename SplitterWorkloadType, armnn::DataType DataType>
679 static void RefCreateSplitterWorkloadTest()
683 auto workload = CreateSplitterWorkloadTest<SplitterWorkloadType, DataType>(factory, graph);
687 auto inputHandle = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Inputs[0]);
690 auto outputHandle0 = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Outputs[0]);
693 auto outputHandle1 = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Outputs[1]);
696 auto outputHandle2 = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Outputs[2]);
702 RefCreateSplitterWorkloadTest<RefSplitterWorkload, armnn::DataType::Float32>();
707 RefCreateSplitterWorkloadTest<RefSplitterWorkload, armnn::DataType::Float16>();
712 RefCreateSplitterWorkloadTest<RefSplitterWorkload, armnn::DataType::QAsymmU8>();
715 template <
typename SplitterWorkloadType,
typename ConcatWorkloadType, armnn::DataType DataType>
716 static void RefCreateSplitterConcatWorkloadTest()
726 auto workloads = CreateSplitterConcatWorkloadTest<SplitterWorkloadType, ConcatWorkloadType, DataType>
729 auto wlSplitter = std::move(workloads.first);
730 auto wlConcat = std::move(workloads.second);
743 bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
745 BOOST_TEST(validDataPointers);
750 RefCreateSplitterConcatWorkloadTest<RefSplitterWorkload, RefConcatWorkload, DataType::Float32>();
755 RefCreateSplitterConcatWorkloadTest<RefSplitterWorkload, RefConcatWorkload, DataType::Float16>();
760 RefCreateSplitterConcatWorkloadTest<RefSplitterWorkload, RefConcatWorkload, DataType::QAsymmU8>();
763 template <
typename SplitterWorkloadType,
typename ActivationWorkloadType, armnn::DataType DataType>
764 static void RefCreateSingleOutputMultipleInputsTest()
771 std::unique_ptr<SplitterWorkloadType> wlSplitter;
772 std::unique_ptr<ActivationWorkloadType> wlActiv0_0;
773 std::unique_ptr<ActivationWorkloadType> wlActiv0_1;
774 std::unique_ptr<ActivationWorkloadType> wlActiv1_0;
775 std::unique_ptr<ActivationWorkloadType> wlActiv1_1;
777 CreateSplitterMultipleInputsOneOutputWorkloadTest<SplitterWorkloadType,
778 ActivationWorkloadType,
DataType>(factory, graph, wlSplitter, wlActiv0_0, wlActiv0_1, wlActiv1_0, wlActiv1_1);
790 BOOST_TEST(activ0_0Im);
791 BOOST_TEST(activ0_1Im);
792 BOOST_TEST(activ1_0Im);
793 BOOST_TEST(activ1_1Im);
795 bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
796 (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
798 BOOST_TEST(validDataPointers);
813 template <
typename ResizeBilinearWorkloadType, armnn::DataType DataType>
814 static void RefCreateResizeBilinearTest(
DataLayout dataLayout)
818 auto workload = CreateResizeBilinearWorkloadTest<ResizeBilinearWorkloadType, DataType>(factory, graph, dataLayout);
825 case DataLayout::NHWC:
826 inputShape = { 2, 4, 4, 3 };
827 outputShape = { 2, 2, 2, 3 };
829 case DataLayout::NCHW:
831 inputShape = { 2, 3, 4, 4 };
832 outputShape = { 2, 3, 2, 2 };
836 CheckInputOutput(std::move(workload),
843 RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
848 RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
853 RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
858 RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::QSymmS16>(DataLayout::NCHW);
863 RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
866 template <
typename BatchToSpaceNdWorkloadType, armnn::DataType DataType>
867 static void RefCreateBatchToSpaceNdTest()
872 auto workload = CreateBatchToSpaceNdWorkloadTest<BatchToSpaceNdWorkloadType, DataType>(factory, graph);
874 CheckInputOutput(std::move(workload),
881 RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::Float32>();
886 RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::Float16>();
891 RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::QAsymmU8>();
896 RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::QSymmS16>();
899 template <
typename L2NormalizationWorkloadType, armnn::DataType DataType>
900 static void RefCreateL2NormalizationTest(
DataLayout dataLayout)
905 CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
912 case DataLayout::NHWC:
913 inputShape = { 5, 50, 67, 20 };
914 outputShape = { 5, 50, 67, 20 };
916 case DataLayout::NCHW:
918 inputShape = { 5, 20, 50, 67 };
919 outputShape = { 5, 20, 50, 67 };
929 RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
934 RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
939 RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::QSymmS16>(DataLayout::NCHW);
944 RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::QSymmS16>(DataLayout::NHWC);
949 RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
954 RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
957 template <
typename ReshapeWorkloadType, armnn::DataType DataType>
958 static void RefCreateReshapeWorkloadTest()
962 auto workload = CreateReshapeWorkloadTest<ReshapeWorkloadType, DataType>(factory, graph);
973 RefCreateReshapeWorkloadTest<RefReshapeWorkload, armnn::DataType::Float32>();
978 RefCreateReshapeWorkloadTest<RefReshapeWorkload, armnn::DataType::QAsymmU8>();
983 RefCreateReshapeWorkloadTest<RefReshapeWorkload, armnn::DataType::QSymmS16>();
986 template <
typename ConcatWorkloadType, armnn::DataType DataType>
988 unsigned int concatAxis)
992 auto workload = CreateConcatWorkloadTest<ConcatWorkloadType, DataType>(factory, graph, outputShape, concatAxis);
994 CheckInputsOutput(std::move(workload),
1002 RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
1007 RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float16>({ 4, 3, 2, 5 }, 0);
1012 RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
1017 RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QSymmS16>({ 4, 3, 2, 5 }, 0);
1022 RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
1027 RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
1032 RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 2, 3, 4, 5 }, 2);
1037 RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 4, 5 }, 2);
1042 RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
1047 RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
1050 template <
typename ConstantWorkloadType, armnn::DataType DataType>
1055 auto workload = CreateConstantWorkloadTest<ConstantWorkloadType, DataType>(factory, graph, outputShape);
1058 auto queueDescriptor = workload->GetData();
1059 auto outputHandle = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Outputs[0]);
1065 RefCreateConstantWorkloadTest<RefConstantWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 });
1070 RefCreateConstantWorkloadTest<RefConstantWorkload, armnn::DataType::QSymmS16>({ 2, 3, 2, 10 });
1075 RefCreateConstantWorkloadTest<RefConstantWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 });
1080 RefCreateConstantWorkloadTest<RefConstantWorkload, armnn::DataType::Signed32>({ 2, 3, 2, 10 });
1090 auto workload = CreatePreluWorkloadTest<RefPreluWorkload>(factory,
1098 auto queueDescriptor = workload->GetData();
1099 auto outputHandle = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Outputs[0]);
1100 BOOST_TEST((outputHandle->GetTensorInfo() ==
TensorInfo(outputShape, dataType)));
1105 RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
armnn::DataType::Float32);
1110 RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
armnn::DataType::Float16);
1115 RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
armnn::DataType::QAsymmU8);
1120 RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
armnn::DataType::QSymmS16);
1125 BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
1132 BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
1139 BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
1146 BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
1151 template <
typename SpaceToDepthWorkloadType, armnn::DataType DataType>
1152 static void RefCreateSpaceToDepthWorkloadTest()
1157 auto workload = CreateSpaceToDepthWorkloadTest<SpaceToDepthWorkloadType, DataType>(factory, graph);
1159 CheckInputOutput(std::move(workload),
1166 RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::Float32>();
1171 RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::Float16>();
1176 RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
1181 RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
1184 template <armnn::DataType DataType>
1188 unsigned int numInputs)
1192 auto workload = CreateStackWorkloadTest<RefStackWorkload, DataType>(factory,
1201 for (
unsigned int i = 0; i < numInputs; ++i)
1203 auto inputHandle = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Inputs[i]);
1206 auto outputHandle = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Outputs[0]);
1212 RefCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1217 RefCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1222 RefCreateStackWorkloadTest<armnn::DataType::QSymmS16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1225 template <
typename QLstmWorkloadType>
1226 static void RefCreateQLstmWorkloadTest()
1231 auto workload = CreateQLstmWorkloadTest<QLstmWorkloadType>(factory, graph);
1240 auto inputHandle = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Inputs[0]);
1241 auto cellStateOutHandle = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Outputs[1]);
1242 auto outputHandle = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor.m_Outputs[2]);
1244 BOOST_TEST((inputHandle->GetTensorInfo() == inputInfo));
1245 BOOST_TEST((cellStateOutHandle->GetTensorInfo() == cellStateInfo));
1246 BOOST_TEST((outputHandle->GetTensorInfo() == outputInfo));
1251 RefCreateQLstmWorkloadTest<RefQLstmWorkload>();
BOOST_AUTO_TEST_SUITE(TensorflowLiteParser)
This layer represents an addition operation.
BOOST_AUTO_TEST_SUITE_END()
This layer represents a subtraction operation.
This layer represents a division operation.
BOOST_AUTO_TEST_CASE(CreateActivationFloat32Workload)
void SetQuantizationOffset(int32_t offset)
This layer represents a multiplication operation.