From a983e4699082a0b1ef685bab7354f2ad9cd37a44 Mon Sep 17 00:00:00 2001 From: Colm Donelan Date: Wed, 20 May 2020 16:12:19 +0100 Subject: Updating Doxygen documentation for 20.05 release. Change-Id: I4d624343ed5fd6ae269c3d53532903084508fd14 Signed-off-by: Colm Donelan --- 20.05/_neon_create_workload_tests_8cpp.xhtml | 1350 ++++++++++++++++++++++++++ 1 file changed, 1350 insertions(+) create mode 100644 20.05/_neon_create_workload_tests_8cpp.xhtml (limited to '20.05/_neon_create_workload_tests_8cpp.xhtml') diff --git a/20.05/_neon_create_workload_tests_8cpp.xhtml b/20.05/_neon_create_workload_tests_8cpp.xhtml new file mode 100644 index 0000000000..e01d9e6947 --- /dev/null +++ b/20.05/_neon_create_workload_tests_8cpp.xhtml @@ -0,0 +1,1350 @@ + + + + + + + + + + + + + +ArmNN: src/backends/neon/test/NeonCreateWorkloadTests.cpp File Reference + + + + + + + + + + + + + + + + +
+
+ + + + ArmNN + + + +
+
+  20.05 +
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Functions
+
+
NeonCreateWorkloadTests.cpp File Reference
+
+
+
#include "NeonWorkloadFactoryHelper.hpp"
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <armnn/utility/PolymorphicDowncast.hpp>
+#include <backendsCommon/MemCopyWorkload.hpp>
+#include <aclCommon/test/CreateWorkloadClNeon.hpp>
+#include <neon/NeonWorkloadFactory.hpp>
+#include <neon/NeonTensorHandle.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloads.hpp>
+
+

Go to the source code of this file.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions

 BOOST_AUTO_TEST_CASE (CreateActivationFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateAdditionFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateSubtractionFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateSubtractionUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateMultiplicationFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateMultiplicationUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateDivisionFloatWorkloadTest)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloatNchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloatNhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateConvolution2dFloatNchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateConvolution2dFloatNhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateDepthWiseConvolution2dFloat32NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateFullyConnectedFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateFullyConnectedQAsymmU8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateFullyConnectedQAsymmS8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateNormalizationFloatNchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateNormalizationFloatNhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dFloatNchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dFloatNhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dUint8NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dUint8NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateReshapeFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateReshapeUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateResizeFloat32NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateResizeUint8NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateResizeFloat32NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateResizeUint8NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateSoftmaxFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateSoftmaxQAsymmU8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSoftmaxQAsymmS8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSpaceToDepthFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSpaceToDepthFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSpaceToDepthQAsymm8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSpaceToDepthQSymm16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSplitterWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateSplitterConcat)
 
 BOOST_AUTO_TEST_CASE (CreateSingleOutputMultipleInputs)
 
 BOOST_AUTO_TEST_CASE (CreateL2NormalizationNchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateL2NormalizationNhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateLSTMWorkloadFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim0Float32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim1Float32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim3Float32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim0Uint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim1Uint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim3Uint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateStackFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateStackUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateQuantizedLstmWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateQLstmWorkloadTest)
 
+

Function Documentation

+ +

◆ BOOST_AUTO_TEST_CASE() [1/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateActivationFloatWorkload )
+
+ +

Definition at line 89 of file NeonCreateWorkloadTests.cpp.

+
90 {
91  NeonCreateActivationWorkloadTest<DataType::Float32>();
92 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [2/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateAdditionFloatWorkload )
+
+ +

Definition at line 125 of file NeonCreateWorkloadTests.cpp.

+
126 {
127  NeonCreateElementwiseWorkloadTest<NeonAdditionWorkload,
128  AdditionQueueDescriptor,
129  AdditionLayer,
130  DataType::Float32>();
131 }
+
armnn::AdditionLayer
This layer represents an addition operation.
Definition: AdditionLayer.hpp:13
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [3/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSubtractionFloatWorkload )
+
+ +

Definition at line 143 of file NeonCreateWorkloadTests.cpp.

+
144 {
145  NeonCreateElementwiseWorkloadTest<NeonSubtractionWorkload,
146  SubtractionQueueDescriptor,
147  SubtractionLayer,
148  DataType::Float32>();
149 }
+ +
armnn::SubtractionLayer
This layer represents a subtraction operation.
Definition: SubtractionLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [4/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSubtractionUint8Workload )
+
+ +

Definition at line 151 of file NeonCreateWorkloadTests.cpp.

+
152 {
153  NeonCreateElementwiseWorkloadTest<NeonSubtractionWorkload,
154  SubtractionQueueDescriptor,
155  SubtractionLayer,
156  DataType::QAsymmU8>();
157 }
+ +
armnn::SubtractionLayer
This layer represents a subtraction operation.
Definition: SubtractionLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [5/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateMultiplicationFloatWorkload )
+
+ +

Definition at line 169 of file NeonCreateWorkloadTests.cpp.

+
170 {
171  NeonCreateElementwiseWorkloadTest<NeonMultiplicationWorkload,
172  MultiplicationQueueDescriptor,
173  MultiplicationLayer,
174  DataType::Float32>();
175 }
+ +
armnn::MultiplicationLayer
This layer represents a multiplication operation.
Definition: MultiplicationLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [6/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateMultiplicationUint8Workload )
+
+ +

Definition at line 177 of file NeonCreateWorkloadTests.cpp.

+
178 {
179  NeonCreateElementwiseWorkloadTest<NeonMultiplicationWorkload,
180  MultiplicationQueueDescriptor,
181  MultiplicationLayer,
182  DataType::QAsymmU8>();
183 }
+ +
armnn::MultiplicationLayer
This layer represents a multiplication operation.
Definition: MultiplicationLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [7/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateDivisionFloatWorkloadTest )
+
+ +

Definition at line 185 of file NeonCreateWorkloadTests.cpp.

+
186 {
187  NeonCreateElementwiseWorkloadTest<NeonDivisionWorkload,
188  DivisionQueueDescriptor,
189  DivisionLayer,
190  armnn::DataType::Float32>();
191 }
+ +
armnn::DivisionLayer
This layer represents a division operation.
Definition: DivisionLayer.hpp:14
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [8/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloatNchwWorkload )
+
+ +

Definition at line 227 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
228 {
229  NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float32>(DataLayout::NCHW);
230 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [9/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloatNhwcWorkload )
+
+ +

Definition at line 232 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
233 {
234  NeonCreateBatchNormalizationWorkloadTest<NeonBatchNormalizationWorkload, DataType::Float32>(DataLayout::NHWC);
235 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [10/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConvolution2dFloatNchwWorkload )
+
+ +

Definition at line 269 of file NeonCreateWorkloadTests.cpp.

+
270 {
271  NeonCreateConvolution2dWorkloadTest<DataType::Float32>();
272 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [11/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConvolution2dFloatNhwcWorkload )
+
+ +

Definition at line 274 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
275 {
276  NeonCreateConvolution2dWorkloadTest<DataType::Float32>(DataLayout::NHWC);
277 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [12/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateDepthWiseConvolution2dFloat32NhwcWorkload )
+
+ +

Definition at line 303 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::BOOST_AUTO_TEST_CASE(), and armnn::NHWC.

+
304 {
305  NeonCreateDepthWiseConvolutionWorkloadTest<DataType::Float32>(DataLayout::NHWC);
306 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [13/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateFullyConnectedFloatWorkload )
+
+ +

Definition at line 343 of file NeonCreateWorkloadTests.cpp.

+
344 {
345  NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::Float32>();
346 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [14/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateFullyConnectedQAsymmU8Workload )
+
+ +

Definition at line 348 of file NeonCreateWorkloadTests.cpp.

+
349 {
350  NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::QAsymmU8>();
351 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [15/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateFullyConnectedQAsymmS8Workload )
+
+ +

Definition at line 353 of file NeonCreateWorkloadTests.cpp.

+
354 {
355  NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::QAsymmS8>();
356 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [16/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateNormalizationFloatNchwWorkload )
+
+ +

Definition at line 391 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
392 {
393  NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(DataLayout::NCHW);
394 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [17/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateNormalizationFloatNhwcWorkload )
+
+ +

Definition at line 396 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
397 {
398  NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(DataLayout::NHWC);
399 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [18/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePooling2dFloatNchwWorkload )
+
+ +

Definition at line 429 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
430 {
431  NeonCreatePooling2dWorkloadTest<DataType::Float32>(DataLayout::NCHW);
432 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [19/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePooling2dFloatNhwcWorkload )
+
+ +

Definition at line 434 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
435 {
436  NeonCreatePooling2dWorkloadTest<DataType::Float32>(DataLayout::NHWC);
437 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [20/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePooling2dUint8NchwWorkload )
+
+ +

Definition at line 439 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
440 {
441  NeonCreatePooling2dWorkloadTest<DataType::QAsymmU8>(DataLayout::NCHW);
442 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [21/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePooling2dUint8NhwcWorkload )
+
+ +

Definition at line 444 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
445 {
446  NeonCreatePooling2dWorkloadTest<DataType::QAsymmU8>(DataLayout::NHWC);
447 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [22/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePreluFloatWorkload )
+
+ +

Definition at line 482 of file NeonCreateWorkloadTests.cpp.

+
483 {
484  NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float32);
485 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [23/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePreluUint8Workload )
+
+ +

Definition at line 487 of file NeonCreateWorkloadTests.cpp.

+
488 {
489  NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::QAsymmU8);
490 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [24/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateReshapeFloatWorkload )
+
+ +

Definition at line 516 of file NeonCreateWorkloadTests.cpp.

+
517 {
518  NeonCreateReshapeWorkloadTest<DataType::Float32>();
519 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [25/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateReshapeUint8Workload )
+
+ +

Definition at line 521 of file NeonCreateWorkloadTests.cpp.

+
522 {
523  NeonCreateReshapeWorkloadTest<DataType::QAsymmU8>();
524 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [26/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateResizeFloat32NchwWorkload )
+
+ +

Definition at line 552 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
553 {
554  NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
555 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [27/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateResizeUint8NchwWorkload )
+
+ +

Definition at line 557 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
558 {
559  NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
560 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [28/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateResizeFloat32NhwcWorkload )
+
+ +

Definition at line 562 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
563 {
564  NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
565 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [29/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateResizeUint8NhwcWorkload )
+
+ +

Definition at line 567 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
568 {
569  NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
570 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [30/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSoftmaxFloatWorkload )
+
+ +

Definition at line 607 of file NeonCreateWorkloadTests.cpp.

+
608 {
609  NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::Float32>();
610 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [31/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSoftmaxQAsymmU8Workload )
+
+ +

Definition at line 612 of file NeonCreateWorkloadTests.cpp.

+
613 {
614  NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::QAsymmU8>();
615 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [32/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSoftmaxQAsymmS8Workload )
+
+ +

Definition at line 617 of file NeonCreateWorkloadTests.cpp.

+
618 {
619  NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::QAsymmS8>();
620 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [33/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSpaceToDepthFloat32Workload )
+
+ +

Definition at line 639 of file NeonCreateWorkloadTests.cpp.

+
640 {
641  NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float32>();
642 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [34/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSpaceToDepthFloat16Workload )
+
+ +

Definition at line 644 of file NeonCreateWorkloadTests.cpp.

+
645 {
646  NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float16>();
647 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [35/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSpaceToDepthQAsymm8Workload )
+
+ +

Definition at line 649 of file NeonCreateWorkloadTests.cpp.

+
650 {
651  NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
652 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [36/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSpaceToDepthQSymm16Workload )
+
+ +

Definition at line 654 of file NeonCreateWorkloadTests.cpp.

+
655 {
656  NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
657 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [37/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSplitterWorkload )
+
+ +

Definition at line 659 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::Float32.

+
660 {
661  Graph graph;
662  NeonWorkloadFactory factory =
663  NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
664 
665  auto workload = CreateSplitterWorkloadTest<NeonSplitterWorkload, DataType::Float32>(factory, graph);
666 
667  // Checks that outputs are as we expect them (see definition of CreateSplitterWorkloadTest).
668  SplitterQueueDescriptor queueDescriptor = workload->GetData();
669  auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
670  BOOST_TEST(TestNeonTensorHandleInfo(inputHandle, TensorInfo({5, 7, 7}, DataType::Float32)));
671 
672  auto outputHandle0 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
673  BOOST_TEST(TestNeonTensorHandleInfo(outputHandle0, TensorInfo({1, 7, 7}, DataType::Float32)));
674 
675  auto outputHandle1 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
676  BOOST_TEST(TestNeonTensorHandleInfo(outputHandle1, TensorInfo({2, 7, 7}, DataType::Float32)));
677 
678  auto outputHandle2 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
679  BOOST_TEST(TestNeonTensorHandleInfo(outputHandle2, TensorInfo({2, 7, 7}, DataType::Float32)));
680 }
+ + + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [38/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSplitterConcat )
+
+ +

Definition at line 682 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::Float32.

+
683 {
684  // Tests that it is possible to decide which output of the splitter layer
685  // should be lined to which input of the concat layer.
686  // We tested that is is possible to specify 0th output
687  // of the splitter to be the 1st input to the concat, and the 1st output of the splitter to be 0th input
688  // of the concat.
689 
690  Graph graph;
691  NeonWorkloadFactory factory =
692  NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
693 
694  auto workloads =
695  CreateSplitterConcatWorkloadTest<NeonSplitterWorkload, NeonConcatWorkload,
696  DataType::Float32>(factory, graph);
697 
698  auto wlSplitter = std::move(workloads.first);
699  auto wlConcat = std::move(workloads.second);
700 
701  //Checks that the index of inputs/outputs matches what we declared on InputDescriptor construction.
702  armnn::IAclTensorHandle* sOut0 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[0]);
703  armnn::IAclTensorHandle* sOut1 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[1]);
704  armnn::IAclTensorHandle* mIn0 = dynamic_cast<armnn::IAclTensorHandle*>(wlConcat->GetData().m_Inputs[0]);
705  armnn::IAclTensorHandle* mIn1 = dynamic_cast<armnn::IAclTensorHandle*>(wlConcat->GetData().m_Inputs[1]);
706 
707  BOOST_TEST(sOut0);
708  BOOST_TEST(sOut1);
709  BOOST_TEST(mIn0);
710  BOOST_TEST(mIn1);
711 
712  bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
713 
714  BOOST_TEST(validDataPointers);
715 }
+ + + + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [39/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSingleOutputMultipleInputs )
+
+ +

Definition at line 717 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::BOOST_AUTO_TEST_CASE(), and armnn::Float32.

+
718 {
719  // Tests that it is possible to assign multiple (two) different layers to each of the outputs of a splitter layer.
720  // We created a splitter with two outputs. That each of those outputs is used by two different activation layers
721 
722  Graph graph;
723  NeonWorkloadFactory factory =
724  NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
725 
726  std::unique_ptr<NeonSplitterWorkload> wlSplitter;
727  std::unique_ptr<NeonActivationWorkload> wlActiv0_0;
728  std::unique_ptr<NeonActivationWorkload> wlActiv0_1;
729  std::unique_ptr<NeonActivationWorkload> wlActiv1_0;
730  std::unique_ptr<NeonActivationWorkload> wlActiv1_1;
731 
732  CreateSplitterMultipleInputsOneOutputWorkloadTest<NeonSplitterWorkload,
733  NeonActivationWorkload, DataType::Float32>(factory, graph, wlSplitter, wlActiv0_0, wlActiv0_1,
734  wlActiv1_0, wlActiv1_1);
735 
736  armnn::IAclTensorHandle* sOut0 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[0]);
737  armnn::IAclTensorHandle* sOut1 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[1]);
738  armnn::IAclTensorHandle* activ0_0Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv0_0->GetData().m_Inputs[0]);
739  armnn::IAclTensorHandle* activ0_1Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv0_1->GetData().m_Inputs[0]);
740  armnn::IAclTensorHandle* activ1_0Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv1_0->GetData().m_Inputs[0]);
741  armnn::IAclTensorHandle* activ1_1Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv1_1->GetData().m_Inputs[0]);
742 
743 
744  BOOST_TEST(sOut0);
745  BOOST_TEST(sOut1);
746  BOOST_TEST(activ0_0Im);
747  BOOST_TEST(activ0_1Im);
748  BOOST_TEST(activ1_0Im);
749  BOOST_TEST(activ1_1Im);
750 
751  bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
752  (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
753 
754  BOOST_TEST(validDataPointers);
755 }
+ + + + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [40/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateL2NormalizationNchwWorkload )
+
+ +

Definition at line 806 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
807 {
808  NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(DataLayout::NCHW);
809 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [41/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateL2NormalizationNhwcWorkload )
+
+ +

Definition at line 811 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
812 {
813  NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(DataLayout::NHWC);
814 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [42/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateLSTMWorkloadFloatWorkload )
+
+ +

Definition at line 834 of file NeonCreateWorkloadTests.cpp.

+
835 {
836  NeonCreateLstmWorkloadTest<NeonLstmFloatWorkload>();
837 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [43/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConcatDim0Float32Workload )
+
+ +

Definition at line 859 of file NeonCreateWorkloadTests.cpp.

+
860 {
861  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
862 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [44/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConcatDim1Float32Workload )
+
+ +

Definition at line 864 of file NeonCreateWorkloadTests.cpp.

+
865 {
866  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
867 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [45/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConcatDim3Float32Workload )
+
+ +

Definition at line 869 of file NeonCreateWorkloadTests.cpp.

+
870 {
871  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
872 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [46/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConcatDim0Uint8Workload )
+
+ +

Definition at line 874 of file NeonCreateWorkloadTests.cpp.

+
875 {
876  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
877 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [47/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConcatDim1Uint8Workload )
+
+ +

Definition at line 879 of file NeonCreateWorkloadTests.cpp.

+
880 {
881  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
882 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [48/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConcatDim3Uint8Workload )
+
+ +

Definition at line 884 of file NeonCreateWorkloadTests.cpp.

+
885 {
886  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
887 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [49/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateStackFloat32Workload )
+
+ +

Definition at line 917 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::BOOST_AUTO_TEST_CASE().

+
918 {
919  NeonCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
920 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [50/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateStackUint8Workload )
+
+ +

Definition at line 929 of file NeonCreateWorkloadTests.cpp.

+
930 {
931  NeonCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
932 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [51/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateQuantizedLstmWorkload )
+
+ +

Definition at line 965 of file NeonCreateWorkloadTests.cpp.

+
966 {
967  NeonCreateQuantizedLstmWorkloadTest<NeonQuantizedLstmWorkload>();
968 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [52/52]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateQLstmWorkloadTest )
+
+ +

Definition at line 992 of file NeonCreateWorkloadTests.cpp.

+ +

References BOOST_AUTO_TEST_SUITE_END().

+
993 {
994  NeonCreateQLstmWorkloadTest<NeonQLstmWorkload>();
995 }
+
+
+
+
+ + + + -- cgit v1.2.1