From 0e2bab81442ee6cc2b94e4f7881ed0c5c6af65e7 Mon Sep 17 00:00:00 2001 From: Jim Flynn Date: Thu, 19 Mar 2020 17:03:14 +0000 Subject: Creating gh-pages documentation for ArmNN Signed-off-by: Jim Flynn --- Documentation/_cl_create_workload_tests_8cpp.xhtml | 1927 ++++++++++++++++++++ 1 file changed, 1927 insertions(+) create mode 100644 Documentation/_cl_create_workload_tests_8cpp.xhtml (limited to 'Documentation/_cl_create_workload_tests_8cpp.xhtml') diff --git a/Documentation/_cl_create_workload_tests_8cpp.xhtml b/Documentation/_cl_create_workload_tests_8cpp.xhtml new file mode 100644 index 0000000000..2b61668673 --- /dev/null +++ b/Documentation/_cl_create_workload_tests_8cpp.xhtml @@ -0,0 +1,1927 @@ + + + + + + + + + + + + + +ArmNN: src/backends/cl/test/ClCreateWorkloadTests.cpp File Reference + + + + + + + + + + + + + + + + +
+
+ + + + ArmNN + + + +
+
+  20.02 +
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Functions
+
+
ClCreateWorkloadTests.cpp File Reference
+
+
+
#include "ClContextControlFixture.hpp"
+#include "ClWorkloadFactoryHelper.hpp"
+#include <backendsCommon/MemCopyWorkload.hpp>
+#include <aclCommon/test/CreateWorkloadClNeon.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <cl/ClTensorHandle.hpp>
+#include <cl/ClWorkloadFactory.hpp>
+#include <cl/workloads/ClWorkloads.hpp>
+#include <cl/workloads/ClWorkloadUtils.hpp>
+
+

Go to the source code of this file.

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

+Functions

boost::test_tools::predicate_result CompareIClTensorHandleShape (IClTensorHandle *tensorHandle, std::initializer_list< unsigned int > expectedDimensions)
 
 BOOST_AUTO_TEST_CASE (CreateActivationFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateActivationFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateAdditionFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateAdditionFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSubtractionFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateSubtractionFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateMultiplicationFloatWorkloadTest)
 
 BOOST_AUTO_TEST_CASE (CreateMultiplicationFloat16WorkloadTest)
 
 BOOST_AUTO_TEST_CASE (CreateMultiplicationUint8WorkloadTest)
 
 BOOST_AUTO_TEST_CASE (CreateDivisionFloatWorkloadTest)
 
 BOOST_AUTO_TEST_CASE (CreateDivisionFloat16WorkloadTest)
 
 BOOST_AUTO_TEST_CASE (CreateRsqrtFloat32WorkloadTest)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloatNchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloat16NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloatNhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationNhwcFloat16NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateConvertFp16ToFp32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConvertFp32ToFp16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConvolution2dFloatNchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateConvolution2dFloatNhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateConvolution2dFloat16NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateConvolution2dFloat16NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateDepthwiseConvolutionFloat32NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateDirectConvolution2dFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateDirectConvolution2dFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateDirectConvolution2dUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateFullyConnectedFloatWorkloadTest)
 
 BOOST_AUTO_TEST_CASE (CreateFullyConnectedFloat16WorkloadTest)
 
 BOOST_AUTO_TEST_CASE (CreateNormalizationFloat32NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateNormalizationFloat16NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateNormalizationFloat32NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateNormalizationFloat16NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dFloatNchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dFloatNhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dFloat16NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dFloat16NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateReshapeFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateReshapeFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateReshapeUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSoftmaxFloatWorkloadTest)
 
 BOOST_AUTO_TEST_CASE (CreateSoftmaxFloat16WorkloadTest)
 
 BOOST_AUTO_TEST_CASE (CreateSplitterFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateSplitterFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSplitterConcatFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateSplitterConcatFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSingleOutputMultipleInputs)
 
 BOOST_AUTO_TEST_CASE (CreateL2NormalizationFloatNchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateL2NormalizationFloatNhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateL2NormalizationFloat16NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateL2NormalizationFloat16NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateLSTMWorkloadFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateResizeFloat32NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateResizeFloat16NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateResizeUint8NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateResizeFloat32NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateResizeFloat16NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateResizeUint8NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateMeanFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateMeanFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateMeanUint8Workload)
 
 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 (CreateSpaceToDepthFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSpaceToDepthFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSpaceToDepthQAsymm8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSpaceToDepthQSymm16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateStackFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateStackFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateStackUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateQuantizedLstmWorkload)
 
+

Function Documentation

+ +

◆ BOOST_AUTO_TEST_CASE() [1/77]

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

Definition at line 45 of file ClCreateWorkloadTests.cpp.

+ +

Referenced by BOOST_AUTO_TEST_CASE().

+
46 {
47  ClCreateActivationWorkloadTest<armnn::DataType::Float32>();
48 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [2/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateActivationFloat16Workload )
+
+ +

Definition at line 50 of file ClCreateWorkloadTests.cpp.

+
51 {
52  ClCreateActivationWorkloadTest<armnn::DataType::Float16>();
53 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [3/77]

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

Definition at line 77 of file ClCreateWorkloadTests.cpp.

+
78 {
79  ClCreateElementwiseWorkloadTest<ClAdditionWorkload,
80  AdditionQueueDescriptor,
81  AdditionLayer,
82  armnn::DataType::Float32>();
83 }
+ +
armnn::AdditionLayer
This layer represents an addition operation.
Definition: AdditionLayer.hpp:13
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [4/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateAdditionFloat16Workload )
+
+ +

Definition at line 85 of file ClCreateWorkloadTests.cpp.

+
86 {
87  ClCreateElementwiseWorkloadTest<ClAdditionWorkload,
88  AdditionQueueDescriptor,
89  AdditionLayer,
90  armnn::DataType::Float16>();
91 }
+ + +
armnn::AdditionLayer
This layer represents an addition operation.
Definition: AdditionLayer.hpp:13
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [5/77]

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

Definition at line 93 of file ClCreateWorkloadTests.cpp.

+
94 {
95  ClCreateElementwiseWorkloadTest<ClSubtractionWorkload,
96  SubtractionQueueDescriptor,
97  SubtractionLayer,
98  armnn::DataType::Float32>();
99 }
+
armnn::SubtractionLayer
This layer represents a subtraction operation.
Definition: SubtractionLayer.hpp:14
+ + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [6/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSubtractionFloat16Workload )
+
+ +

Definition at line 101 of file ClCreateWorkloadTests.cpp.

+
102 {
103  ClCreateElementwiseWorkloadTest<ClSubtractionWorkload,
104  SubtractionQueueDescriptor,
105  SubtractionLayer,
106  armnn::DataType::Float16>();
107 }
+ +
armnn::SubtractionLayer
This layer represents a subtraction operation.
Definition: SubtractionLayer.hpp:14
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [7/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateMultiplicationFloatWorkloadTest )
+
+ +

Definition at line 109 of file ClCreateWorkloadTests.cpp.

+
110 {
111  ClCreateElementwiseWorkloadTest<ClMultiplicationWorkload,
112  MultiplicationQueueDescriptor,
113  MultiplicationLayer,
114  armnn::DataType::Float32>();
115 }
+ + +
armnn::MultiplicationLayer
This layer represents a multiplication operation.
Definition: MultiplicationLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [8/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateMultiplicationFloat16WorkloadTest )
+
+ +

Definition at line 117 of file ClCreateWorkloadTests.cpp.

+
118 {
119  ClCreateElementwiseWorkloadTest<ClMultiplicationWorkload,
120  MultiplicationQueueDescriptor,
121  MultiplicationLayer,
122  armnn::DataType::Float16>();
123 }
+ + +
armnn::MultiplicationLayer
This layer represents a multiplication operation.
Definition: MultiplicationLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [9/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateMultiplicationUint8WorkloadTest )
+
+ +

Definition at line 125 of file ClCreateWorkloadTests.cpp.

+
126 {
127  ClCreateElementwiseWorkloadTest<ClMultiplicationWorkload,
128  MultiplicationQueueDescriptor,
129  MultiplicationLayer,
130  armnn::DataType::QAsymmU8>();
131 }
+ + +
armnn::MultiplicationLayer
This layer represents a multiplication operation.
Definition: MultiplicationLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [10/77]

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

Definition at line 133 of file ClCreateWorkloadTests.cpp.

+
134 {
135  ClCreateElementwiseWorkloadTest<ClDivisionFloatWorkload,
136  DivisionQueueDescriptor,
137  DivisionLayer,
138  armnn::DataType::Float32>();
139 }
+ +
armnn::DivisionLayer
This layer represents a division operation.
Definition: DivisionLayer.hpp:14
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [11/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateDivisionFloat16WorkloadTest )
+
+ +

Definition at line 141 of file ClCreateWorkloadTests.cpp.

+
142 {
143  ClCreateElementwiseWorkloadTest<ClDivisionFloatWorkload,
144  DivisionQueueDescriptor,
145  DivisionLayer,
146  armnn::DataType::Float16>();
147 }
+ + +
armnn::DivisionLayer
This layer represents a division operation.
Definition: DivisionLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [12/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateRsqrtFloat32WorkloadTest )
+
+ +

Definition at line 169 of file ClCreateWorkloadTests.cpp.

+
170 {
171  ClCreateElementwiseUnaryWorkloadTest<ClRsqrtWorkload, RsqrtQueueDescriptor, armnn::DataType::Float32>(
172  UnaryOperation::Rsqrt);
173 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [13/77]

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

Definition at line 202 of file ClCreateWorkloadTests.cpp.

+
203 {
204  ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload,
205  armnn::DataType::Float32>(DataLayout::NCHW);
206 }
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [14/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloat16NchwWorkload )
+
+ +

Definition at line 208 of file ClCreateWorkloadTests.cpp.

+
209 {
210  ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload,
211  armnn::DataType::Float16>(DataLayout::NCHW);
212 }
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [15/77]

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

Definition at line 214 of file ClCreateWorkloadTests.cpp.

+
215 {
216  ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload,
217  armnn::DataType::Float32>(DataLayout::NHWC);
218 }
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [16/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchNormalizationNhwcFloat16NhwcWorkload )
+
+ +

Definition at line 220 of file ClCreateWorkloadTests.cpp.

+
221 {
222  ClCreateBatchNormalizationWorkloadTest<ClBatchNormalizationFloatWorkload,
223  armnn::DataType::Float16>(DataLayout::NHWC);
224 }
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [17/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConvertFp16ToFp32Workload )
+
+ +

Definition at line 226 of file ClCreateWorkloadTests.cpp.

+ +

References CompareIClTensorHandleShape().

+
227 {
228  Graph graph;
229  ClWorkloadFactory factory =
230  ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
231 
232  auto workload = CreateConvertFp16ToFp32WorkloadTest<ClConvertFp16ToFp32Workload>(factory, graph);
233 
234  ConvertFp16ToFp32QueueDescriptor queueDescriptor = workload->GetData();
235  auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
236  auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
237 
238  BOOST_TEST(CompareIClTensorHandleShape(inputHandle, {1, 3, 2, 3}));
239  BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {1, 3, 2, 3}));
240  BOOST_TEST((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
241  BOOST_TEST((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
242 }
+ + +
CompareIClTensorHandleShape
boost::test_tools::predicate_result CompareIClTensorHandleShape(IClTensorHandle *tensorHandle, std::initializer_list< unsigned int > expectedDimensions)
Definition: ClCreateWorkloadTests.cpp:19
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [18/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConvertFp32ToFp16Workload )
+
+ +

Definition at line 244 of file ClCreateWorkloadTests.cpp.

+ +

References CompareIClTensorHandleShape().

+
245 {
246  Graph graph;
247  ClWorkloadFactory factory =
248  ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
249 
250  auto workload = CreateConvertFp32ToFp16WorkloadTest<ClConvertFp32ToFp16Workload>(factory, graph);
251 
252  ConvertFp32ToFp16QueueDescriptor queueDescriptor = workload->GetData();
253  auto inputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
254  auto outputHandle = boost::polymorphic_downcast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
255 
256  BOOST_TEST(CompareIClTensorHandleShape(inputHandle, {1, 3, 2, 3}));
257  BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {1, 3, 2, 3}));
258  BOOST_TEST((inputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F32));
259  BOOST_TEST((outputHandle->GetTensor().info()->data_type() == arm_compute::DataType::F16));
260 }
+ + +
CompareIClTensorHandleShape
boost::test_tools::predicate_result CompareIClTensorHandleShape(IClTensorHandle *tensorHandle, std::initializer_list< unsigned int > expectedDimensions)
Definition: ClCreateWorkloadTests.cpp:19
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [19/77]

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

Definition at line 286 of file ClCreateWorkloadTests.cpp.

+
287 {
288  ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
289 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [20/77]

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

Definition at line 291 of file ClCreateWorkloadTests.cpp.

+
292 {
293  ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
294 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [21/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConvolution2dFloat16NchwWorkload )
+
+ +

Definition at line 296 of file ClCreateWorkloadTests.cpp.

+
297 {
298  ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
299 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [22/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConvolution2dFloat16NhwcWorkload )
+
+ +

Definition at line 301 of file ClCreateWorkloadTests.cpp.

+
302 {
303  ClConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
304 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [23/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateDepthwiseConvolutionFloat32NhwcWorkload )
+
+ +

Definition at line 330 of file ClCreateWorkloadTests.cpp.

+
331 {
332  ClDepthwiseConvolutionWorkloadTest<ClDepthwiseConvolutionWorkload, DataType::Float32>(DataLayout::NHWC);
333 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [24/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateDirectConvolution2dFloatWorkload )
+
+ +

Definition at line 352 of file ClCreateWorkloadTests.cpp.

+
353 {
354  ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float32>();
355 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [25/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateDirectConvolution2dFloat16Workload )
+
+ +

Definition at line 357 of file ClCreateWorkloadTests.cpp.

+
358 {
359  ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::Float16>();
360 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [26/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateDirectConvolution2dUint8Workload )
+
+ +

Definition at line 362 of file ClCreateWorkloadTests.cpp.

+
363 {
364  ClDirectConvolution2dWorkloadTest<ClConvolution2dWorkload, armnn::DataType::QAsymmU8>();
365 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [27/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateFullyConnectedFloatWorkloadTest )
+
+ +

Definition at line 386 of file ClCreateWorkloadTests.cpp.

+
387 {
388  ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float32>();
389 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [28/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateFullyConnectedFloat16WorkloadTest )
+
+ +

Definition at line 391 of file ClCreateWorkloadTests.cpp.

+
392 {
393  ClCreateFullyConnectedWorkloadTest<ClFullyConnectedWorkload, armnn::DataType::Float16>();
394 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [29/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateNormalizationFloat32NchwWorkload )
+
+ +

Definition at line 419 of file ClCreateWorkloadTests.cpp.

+
420 {
421  ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
422 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [30/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateNormalizationFloat16NchwWorkload )
+
+ +

Definition at line 424 of file ClCreateWorkloadTests.cpp.

+
425 {
426  ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
427 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [31/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateNormalizationFloat32NhwcWorkload )
+
+ +

Definition at line 429 of file ClCreateWorkloadTests.cpp.

+
430 {
431  ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
432 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [32/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateNormalizationFloat16NhwcWorkload )
+
+ +

Definition at line 434 of file ClCreateWorkloadTests.cpp.

+
435 {
436  ClNormalizationWorkloadTest<ClNormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
437 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [33/77]

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

Definition at line 462 of file ClCreateWorkloadTests.cpp.

+
463 {
464  ClPooling2dWorkloadTest<armnn::DataType::Float32>(DataLayout::NCHW);
465 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [34/77]

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

Definition at line 467 of file ClCreateWorkloadTests.cpp.

+
468 {
469  ClPooling2dWorkloadTest<armnn::DataType::Float32>(DataLayout::NHWC);
470 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [35/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePooling2dFloat16NchwWorkload )
+
+ +

Definition at line 472 of file ClCreateWorkloadTests.cpp.

+
473 {
474  ClPooling2dWorkloadTest<armnn::DataType::Float16>(DataLayout::NCHW);
475 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [36/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePooling2dFloat16NhwcWorkload )
+
+ +

Definition at line 477 of file ClCreateWorkloadTests.cpp.

+
478 {
479  ClPooling2dWorkloadTest<armnn::DataType::Float16>(DataLayout::NHWC);
480 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [37/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePreluFloat16Workload )
+
+ +

Definition at line 509 of file ClCreateWorkloadTests.cpp.

+
510 {
511  ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float16);
512 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [38/77]

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

Definition at line 514 of file ClCreateWorkloadTests.cpp.

+
515 {
516  ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::Float32);
517 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [39/77]

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

Definition at line 519 of file ClCreateWorkloadTests.cpp.

+
520 {
521  ClCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, DataType::QAsymmU8);
522 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [40/77]

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

Definition at line 542 of file ClCreateWorkloadTests.cpp.

+
543 {
544  ClCreateReshapeWorkloadTest<armnn::DataType::Float32>();
545 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [41/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateReshapeFloat16Workload )
+
+ +

Definition at line 547 of file ClCreateWorkloadTests.cpp.

+
548 {
549  ClCreateReshapeWorkloadTest<armnn::DataType::Float16>();
550 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [42/77]

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

Definition at line 552 of file ClCreateWorkloadTests.cpp.

+
553 {
554  ClCreateReshapeWorkloadTest<armnn::DataType::QAsymmU8>();
555 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [43/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSoftmaxFloatWorkloadTest )
+
+ +

Definition at line 576 of file ClCreateWorkloadTests.cpp.

+
577 {
578  ClSoftmaxWorkloadTest<ClSoftmaxFloatWorkload, armnn::DataType::Float32>();
579 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [44/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSoftmaxFloat16WorkloadTest )
+
+ +

Definition at line 581 of file ClCreateWorkloadTests.cpp.

+
582 {
583  ClSoftmaxWorkloadTest<ClSoftmaxFloatWorkload, armnn::DataType::Float16>();
584 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [45/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSplitterFloatWorkload )
+
+ +

Definition at line 610 of file ClCreateWorkloadTests.cpp.

+
611 {
612  ClSplitterWorkloadTest<armnn::DataType::Float32>();
613 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [46/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSplitterFloat16Workload )
+
+ +

Definition at line 615 of file ClCreateWorkloadTests.cpp.

+
616 {
617  ClSplitterWorkloadTest<armnn::DataType::Float16>();
618 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [47/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSplitterConcatFloatWorkload )
+
+ +

Definition at line 663 of file ClCreateWorkloadTests.cpp.

+
664 {
665  ClSplitterConcatTest<armnn::DataType::Float32>();
666 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [48/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSplitterConcatFloat16Workload )
+
+ +

Definition at line 668 of file ClCreateWorkloadTests.cpp.

+
669 {
670  ClSplitterConcatTest<armnn::DataType::Float16>();
671 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [49/77]

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

Definition at line 674 of file ClCreateWorkloadTests.cpp.

+ +

References BOOST_AUTO_TEST_CASE(), and armnn::Float32.

+
675 {
676  // Test that it is possible to assign multiple (two) different layers to each of the outputs of a splitter layer.
677  // We create a splitter with two outputs. That each of those outputs is used by two different activation layers.
678 
679  Graph graph;
680  ClWorkloadFactory factory =
681  ClWorkloadFactoryHelper::GetFactory(ClWorkloadFactoryHelper::GetMemoryManager());
682 
683  std::unique_ptr<ClSplitterWorkload> wlSplitter;
684  std::unique_ptr<ClActivationWorkload> wlActiv0_0;
685  std::unique_ptr<ClActivationWorkload> wlActiv0_1;
686  std::unique_ptr<ClActivationWorkload> wlActiv1_0;
687  std::unique_ptr<ClActivationWorkload> wlActiv1_1;
688 
689  CreateSplitterMultipleInputsOneOutputWorkloadTest<ClSplitterWorkload,
690  ClActivationWorkload, armnn::DataType::Float32>(factory, graph, wlSplitter, wlActiv0_0, wlActiv0_1,
691  wlActiv1_0, wlActiv1_1);
692 
693  //Checks that the index of inputs/outputs matches what we declared on InputDescriptor construction.
694  armnn::ClSubTensorHandle* sOut0 = dynamic_cast<armnn::ClSubTensorHandle*>(wlSplitter->GetData().m_Outputs[0]);
695  armnn::ClSubTensorHandle* sOut1 = dynamic_cast<armnn::ClSubTensorHandle*>(wlSplitter->GetData().m_Outputs[1]);
696  armnn::ClSubTensorHandle* activ0_0Im = dynamic_cast<armnn::ClSubTensorHandle*>(wlActiv0_0->GetData().m_Inputs[0]);
697  armnn::ClSubTensorHandle* activ0_1Im = dynamic_cast<armnn::ClSubTensorHandle*>(wlActiv0_1->GetData().m_Inputs[0]);
698  armnn::ClSubTensorHandle* activ1_0Im = dynamic_cast<armnn::ClSubTensorHandle*>(wlActiv1_0->GetData().m_Inputs[0]);
699  armnn::ClSubTensorHandle* activ1_1Im = dynamic_cast<armnn::ClSubTensorHandle*>(wlActiv1_1->GetData().m_Inputs[0]);
700 
701 
702  BOOST_TEST(sOut0);
703  BOOST_TEST(sOut1);
704  BOOST_TEST(activ0_0Im);
705  BOOST_TEST(activ0_1Im);
706  BOOST_TEST(activ1_0Im);
707  BOOST_TEST(activ1_1Im);
708 
709  bool validDataPointers = (sOut0 == activ0_0Im) && (sOut0 == activ0_1Im) &&
710  (sOut1 == activ1_0Im) && (sOut1 == activ1_1Im);
711 
712  BOOST_TEST(validDataPointers);
713 }
+ + + + + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [50/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateL2NormalizationFloatNchwWorkload )
+
+ +

Definition at line 753 of file ClCreateWorkloadTests.cpp.

+
754 {
755  ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
756 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [51/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateL2NormalizationFloatNhwcWorkload )
+
+ +

Definition at line 758 of file ClCreateWorkloadTests.cpp.

+
759 {
760  ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
761 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [52/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateL2NormalizationFloat16NchwWorkload )
+
+ +

Definition at line 763 of file ClCreateWorkloadTests.cpp.

+
764 {
765  ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
766 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [53/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateL2NormalizationFloat16NhwcWorkload )
+
+ +

Definition at line 768 of file ClCreateWorkloadTests.cpp.

+
769 {
770  ClL2NormalizationWorkloadTest<ClL2NormalizationFloatWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
771 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [54/77]

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

Definition at line 789 of file ClCreateWorkloadTests.cpp.

+
790 {
791  ClCreateLstmWorkloadTest<ClLstmFloatWorkload>();
792 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [55/77]

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

Definition at line 821 of file ClCreateWorkloadTests.cpp.

+
822 {
823  ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
824 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [56/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateResizeFloat16NchwWorkload )
+
+ +

Definition at line 826 of file ClCreateWorkloadTests.cpp.

+
827 {
828  ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
829 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [57/77]

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

Definition at line 831 of file ClCreateWorkloadTests.cpp.

+
832 {
833  ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
834 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [58/77]

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

Definition at line 836 of file ClCreateWorkloadTests.cpp.

+
837 {
838  ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
839 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [59/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateResizeFloat16NhwcWorkload )
+
+ +

Definition at line 841 of file ClCreateWorkloadTests.cpp.

+
842 {
843  ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::Float16>(DataLayout::NHWC);
844 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [60/77]

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

Definition at line 846 of file ClCreateWorkloadTests.cpp.

+
847 {
848  ClResizeWorkloadTest<ClResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
849 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [61/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateMeanFloat32Workload )
+
+ +

Definition at line 870 of file ClCreateWorkloadTests.cpp.

+
871 {
872  ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float32>();
873 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [62/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateMeanFloat16Workload )
+
+ +

Definition at line 875 of file ClCreateWorkloadTests.cpp.

+
876 {
877  ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::Float16>();
878 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [63/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateMeanUint8Workload )
+
+ +

Definition at line 880 of file ClCreateWorkloadTests.cpp.

+
881 {
882  ClMeanWorkloadTest<ClMeanWorkload, armnn::DataType::QAsymmU8>();
883 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [64/77]

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

Definition at line 905 of file ClCreateWorkloadTests.cpp.

+
906 {
907  ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
908 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [65/77]

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

Definition at line 910 of file ClCreateWorkloadTests.cpp.

+
911 {
912  ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
913 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [66/77]

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

Definition at line 915 of file ClCreateWorkloadTests.cpp.

+
916 {
917  ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
918 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [67/77]

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

Definition at line 920 of file ClCreateWorkloadTests.cpp.

+
921 {
922  ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
923 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [68/77]

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

Definition at line 925 of file ClCreateWorkloadTests.cpp.

+
926 {
927  ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 6, 2, 5 }, 1);
928 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [69/77]

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

Definition at line 930 of file ClCreateWorkloadTests.cpp.

+
931 {
932  ClCreateConcatWorkloadTest<ClConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
933 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [70/77]

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

Definition at line 952 of file ClCreateWorkloadTests.cpp.

+
953 {
954  ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float32>();
955 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [71/77]

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

Definition at line 957 of file ClCreateWorkloadTests.cpp.

+
958 {
959  ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::Float16>();
960 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [72/77]

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

Definition at line 962 of file ClCreateWorkloadTests.cpp.

+
963 {
964  ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
965 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [73/77]

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

Definition at line 967 of file ClCreateWorkloadTests.cpp.

+
968 {
969  ClSpaceToDepthWorkloadTest<ClSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
970 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [74/77]

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

Definition at line 1000 of file ClCreateWorkloadTests.cpp.

+
1001 {
1002  ClCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1003 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [75/77]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateStackFloat16Workload )
+
+ +

Definition at line 1005 of file ClCreateWorkloadTests.cpp.

+
1006 {
1007  ClCreateStackWorkloadTest<armnn::DataType::Float16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1008 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [76/77]

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

Definition at line 1010 of file ClCreateWorkloadTests.cpp.

+
1011 {
1012  ClCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1013 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [77/77]

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

Definition at line 1050 of file ClCreateWorkloadTests.cpp.

+ +

References BOOST_AUTO_TEST_SUITE_END().

+
1051 {
1052  ClCreateQuantizedLstmWorkloadTest<ClQuantizedLstmWorkload>();
1053 }
+
+
+ +

◆ CompareIClTensorHandleShape()

+ +
+
+ + + + + + + + + + + + + + + + + + +
boost::test_tools::predicate_result CompareIClTensorHandleShape (IClTensorHandle * tensorHandle,
std::initializer_list< unsigned int > expectedDimensions 
)
+
+ +

Definition at line 19 of file ClCreateWorkloadTests.cpp.

+ +

Referenced by BOOST_AUTO_TEST_CASE().

+
21 {
22  return CompareTensorHandleShape<IClTensorHandle>(tensorHandle, expectedDimensions);
23 }
+
+
+
+
+ + + + -- cgit v1.2.1