From fd627ffaec8fd8801d980b4c91ee7c0607ab6aaf Mon Sep 17 00:00:00 2001 From: Jan Eilers Date: Thu, 25 Feb 2021 17:44:00 +0000 Subject: IVGCVSW-5687 Update Doxygen Docu * Update Doxygen Documentation for 21.02 release Signed-off-by: Jan Eilers Change-Id: I9ed2f9caab038836ea99d7b378d7899fe431a4e5 --- 21.02/_neon_create_workload_tests_8cpp.xhtml | 1404 ++++++++++++++++++++++++++ 1 file changed, 1404 insertions(+) create mode 100644 21.02/_neon_create_workload_tests_8cpp.xhtml (limited to '21.02/_neon_create_workload_tests_8cpp.xhtml') diff --git a/21.02/_neon_create_workload_tests_8cpp.xhtml b/21.02/_neon_create_workload_tests_8cpp.xhtml new file mode 100644 index 0000000000..c5c2738c0f --- /dev/null +++ b/21.02/_neon_create_workload_tests_8cpp.xhtml @@ -0,0 +1,1404 @@ + + + + + + + + + + + + + +ArmNN: src/backends/neon/test/NeonCreateWorkloadTests.cpp File Reference + + + + + + + + + + + + + + + + +
+
+ + + + ArmNN + + + +
+
+  21.02 +
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Functions
+
+
NeonCreateWorkloadTests.cpp File Reference
+
+
+
#include "NeonWorkloadFactoryHelper.hpp"
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <armnn/utility/Assert.hpp>
+#include <armnn/utility/IgnoreUnused.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 (CreateConvolution2dFastMathEnabledWorkload)
 
 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 (CreateLogSoftmaxFloatWorkload)
 
 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/54]

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

Definition at line 91 of file NeonCreateWorkloadTests.cpp.

+
92 {
93  NeonCreateActivationWorkloadTest<DataType::Float32>();
94 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [2/54]

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

Definition at line 127 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [3/54]

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

Definition at line 145 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [4/54]

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

Definition at line 153 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [5/54]

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

Definition at line 171 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [6/54]

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

Definition at line 179 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [7/54]

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

Definition at line 187 of file NeonCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [8/54]

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

Definition at line 229 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

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

◆ BOOST_AUTO_TEST_CASE() [9/54]

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

Definition at line 234 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

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

◆ BOOST_AUTO_TEST_CASE() [10/54]

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

Definition at line 271 of file NeonCreateWorkloadTests.cpp.

+
272 {
273  NeonCreateConvolution2dWorkloadTest<DataType::Float32>();
274 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [11/54]

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

Definition at line 276 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
277 {
278  NeonCreateConvolution2dWorkloadTest<DataType::Float32>(DataLayout::NHWC);
279 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [12/54]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConvolution2dFastMathEnabledWorkload )
+
+ +

Definition at line 281 of file NeonCreateWorkloadTests.cpp.

+ +

References ARMNN_ASSERT, armnn::IgnoreUnused(), and armnn::NCHW.

+
282 {
283  Graph graph;
284  using ModelOptions = std::vector<BackendOptions>;
285  ModelOptions modelOptions = {};
286  BackendOptions cpuAcc("CpuAcc",
287  {
288  { "FastMathEnabled", true }
289  });
290  modelOptions.push_back(cpuAcc);
291  NeonWorkloadFactory factory =
292  NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager(), modelOptions);
293 
294  auto workload =
295  CreateConvolution2dWorkloadFastMathTest<NeonConvolution2dWorkload, armnn::DataType::Float32>(factory,
296  graph,
297  DataLayout::NCHW,
298  modelOptions);
299 
300  ARMNN_ASSERT(workload != nullptr);
301  auto conv2dWorkload = PolymorphicDowncast<NeonConvolution2dWorkload*>(workload.get());
302  IgnoreUnused(conv2dWorkload);
303  ARMNN_ASSERT(conv2dWorkload != nullptr);
304  ARMNN_ASSERT(conv2dWorkload->GetConvolutionMethod() == arm_compute::ConvolutionMethod::WINOGRAD);
305 }
armnn::ModelOptions
std::vector< BackendOptions > ModelOptions
Definition: BackendOptions.hpp:17
+ +
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
+
ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14
+ +
armnn::BackendOptions
Struct for the users to pass backend specific options.
Definition: BackendOptions.hpp:20
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [13/54]

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

Definition at line 331 of file NeonCreateWorkloadTests.cpp.

+ +

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

+
332 {
333  NeonCreateDepthWiseConvolutionWorkloadTest<DataType::Float32>(DataLayout::NHWC);
334 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [14/54]

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

Definition at line 371 of file NeonCreateWorkloadTests.cpp.

+
372 {
373  NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::Float32>();
374 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [15/54]

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

Definition at line 376 of file NeonCreateWorkloadTests.cpp.

+
377 {
378  NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::QAsymmU8>();
379 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [16/54]

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

Definition at line 381 of file NeonCreateWorkloadTests.cpp.

+
382 {
383  NeonCreateFullyConnectedWorkloadTest<NeonFullyConnectedWorkload, DataType::QAsymmS8>();
384 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [17/54]

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

Definition at line 419 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
420 {
421  NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(DataLayout::NCHW);
422 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [18/54]

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

Definition at line 424 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
425 {
426  NeonCreateNormalizationWorkloadTest<NeonNormalizationFloatWorkload, DataType::Float32>(DataLayout::NHWC);
427 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [19/54]

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

Definition at line 457 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
458 {
459  NeonCreatePooling2dWorkloadTest<DataType::Float32>(DataLayout::NCHW);
460 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [20/54]

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

Definition at line 462 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
463 {
464  NeonCreatePooling2dWorkloadTest<DataType::Float32>(DataLayout::NHWC);
465 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [21/54]

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

Definition at line 467 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
468 {
469  NeonCreatePooling2dWorkloadTest<DataType::QAsymmU8>(DataLayout::NCHW);
470 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [22/54]

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

Definition at line 472 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
473 {
474  NeonCreatePooling2dWorkloadTest<DataType::QAsymmU8>(DataLayout::NHWC);
475 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [23/54]

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

Definition at line 510 of file NeonCreateWorkloadTests.cpp.

+
511 {
512  NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float32);
513 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [24/54]

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

Definition at line 515 of file NeonCreateWorkloadTests.cpp.

+
516 {
517  NeonCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::QAsymmU8);
518 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [25/54]

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

Definition at line 544 of file NeonCreateWorkloadTests.cpp.

+
545 {
546  NeonCreateReshapeWorkloadTest<DataType::Float32>();
547 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [26/54]

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

Definition at line 549 of file NeonCreateWorkloadTests.cpp.

+
550 {
551  NeonCreateReshapeWorkloadTest<DataType::QAsymmU8>();
552 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [27/54]

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

Definition at line 580 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
581 {
582  NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
583 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [28/54]

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

Definition at line 585 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
586 {
587  NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
588 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [29/54]

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

Definition at line 590 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
591 {
592  NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
593 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [30/54]

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

Definition at line 595 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
596 {
597  NeonCreateResizeWorkloadTest<NeonResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
598 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [31/54]

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

Definition at line 635 of file NeonCreateWorkloadTests.cpp.

+
636 {
637  NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::Float32>();
638 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [32/54]

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

Definition at line 640 of file NeonCreateWorkloadTests.cpp.

+
641 {
642  NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::QAsymmU8>();
643 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [33/54]

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

Definition at line 645 of file NeonCreateWorkloadTests.cpp.

+
646 {
647  NeonCreateSoftmaxWorkloadTest<NeonSoftmaxWorkload, DataType::QAsymmS8>();
648 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [34/54]

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

Definition at line 667 of file NeonCreateWorkloadTests.cpp.

+
668 {
669  NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float32>();
670 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [35/54]

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

Definition at line 672 of file NeonCreateWorkloadTests.cpp.

+
673 {
674  NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::Float16>();
675 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [36/54]

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

Definition at line 677 of file NeonCreateWorkloadTests.cpp.

+
678 {
679  NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
680 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [37/54]

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

Definition at line 682 of file NeonCreateWorkloadTests.cpp.

+
683 {
684  NeonSpaceToDepthWorkloadTest<NeonSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
685 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [38/54]

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

Definition at line 687 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::Float32.

+
688 {
689  Graph graph;
690  NeonWorkloadFactory factory =
691  NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
692 
693  auto workload = CreateSplitterWorkloadTest<NeonSplitterWorkload, DataType::Float32>(factory, graph);
694 
695  // Checks that outputs are as we expect them (see definition of CreateSplitterWorkloadTest).
696  SplitterQueueDescriptor queueDescriptor = workload->GetData();
697  auto inputHandle = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Inputs[0]);
698  BOOST_TEST(TestNeonTensorHandleInfo(inputHandle, TensorInfo({5, 7, 7}, DataType::Float32)));
699 
700  auto outputHandle0 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[0]);
701  BOOST_TEST(TestNeonTensorHandleInfo(outputHandle0, TensorInfo({1, 7, 7}, DataType::Float32)));
702 
703  auto outputHandle1 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[1]);
704  BOOST_TEST(TestNeonTensorHandleInfo(outputHandle1, TensorInfo({2, 7, 7}, DataType::Float32)));
705 
706  auto outputHandle2 = PolymorphicDowncast<IAclTensorHandle*>(queueDescriptor.m_Outputs[2]);
707  BOOST_TEST(TestNeonTensorHandleInfo(outputHandle2, TensorInfo({2, 7, 7}, DataType::Float32)));
708 }
+ + + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [39/54]

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

Definition at line 710 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::Float32.

+
711 {
712  // Tests that it is possible to decide which output of the splitter layer
713  // should be lined to which input of the concat layer.
714  // We tested that is is possible to specify 0th output
715  // of the splitter to be the 1st input to the concat, and the 1st output of the splitter to be 0th input
716  // of the concat.
717 
718  Graph graph;
719  NeonWorkloadFactory factory =
720  NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
721 
722  auto workloads =
723  CreateSplitterConcatWorkloadTest<NeonSplitterWorkload, NeonConcatWorkload,
724  DataType::Float32>(factory, graph);
725 
726  auto wlSplitter = std::move(workloads.first);
727  auto wlConcat = std::move(workloads.second);
728 
729  //Checks that the index of inputs/outputs matches what we declared on InputDescriptor construction.
730  armnn::IAclTensorHandle* sOut0 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[0]);
731  armnn::IAclTensorHandle* sOut1 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[1]);
732  armnn::IAclTensorHandle* mIn0 = dynamic_cast<armnn::IAclTensorHandle*>(wlConcat->GetData().m_Inputs[0]);
733  armnn::IAclTensorHandle* mIn1 = dynamic_cast<armnn::IAclTensorHandle*>(wlConcat->GetData().m_Inputs[1]);
734 
735  BOOST_TEST(sOut0);
736  BOOST_TEST(sOut1);
737  BOOST_TEST(mIn0);
738  BOOST_TEST(mIn1);
739 
740  bool validDataPointers = (sOut0 == mIn1) && (sOut1 == mIn0);
741 
742  BOOST_TEST(validDataPointers);
743 }
+ + + + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [40/54]

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

Definition at line 745 of file NeonCreateWorkloadTests.cpp.

+ +

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

+
746 {
747  // Tests that it is possible to assign multiple (two) different layers to each of the outputs of a splitter layer.
748  // We created a splitter with two outputs. That each of those outputs is used by two different activation layers
749 
750  Graph graph;
751  NeonWorkloadFactory factory =
752  NeonWorkloadFactoryHelper::GetFactory(NeonWorkloadFactoryHelper::GetMemoryManager());
753 
754  std::unique_ptr<NeonSplitterWorkload> wlSplitter;
755  std::unique_ptr<NeonActivationWorkload> wlActiv0_0;
756  std::unique_ptr<NeonActivationWorkload> wlActiv0_1;
757  std::unique_ptr<NeonActivationWorkload> wlActiv1_0;
758  std::unique_ptr<NeonActivationWorkload> wlActiv1_1;
759 
760  CreateSplitterMultipleInputsOneOutputWorkloadTest<NeonSplitterWorkload,
761  NeonActivationWorkload, DataType::Float32>(factory, graph, wlSplitter, wlActiv0_0, wlActiv0_1,
762  wlActiv1_0, wlActiv1_1);
763 
764  armnn::IAclTensorHandle* sOut0 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[0]);
765  armnn::IAclTensorHandle* sOut1 = dynamic_cast<armnn::IAclTensorHandle*>(wlSplitter->GetData().m_Outputs[1]);
766  armnn::IAclTensorHandle* activ0_0Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv0_0->GetData().m_Inputs[0]);
767  armnn::IAclTensorHandle* activ0_1Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv0_1->GetData().m_Inputs[0]);
768  armnn::IAclTensorHandle* activ1_0Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv1_0->GetData().m_Inputs[0]);
769  armnn::IAclTensorHandle* activ1_1Im = dynamic_cast<armnn::IAclTensorHandle*>(wlActiv1_1->GetData().m_Inputs[0]);
770 
771 
772  BOOST_TEST(sOut0);
773  BOOST_TEST(sOut1);
774  BOOST_TEST(activ0_0Im);
775  BOOST_TEST(activ0_1Im);
776  BOOST_TEST(activ1_0Im);
777  BOOST_TEST(activ1_1Im);
778 
779  bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
780  (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
781 
782  BOOST_TEST(validDataPointers);
783 }
+ + + + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [41/54]

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

Definition at line 834 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NCHW.

+
835 {
836  NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(DataLayout::NCHW);
837 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [42/54]

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

Definition at line 839 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::NHWC.

+
840 {
841  NeonCreateL2NormalizationWorkloadTest<NeonL2NormalizationFloatWorkload, DataType::Float32>(DataLayout::NHWC);
842 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [43/54]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateLogSoftmaxFloatWorkload )
+
+ +

Definition at line 870 of file NeonCreateWorkloadTests.cpp.

+
871 {
872  NeonCreateLogSoftmaxWorkloadTest<NeonLogSoftmaxWorkload, DataType::Float32>();
873 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [44/54]

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

Definition at line 893 of file NeonCreateWorkloadTests.cpp.

+
894 {
895  NeonCreateLstmWorkloadTest<NeonLstmFloatWorkload>();
896 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [45/54]

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

Definition at line 918 of file NeonCreateWorkloadTests.cpp.

+
919 {
920  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
921 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [46/54]

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

Definition at line 923 of file NeonCreateWorkloadTests.cpp.

+
924 {
925  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
926 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [47/54]

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

Definition at line 928 of file NeonCreateWorkloadTests.cpp.

+
929 {
930  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
931 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [48/54]

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

Definition at line 933 of file NeonCreateWorkloadTests.cpp.

+
934 {
935  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
936 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [49/54]

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

Definition at line 938 of file NeonCreateWorkloadTests.cpp.

+
939 {
940  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
941 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [50/54]

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

Definition at line 943 of file NeonCreateWorkloadTests.cpp.

+
944 {
945  NeonCreateConcatWorkloadTest<NeonConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
946 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [51/54]

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

Definition at line 976 of file NeonCreateWorkloadTests.cpp.

+ +

References armnn::BOOST_AUTO_TEST_CASE().

+
977 {
978  NeonCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
979 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [52/54]

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

Definition at line 988 of file NeonCreateWorkloadTests.cpp.

+
989 {
990  NeonCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
991 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [53/54]

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

Definition at line 1024 of file NeonCreateWorkloadTests.cpp.

+
1025 {
1026  NeonCreateQuantizedLstmWorkloadTest<NeonQuantizedLstmWorkload>();
1027 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [54/54]

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

Definition at line 1051 of file NeonCreateWorkloadTests.cpp.

+ +

References BOOST_AUTO_TEST_SUITE_END().

+
1052 {
1053  NeonCreateQLstmWorkloadTest<NeonQLstmWorkload>();
1054 }
+
+
+
+
+ + + + -- cgit v1.2.1