From 6940dd720ebb6b3d1df8ca203ab696daefe58189 Mon Sep 17 00:00:00 2001 From: Jim Flynn Date: Fri, 20 Mar 2020 12:25:56 +0000 Subject: renamed Documentation folder 20.02 and added .nojekyll file Signed-off-by: Jim Flynn --- 20.02/_neon_create_workload_tests_8cpp.xhtml | 1239 ++++++++++++++++++++++++++ 1 file changed, 1239 insertions(+) create mode 100644 20.02/_neon_create_workload_tests_8cpp.xhtml (limited to '20.02/_neon_create_workload_tests_8cpp.xhtml') diff --git a/20.02/_neon_create_workload_tests_8cpp.xhtml b/20.02/_neon_create_workload_tests_8cpp.xhtml new file mode 100644 index 0000000000..0061934af1 --- /dev/null +++ b/20.02/_neon_create_workload_tests_8cpp.xhtml @@ -0,0 +1,1239 @@ + + + + + + + + + + + + + +ArmNN: src/backends/neon/test/NeonCreateWorkloadTests.cpp File Reference + + + + + + + + + + + + + + + + +
+
+ + + + ArmNN + + + +
+
+  20.02 +
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Functions
+
+
NeonCreateWorkloadTests.cpp File Reference
+
+
+
#include "NeonWorkloadFactoryHelper.hpp"
+#include <aclCommon/ArmComputeTensorUtils.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 (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 (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)
 
+

Function Documentation

+ +

◆ BOOST_AUTO_TEST_CASE() [1/47]

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

Definition at line 88 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [2/47]

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

Definition at line 124 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [3/47]

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

Definition at line 142 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [4/47]

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

Definition at line 150 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [5/47]

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

Definition at line 168 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [6/47]

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

Definition at line 176 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [7/47]

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

Definition at line 184 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [8/47]

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

Definition at line 226 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

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

◆ BOOST_AUTO_TEST_CASE() [9/47]

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

Definition at line 231 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

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

◆ BOOST_AUTO_TEST_CASE() [10/47]

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

Definition at line 268 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [11/47]

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

Definition at line 273 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

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

◆ BOOST_AUTO_TEST_CASE() [12/47]

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

Definition at line 302 of file NeonCreateWorkloadTests.cpp.

+ +

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

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

◆ BOOST_AUTO_TEST_CASE() [13/47]

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

Definition at line 338 of file NeonCreateWorkloadTests.cpp.

+
339 {
340  NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::Float32>();
341 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [14/47]

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

Definition at line 376 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
377 {
378  NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(DataLayout::NCHW);
379 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [15/47]

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

Definition at line 381 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
382 {
383  NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(DataLayout::NHWC);
384 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [16/47]

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

Definition at line 414 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
415 {
416  NeonCreatePooling2dWorkloadTest<DataType::Float32>(DataLayout::NCHW);
417 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [17/47]

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

Definition at line 419 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
420 {
421  NeonCreatePooling2dWorkloadTest<DataType::Float32>(DataLayout::NHWC);
422 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [18/47]

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

Definition at line 424 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
425 {
426  NeonCreatePooling2dWorkloadTest<DataType::QAsymmU8>(DataLayout::NCHW);
427 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [19/47]

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

Definition at line 429 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
430 {
431  NeonCreatePooling2dWorkloadTest<DataType::QAsymmU8>(DataLayout::NHWC);
432 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [20/47]

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

Definition at line 467 of file NeonCreateWorkloadTests.cpp.

+
468 {
469  NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float32);
470 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [21/47]

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

Definition at line 472 of file NeonCreateWorkloadTests.cpp.

+
473 {
474  NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::QAsymmU8);
475 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [22/47]

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

Definition at line 501 of file NeonCreateWorkloadTests.cpp.

+
502 {
503  NeonCreateReshapeWorkloadTest<DataType::Float32>();
504 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [23/47]

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

Definition at line 506 of file NeonCreateWorkloadTests.cpp.

+
507 {
508  NeonCreateReshapeWorkloadTest<DataType::QAsymmU8>();
509 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [24/47]

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

Definition at line 537 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
538 {
539  NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
540 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [25/47]

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

Definition at line 542 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
543 {
544  NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
545 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [26/47]

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

Definition at line 547 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
548 {
549  NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
550 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [27/47]

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

Definition at line 552 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

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

◆ BOOST_AUTO_TEST_CASE() [28/47]

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

Definition at line 581 of file NeonCreateWorkloadTests.cpp.

+
582 {
583  NeonCreateSoftmaxWorkloadTest<NeonSoftmaxFloatWorkload, DataType::Float32>();
584 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [29/47]

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

Definition at line 603 of file NeonCreateWorkloadTests.cpp.

+
604 {
605  NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float32>();
606 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [30/47]

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

Definition at line 608 of file NeonCreateWorkloadTests.cpp.

+
609 {
610  NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float16>();
611 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [31/47]

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

Definition at line 613 of file NeonCreateWorkloadTests.cpp.

+
614 {
615  NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
616 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [32/47]

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

Definition at line 618 of file NeonCreateWorkloadTests.cpp.

+
619 {
620  NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
621 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [33/47]

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

Definition at line 623 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::Float32.

+
624 {
625  Graph graph;
626  NeonWorkloadFactory factory =
627  NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
628 
629  auto workload = CreateSplitterWorkloadTest<NeonSplitterWorkload, DataType::Float32>(factory, graph);
630 
631  // Checks that outputs are as we expect them (see definition of CreateSplitterWorkloadTest).
632  SplitterQueueDescriptor queueDescriptor = workload->GetData();
633  auto inputHandle = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
634  BOOST_TEST(TestNeonTensorHandleInfo(inputHandle, TensorInfo({5, 7, 7}, DataType::Float32)));
635 
636  auto outputHandle0 = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
637  BOOST_TEST(TestNeonTensorHandleInfo(outputHandle0, TensorInfo({1, 7, 7}, DataType::Float32)));
638 
639  auto outputHandle1 = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
640  BOOST_TEST(TestNeonTensorHandleInfo(outputHandle1, TensorInfo({2, 7, 7}, DataType::Float32)));
641 
642  auto outputHandle2 = boost::polymorphic_downcast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
643  BOOST_TEST(TestNeonTensorHandleInfo(outputHandle2, TensorInfo({2, 7, 7}, DataType::Float32)));
644 }
+ + + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [34/47]

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

Definition at line 646 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::Float32.

+
647 {
648  // Tests that it is possible to decide which output of the splitter layer
649  // should be lined to which input of the concat layer.
650  // We tested that is is possible to specify 0th output
651  // of the splitter to be the 1st input to the concat, and the 1st output of the splitter to be 0th input
652  // of the concat.
653 
654  Graph graph;
655  NeonWorkloadFactory factory =
656  NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
657 
658  auto workloads =
659  CreateSplitterConcatWorkloadTest<NeonSplitterWorkload, NeonConcatWorkload,
660  DataType::Float32>(factory, graph);
661 
662  auto wlSplitter = std::move(workloads.first);
663  auto wlConcat = std::move(workloads.second);
664 
665  //Checks that the index of inputs/outputs matches what we declared on InputDescriptor construction.
666  armnn::IAclTensorHandle* sOut0 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[0]);
667  armnn::IAclTensorHandle* sOut1 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[1]);
668  armnn::IAclTensorHandle* mIn0 = dynamic_cast<armnn::IAclTensorHandle*>(wlConcat->GetData().m_Inputs[0]);
669  armnn::IAclTensorHandle* mIn1 = dynamic_cast<armnn::IAclTensorHandle*>(wlConcat->GetData().m_Inputs[1]);
670 
671  BOOST_TEST(sOut0);
672  BOOST_TEST(sOut1);
673  BOOST_TEST(mIn0);
674  BOOST_TEST(mIn1);
675 
676  bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
677 
678  BOOST_TEST(validDataPointers);
679 }
+ + + + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [35/47]

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

Definition at line 681 of file NeonCreateWorkloadTests.cpp.

+ +

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

+
682 {
683  // Tests that it is possible to assign multiple (two) different layers to each of the outputs of a splitter layer.
684  // We created a splitter with two outputs. That each of those outputs is used by two different activation layers
685 
686  Graph graph;
687  NeonWorkloadFactory factory =
688  NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
689 
690  std::unique_ptr<NeonSplitterWorkload> wlSplitter;
691  std::unique_ptr<NeonActivationWorkload> wlActiv0_0;
692  std::unique_ptr<NeonActivationWorkload> wlActiv0_1;
693  std::unique_ptr<NeonActivationWorkload> wlActiv1_0;
694  std::unique_ptr<NeonActivationWorkload> wlActiv1_1;
695 
696  CreateSplitterMultipleInputsOneOutputWorkloadTest<NeonSplitterWorkload,
697  NeonActivationWorkload, DataType::Float32>(factory, graph, wlSplitter, wlActiv0_0, wlActiv0_1,
698  wlActiv1_0, wlActiv1_1);
699 
700  armnn::IAclTensorHandle* sOut0 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[0]);
701  armnn::IAclTensorHandle* sOut1 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[1]);
702  armnn::IAclTensorHandle* activ0_0Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv0_0->GetData().m_Inputs[0]);
703  armnn::IAclTensorHandle* activ0_1Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv0_1->GetData().m_Inputs[0]);
704  armnn::IAclTensorHandle* activ1_0Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv1_0->GetData().m_Inputs[0]);
705  armnn::IAclTensorHandle* activ1_1Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv1_1->GetData().m_Inputs[0]);
706 
707 
708  BOOST_TEST(sOut0);
709  BOOST_TEST(sOut1);
710  BOOST_TEST(activ0_0Im);
711  BOOST_TEST(activ0_1Im);
712  BOOST_TEST(activ1_0Im);
713  BOOST_TEST(activ1_1Im);
714 
715  bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
716  (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
717 
718  BOOST_TEST(validDataPointers);
719 }
+ + + + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [36/47]

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

Definition at line 770 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
771 {
772  NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(DataLayout::NCHW);
773 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [37/47]

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

Definition at line 775 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
776 {
777  NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(DataLayout::NHWC);
778 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [38/47]

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

Definition at line 798 of file NeonCreateWorkloadTests.cpp.

+
799 {
800  NeonCreateLstmWorkloadTest<NeonLstmFloatWorkload>();
801 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [39/47]

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

Definition at line 823 of file NeonCreateWorkloadTests.cpp.

+
824 {
825  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
826 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [40/47]

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

Definition at line 828 of file NeonCreateWorkloadTests.cpp.

+
829 {
830  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
831 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [41/47]

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

Definition at line 833 of file NeonCreateWorkloadTests.cpp.

+
834 {
835  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
836 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [42/47]

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

Definition at line 838 of file NeonCreateWorkloadTests.cpp.

+
839 {
840  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
841 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [43/47]

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

Definition at line 843 of file NeonCreateWorkloadTests.cpp.

+
844 {
845  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
846 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [44/47]

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

Definition at line 848 of file NeonCreateWorkloadTests.cpp.

+
849 {
850  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
851 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [45/47]

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

Definition at line 881 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::BOOST_AUTO_TEST_CASE().

+
882 {
883  NeonCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
884 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [46/47]

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

Definition at line 893 of file NeonCreateWorkloadTests.cpp.

+
894 {
895  NeonCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
896 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [47/47]

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

Definition at line 931 of file NeonCreateWorkloadTests.cpp.

+ +

References BOOST_AUTO_TEST_SUITE_END().

+
932 {
933  NeonCreateQuantizedLstmWorkloadTest<NeonQuantizedLstmWorkload>();
934 }
+
+
+
+
+ + + + -- cgit v1.2.1