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/_ref_create_workload_tests_8cpp.xhtml | 2474 +++++++++++++++++++++++++++ 1 file changed, 2474 insertions(+) create mode 100644 20.02/_ref_create_workload_tests_8cpp.xhtml (limited to '20.02/_ref_create_workload_tests_8cpp.xhtml') diff --git a/20.02/_ref_create_workload_tests_8cpp.xhtml b/20.02/_ref_create_workload_tests_8cpp.xhtml new file mode 100644 index 0000000000..d797f60f15 --- /dev/null +++ b/20.02/_ref_create_workload_tests_8cpp.xhtml @@ -0,0 +1,2474 @@ + + + + + + + + + + + + + +ArmNN: src/backends/reference/test/RefCreateWorkloadTests.cpp File Reference + + + + + + + + + + + + + + + + +
+
+ + + + ArmNN + + + +
+
+  20.02 +
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Functions
+
+
RefCreateWorkloadTests.cpp File Reference
+
+
+
#include <test/CreateWorkload.hpp>
+#include <reference/RefTensorHandle.hpp>
+#include <reference/RefWorkloadFactory.hpp>
+#include <reference/workloads/RefWorkloads.hpp>
+
+

Go to the source code of this file.

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

+Functions

 BOOST_AUTO_TEST_CASE (CreateActivationFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateActivationUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateAdditionFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateAdditionUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateAdditionInt16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSubtractionFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSubtractionFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSubtractionUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSubtractionInt16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateMultiplicationFloatWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateMultiplicationUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateMultiplicationInt16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateDivisionFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateDivisionFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateDivisionUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateDivisionInt16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloat32WorkloadNhwc)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloat16WorkloadNhwc)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationUint8WorkloadNhwc)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationInt16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateBatchNormalizationInt16WorkloadNhwc)
 
 BOOST_AUTO_TEST_CASE (CreateConvertFp16ToFp32Float32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConvertFp32ToFp16Float16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConvolution2dFloatNchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateConvolution2dFloatNhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateDepthwiseConvolutionFloat32NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateFullyConnectedWorkloadFloat32)
 
 BOOST_AUTO_TEST_CASE (CreateFullyConnectedWorkloadQuantisedAsymm8)
 
 BOOST_AUTO_TEST_CASE (CreateFullyConnectedWorkloadQuantisedSymm16)
 
 BOOST_AUTO_TEST_CASE (CreateRefNormalizationFloat32NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateRefNormalizationFloat32NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateRefNormalizationUint8NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateRefNormalizationUint8NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateRefNormalizationInt16NchwWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateRefNormalizationInt16NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dFloat32NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dUint8NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dInt16Workload)
 
 BOOST_AUTO_TEST_CASE (CreatePooling2dInt16NhwcWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateSoftmaxFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSoftmaxFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSoftmaxQuantisedAsymm8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSoftmaxQuantisedSymm16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSplitterFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSplitterFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSplitterUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateSplitterConcatFloat32)
 
 BOOST_AUTO_TEST_CASE (CreateSplitterConcatFloat16)
 
 BOOST_AUTO_TEST_CASE (CreateSplitterConcatUint8)
 
 BOOST_AUTO_TEST_CASE (CreateSingleOutputMultipleInputsFloat32)
 
 BOOST_AUTO_TEST_CASE (CreateSingleOutputMultipleInputsUint8)
 
 BOOST_AUTO_TEST_CASE (CreateResizeBilinearFloat32)
 
 BOOST_AUTO_TEST_CASE (CreateResizeBilinearFloat16)
 
 BOOST_AUTO_TEST_CASE (CreateResizeBilinearUint8)
 
 BOOST_AUTO_TEST_CASE (CreateResizeBilinearQuantisedAsymm16)
 
 BOOST_AUTO_TEST_CASE (CreateResizeBilinearFloat32Nhwc)
 
 BOOST_AUTO_TEST_CASE (CreateBatchToSpaceNdFloat32)
 
 BOOST_AUTO_TEST_CASE (CreateBatchToSpaceNdFloat16)
 
 BOOST_AUTO_TEST_CASE (CreateBatchToSpaceNdUint8)
 
 BOOST_AUTO_TEST_CASE (CreateBatchToSpaceNdQSymm16)
 
 BOOST_AUTO_TEST_CASE (CreateL2NormalizationFloat32)
 
 BOOST_AUTO_TEST_CASE (CreateL2NormalizationFloat32Nhwc)
 
 BOOST_AUTO_TEST_CASE (CreateL2NormalizationInt16)
 
 BOOST_AUTO_TEST_CASE (CreateL2NormalizationInt16Nhwc)
 
 BOOST_AUTO_TEST_CASE (CreateL2NormalizationUint8)
 
 BOOST_AUTO_TEST_CASE (CreateL2NormalizationUint8Nhwc)
 
 BOOST_AUTO_TEST_CASE (CreateReshapeWorkloadFloat32)
 
 BOOST_AUTO_TEST_CASE (CreateReshapeWorkloadQuantisedAsymm8)
 
 BOOST_AUTO_TEST_CASE (CreateReshapeWorkloadQuantisedSymm16)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim0Float32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim0Float16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim0Uint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim0Uint16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim1Float32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim1Uint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim2Float32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim2Uint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim3Float32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConcatDim3Uint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConstantUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConstantInt16Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConstantFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateConstantSigned32Workload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluFloat16Workload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluInt16Workload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluFloat32NoBroadcastWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluFloat16NoBroadcastWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluUint8NoBroadcastWorkload)
 
 BOOST_AUTO_TEST_CASE (CreatePreluInt16NoBroadcastWorkload)
 
 BOOST_AUTO_TEST_CASE (CreateSpaceToDepthWorkloadFloat32)
 
 BOOST_AUTO_TEST_CASE (CreateSpaceToDepthWorkloadFloat16)
 
 BOOST_AUTO_TEST_CASE (CreateSpaceToDepthWorkloadQASymm8)
 
 BOOST_AUTO_TEST_CASE (CreateSpaceToDepthWorkloadQSymm16)
 
 BOOST_AUTO_TEST_CASE (CreateStackFloat32Workload)
 
 BOOST_AUTO_TEST_CASE (CreateStackUint8Workload)
 
 BOOST_AUTO_TEST_CASE (CreateStackUint16Workload)
 
+

Function Documentation

+ +

◆ BOOST_AUTO_TEST_CASE() [1/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateActivationFloat32Workload )
+
+ +

Definition at line 64 of file RefCreateWorkloadTests.cpp.

+
65 {
66  RefCreateActivationWorkloadTest<RefActivationWorkload, armnn::DataType::Float32>();
67 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [2/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateActivationUint8Workload )
+
+ +

Definition at line 69 of file RefCreateWorkloadTests.cpp.

+
70 {
71  RefCreateActivationWorkloadTest<RefActivationWorkload, armnn::DataType::QAsymmU8>();
72 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [3/103]

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

Definition at line 91 of file RefCreateWorkloadTests.cpp.

+
92 {
93  RefCreateElementwiseWorkloadTest<RefAdditionWorkload,
94  AdditionQueueDescriptor,
95  AdditionLayer,
96  armnn::DataType::Float32>();
97 }
armnn::RefAdditionWorkload
RefElementwiseWorkload< std::plus< float >, AdditionQueueDescriptor, StringMapping::RefAdditionWorkload_Execute > RefAdditionWorkload
Definition: RefElementwiseWorkload.hpp:41
+ +
armnn::AdditionLayer
This layer represents an addition operation.
Definition: AdditionLayer.hpp:13
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [4/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateAdditionUint8Workload )
+
+ +

Definition at line 99 of file RefCreateWorkloadTests.cpp.

+
100 {
101  RefCreateElementwiseWorkloadTest<RefAdditionWorkload,
102  AdditionQueueDescriptor,
103  AdditionLayer,
104  armnn::DataType::QAsymmU8>();
105 }
armnn::RefAdditionWorkload
RefElementwiseWorkload< std::plus< float >, AdditionQueueDescriptor, StringMapping::RefAdditionWorkload_Execute > RefAdditionWorkload
Definition: RefElementwiseWorkload.hpp:41
+ + +
armnn::AdditionLayer
This layer represents an addition operation.
Definition: AdditionLayer.hpp:13
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [5/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateAdditionInt16Workload )
+
+ +

Definition at line 107 of file RefCreateWorkloadTests.cpp.

+
108 {
109  RefCreateElementwiseWorkloadTest<RefAdditionWorkload,
110  AdditionQueueDescriptor,
111  AdditionLayer,
112  armnn::DataType::QSymmS16>();
113 }
armnn::RefAdditionWorkload
RefElementwiseWorkload< std::plus< float >, AdditionQueueDescriptor, StringMapping::RefAdditionWorkload_Execute > RefAdditionWorkload
Definition: RefElementwiseWorkload.hpp:41
+ + +
armnn::AdditionLayer
This layer represents an addition operation.
Definition: AdditionLayer.hpp:13
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [6/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSubtractionFloat32Workload )
+
+ +

Definition at line 115 of file RefCreateWorkloadTests.cpp.

+
116 {
117  RefCreateElementwiseWorkloadTest<RefSubtractionWorkload,
118  SubtractionQueueDescriptor,
119  SubtractionLayer,
120  armnn::DataType::Float32>();
121 }
armnn::RefSubtractionWorkload
RefElementwiseWorkload< std::minus< float >, SubtractionQueueDescriptor, StringMapping::RefSubtractionWorkload_Execute > RefSubtractionWorkload
Definition: RefElementwiseWorkload.hpp:46
+ +
armnn::SubtractionLayer
This layer represents a subtraction operation.
Definition: SubtractionLayer.hpp:14
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [7/103]

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

Definition at line 123 of file RefCreateWorkloadTests.cpp.

+
124 {
125  RefCreateElementwiseWorkloadTest<RefSubtractionWorkload,
126  SubtractionQueueDescriptor,
127  SubtractionLayer,
128  armnn::DataType::Float16>();
129 }
armnn::RefSubtractionWorkload
RefElementwiseWorkload< std::minus< float >, SubtractionQueueDescriptor, StringMapping::RefSubtractionWorkload_Execute > RefSubtractionWorkload
Definition: RefElementwiseWorkload.hpp:46
+ + +
armnn::SubtractionLayer
This layer represents a subtraction operation.
Definition: SubtractionLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [8/103]

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

Definition at line 131 of file RefCreateWorkloadTests.cpp.

+
132 {
133  RefCreateElementwiseWorkloadTest<RefSubtractionWorkload,
134  SubtractionQueueDescriptor,
135  SubtractionLayer,
136  armnn::DataType::QAsymmU8>();
137 }
armnn::RefSubtractionWorkload
RefElementwiseWorkload< std::minus< float >, SubtractionQueueDescriptor, StringMapping::RefSubtractionWorkload_Execute > RefSubtractionWorkload
Definition: RefElementwiseWorkload.hpp:46
+ + +
armnn::SubtractionLayer
This layer represents a subtraction operation.
Definition: SubtractionLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [9/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSubtractionInt16Workload )
+
+ +

Definition at line 139 of file RefCreateWorkloadTests.cpp.

+
140 {
141  RefCreateElementwiseWorkloadTest<RefSubtractionWorkload,
142  SubtractionQueueDescriptor,
143  SubtractionLayer,
144  armnn::DataType::QSymmS16>();
145 }
armnn::RefSubtractionWorkload
RefElementwiseWorkload< std::minus< float >, SubtractionQueueDescriptor, StringMapping::RefSubtractionWorkload_Execute > RefSubtractionWorkload
Definition: RefElementwiseWorkload.hpp:46
+ + +
armnn::SubtractionLayer
This layer represents a subtraction operation.
Definition: SubtractionLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [10/103]

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

Definition at line 147 of file RefCreateWorkloadTests.cpp.

+
148 {
149  RefCreateElementwiseWorkloadTest<RefMultiplicationWorkload,
150  MultiplicationQueueDescriptor,
151  MultiplicationLayer,
152  armnn::DataType::Float32>();
153 }
+
armnn::RefMultiplicationWorkload
RefElementwiseWorkload< std::multiplies< float >, MultiplicationQueueDescriptor, StringMapping::RefMultiplicationWorkload_Execute > RefMultiplicationWorkload
Definition: RefElementwiseWorkload.hpp:51
+ +
armnn::MultiplicationLayer
This layer represents a multiplication operation.
Definition: MultiplicationLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [11/103]

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

Definition at line 155 of file RefCreateWorkloadTests.cpp.

+
156 {
157  RefCreateElementwiseWorkloadTest<RefMultiplicationWorkload,
158  MultiplicationQueueDescriptor,
159  MultiplicationLayer,
160  armnn::DataType::QAsymmU8>();
161 }
+
armnn::RefMultiplicationWorkload
RefElementwiseWorkload< std::multiplies< float >, MultiplicationQueueDescriptor, StringMapping::RefMultiplicationWorkload_Execute > RefMultiplicationWorkload
Definition: RefElementwiseWorkload.hpp:51
+ +
armnn::MultiplicationLayer
This layer represents a multiplication operation.
Definition: MultiplicationLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [12/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateMultiplicationInt16Workload )
+
+ +

Definition at line 163 of file RefCreateWorkloadTests.cpp.

+
164 {
165  RefCreateElementwiseWorkloadTest<RefMultiplicationWorkload,
166  MultiplicationQueueDescriptor,
167  MultiplicationLayer,
168  armnn::DataType::QSymmS16>();
169 }
+
armnn::RefMultiplicationWorkload
RefElementwiseWorkload< std::multiplies< float >, MultiplicationQueueDescriptor, StringMapping::RefMultiplicationWorkload_Execute > RefMultiplicationWorkload
Definition: RefElementwiseWorkload.hpp:51
+ +
armnn::MultiplicationLayer
This layer represents a multiplication operation.
Definition: MultiplicationLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [13/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateDivisionFloat32Workload )
+
+ +

Definition at line 171 of file RefCreateWorkloadTests.cpp.

+
172 {
173  RefCreateElementwiseWorkloadTest<RefDivisionWorkload,
174  DivisionQueueDescriptor,
175  DivisionLayer,
176  armnn::DataType::Float32>();
177 }
armnn::RefDivisionWorkload
RefElementwiseWorkload< std::divides< float >, DivisionQueueDescriptor, StringMapping::RefDivisionWorkload_Execute > RefDivisionWorkload
Definition: RefElementwiseWorkload.hpp:56
+ +
armnn::DivisionLayer
This layer represents a division operation.
Definition: DivisionLayer.hpp:14
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [14/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateDivisionFloat16Workload )
+
+ +

Definition at line 179 of file RefCreateWorkloadTests.cpp.

+
180 {
181  RefCreateElementwiseWorkloadTest<RefDivisionWorkload,
182  DivisionQueueDescriptor,
183  DivisionLayer,
184  armnn::DataType::Float16>();
185 }
armnn::RefDivisionWorkload
RefElementwiseWorkload< std::divides< float >, DivisionQueueDescriptor, StringMapping::RefDivisionWorkload_Execute > RefDivisionWorkload
Definition: RefElementwiseWorkload.hpp:56
+ + +
armnn::DivisionLayer
This layer represents a division operation.
Definition: DivisionLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [15/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateDivisionUint8Workload )
+
+ +

Definition at line 187 of file RefCreateWorkloadTests.cpp.

+
188 {
189  RefCreateElementwiseWorkloadTest<RefDivisionWorkload,
190  DivisionQueueDescriptor,
191  DivisionLayer,
192  armnn::DataType::QAsymmU8>();
193 }
armnn::RefDivisionWorkload
RefElementwiseWorkload< std::divides< float >, DivisionQueueDescriptor, StringMapping::RefDivisionWorkload_Execute > RefDivisionWorkload
Definition: RefElementwiseWorkload.hpp:56
+ + +
armnn::DivisionLayer
This layer represents a division operation.
Definition: DivisionLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [16/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateDivisionInt16Workload )
+
+ +

Definition at line 195 of file RefCreateWorkloadTests.cpp.

+
196 {
197  RefCreateElementwiseWorkloadTest<RefDivisionWorkload,
198  DivisionQueueDescriptor,
199  DivisionLayer,
200  armnn::DataType::QSymmS16>();
201 }
armnn::RefDivisionWorkload
RefElementwiseWorkload< std::divides< float >, DivisionQueueDescriptor, StringMapping::RefDivisionWorkload_Execute > RefDivisionWorkload
Definition: RefElementwiseWorkload.hpp:56
+ + +
armnn::DivisionLayer
This layer represents a division operation.
Definition: DivisionLayer.hpp:14
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [17/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloat32Workload )
+
+ +

Definition at line 232 of file RefCreateWorkloadTests.cpp.

+
233 {
234  RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload,armnn::DataType::Float32>
235  (DataLayout::NCHW);
236 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [18/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloat32WorkloadNhwc )
+
+ +

Definition at line 238 of file RefCreateWorkloadTests.cpp.

+
239 {
240  RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::Float32>
241  (DataLayout::NHWC);
242 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [19/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloat16Workload )
+
+ +

Definition at line 244 of file RefCreateWorkloadTests.cpp.

+
245 {
246  RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload,armnn::DataType::Float16>
247  (DataLayout::NCHW);
248 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [20/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchNormalizationFloat16WorkloadNhwc )
+
+ +

Definition at line 250 of file RefCreateWorkloadTests.cpp.

+
251 {
252  RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::Float16>
253  (DataLayout::NHWC);
254 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [21/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchNormalizationUint8Workload )
+
+ +

Definition at line 256 of file RefCreateWorkloadTests.cpp.

+
257 {
258  RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QAsymmU8>
259  (DataLayout::NCHW);
260 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [22/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchNormalizationUint8WorkloadNhwc )
+
+ +

Definition at line 262 of file RefCreateWorkloadTests.cpp.

+
263 {
264  RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QAsymmU8>
265  (DataLayout::NHWC);
266 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [23/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchNormalizationInt16Workload )
+
+ +

Definition at line 268 of file RefCreateWorkloadTests.cpp.

+
269 {
270  RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QSymmS16>
271  (DataLayout::NCHW);
272 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [24/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchNormalizationInt16WorkloadNhwc )
+
+ +

Definition at line 274 of file RefCreateWorkloadTests.cpp.

+
275 {
276  RefCreateBatchNormalizationWorkloadTest<RefBatchNormalizationWorkload, armnn::DataType::QSymmS16>
277  (DataLayout::NHWC);
278 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [25/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConvertFp16ToFp32Float32Workload )
+
+ +

Definition at line 280 of file RefCreateWorkloadTests.cpp.

+
281 {
282  Graph graph;
283  RefWorkloadFactory factory = GetFactory();
284  auto workload = CreateConvertFp16ToFp32WorkloadTest<RefConvertFp16ToFp32Workload>(factory, graph);
285 
286  // Checks that outputs and inputs are as we expect them
287  CheckInputOutput(
288  std::move(workload), TensorInfo({1, 3, 2, 3}, DataType::Float16), TensorInfo({1, 3, 2, 3}, DataType::Float32));
289 }
+ + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [26/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConvertFp32ToFp16Float16Workload )
+
+ +

Definition at line 291 of file RefCreateWorkloadTests.cpp.

+
292 {
293  Graph graph;
294  RefWorkloadFactory factory = GetFactory();
295  auto workload = CreateConvertFp32ToFp16WorkloadTest<RefConvertFp32ToFp16Workload>(factory, graph);
296 
297  // Checks that outputs and inputs are as we expect them
298  CheckInputOutput(
299  std::move(workload), TensorInfo({1, 3, 2, 3}, DataType::Float32), TensorInfo({1, 3, 2, 3}, DataType::Float16));
300 }
+ + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [27/103]

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

Definition at line 320 of file RefCreateWorkloadTests.cpp.

+
321 {
322  RefCreateConvolution2dWorkloadTest(DataLayout::NCHW);
323 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [28/103]

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

Definition at line 325 of file RefCreateWorkloadTests.cpp.

+
326 {
327  RefCreateConvolution2dWorkloadTest(DataLayout::NHWC);
328 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [29/103]

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

Definition at line 348 of file RefCreateWorkloadTests.cpp.

+
349 {
350  RefCreateDepthwiseConvolutionWorkloadTest(DataLayout::NHWC);
351 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [30/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateFullyConnectedWorkloadFloat32 )
+
+ +

Definition at line 368 of file RefCreateWorkloadTests.cpp.

+
369 {
370  RefCreateFullyConnectedWorkloadTest<RefFullyConnectedWorkload, armnn::DataType::Float32>();
371 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [31/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateFullyConnectedWorkloadQuantisedAsymm8 )
+
+ +

Definition at line 373 of file RefCreateWorkloadTests.cpp.

+
374 {
375  RefCreateFullyConnectedWorkloadTest<RefFullyConnectedWorkload, armnn::DataType::QAsymmU8>();
376 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [32/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateFullyConnectedWorkloadQuantisedSymm16 )
+
+ +

Definition at line 378 of file RefCreateWorkloadTests.cpp.

+
379 {
380  RefCreateFullyConnectedWorkloadTest<RefFullyConnectedWorkload, armnn::DataType::QSymmS16>();
381 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [33/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateRefNormalizationFloat32NchwWorkload )
+
+ +

Definition at line 410 of file RefCreateWorkloadTests.cpp.

+
411 {
412  RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
413 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [34/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateRefNormalizationFloat32NhwcWorkload )
+
+ +

Definition at line 415 of file RefCreateWorkloadTests.cpp.

+
416 {
417  RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
418 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [35/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateRefNormalizationUint8NchwWorkload )
+
+ +

Definition at line 420 of file RefCreateWorkloadTests.cpp.

+
421 {
422  RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
423 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [36/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateRefNormalizationUint8NhwcWorkload )
+
+ +

Definition at line 425 of file RefCreateWorkloadTests.cpp.

+
426 {
427  RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
428 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [37/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateRefNormalizationInt16NchwWorkload )
+
+ +

Definition at line 430 of file RefCreateWorkloadTests.cpp.

+
431 {
432  RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::QSymmS16>(DataLayout::NCHW);
433 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [38/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateRefNormalizationInt16NhwcWorkload )
+
+ +

Definition at line 435 of file RefCreateWorkloadTests.cpp.

+
436 {
437  RefCreateNormalizationWorkloadTest<RefNormalizationWorkload, armnn::DataType::QSymmS16>(DataLayout::NHWC);
438 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [39/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePooling2dFloat32Workload )
+
+ +

Definition at line 468 of file RefCreateWorkloadTests.cpp.

+
469 {
470  RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
471 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [40/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePooling2dFloat32NhwcWorkload )
+
+ +

Definition at line 473 of file RefCreateWorkloadTests.cpp.

+
474 {
475  RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
476 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [41/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePooling2dUint8Workload )
+
+ +

Definition at line 478 of file RefCreateWorkloadTests.cpp.

+
479 {
480  RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
481 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [42/103]

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

Definition at line 483 of file RefCreateWorkloadTests.cpp.

+
484 {
485  RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
486 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [43/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePooling2dInt16Workload )
+
+ +

Definition at line 488 of file RefCreateWorkloadTests.cpp.

+
489 {
490  RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::QSymmS16>(DataLayout::NCHW);
491 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [44/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePooling2dInt16NhwcWorkload )
+
+ +

Definition at line 493 of file RefCreateWorkloadTests.cpp.

+
494 {
495  RefCreatePooling2dWorkloadTest<RefPooling2dWorkload, armnn::DataType::QSymmS16>(DataLayout::NHWC);
496 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [45/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSoftmaxFloat32Workload )
+
+ +

Definition at line 512 of file RefCreateWorkloadTests.cpp.

+
513 {
514  RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::Float32>();
515 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [46/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSoftmaxFloat16Workload )
+
+ +

Definition at line 517 of file RefCreateWorkloadTests.cpp.

+
518 {
519  RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::Float16>();
520 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [47/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSoftmaxQuantisedAsymm8Workload )
+
+ +

Definition at line 522 of file RefCreateWorkloadTests.cpp.

+
523 {
524  RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::QAsymmU8>();
525 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [48/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSoftmaxQuantisedSymm16Workload )
+
+ +

Definition at line 527 of file RefCreateWorkloadTests.cpp.

+
528 {
529  RefCreateSoftmaxWorkloadTest<RefSoftmaxWorkload, armnn::DataType::QSymmS16>();
530 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [49/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSplitterFloat32Workload )
+
+ +

Definition at line 554 of file RefCreateWorkloadTests.cpp.

+
555 {
556  RefCreateSplitterWorkloadTest<RefSplitterWorkload, armnn::DataType::Float32>();
557 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [50/103]

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

Definition at line 559 of file RefCreateWorkloadTests.cpp.

+
560 {
561  RefCreateSplitterWorkloadTest<RefSplitterWorkload, armnn::DataType::Float16>();
562 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [51/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSplitterUint8Workload )
+
+ +

Definition at line 564 of file RefCreateWorkloadTests.cpp.

+
565 {
566  RefCreateSplitterWorkloadTest<RefSplitterWorkload, armnn::DataType::QAsymmU8>();
567 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [52/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSplitterConcatFloat32 )
+
+ +

Definition at line 602 of file RefCreateWorkloadTests.cpp.

+
603 {
604  RefCreateSplitterConcatWorkloadTest<RefSplitterWorkload, RefConcatWorkload, DataType::Float32>();
605 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [53/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSplitterConcatFloat16 )
+
+ +

Definition at line 607 of file RefCreateWorkloadTests.cpp.

+
608 {
609  RefCreateSplitterConcatWorkloadTest<RefSplitterWorkload, RefConcatWorkload, DataType::Float16>();
610 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [54/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSplitterConcatUint8 )
+
+ +

Definition at line 612 of file RefCreateWorkloadTests.cpp.

+
613 {
614  RefCreateSplitterConcatWorkloadTest<RefSplitterWorkload, RefConcatWorkload, DataType::QAsymmU8>();
615 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [55/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSingleOutputMultipleInputsFloat32 )
+
+ +

Definition at line 655 of file RefCreateWorkloadTests.cpp.

+
656 {
657  RefCreateSingleOutputMultipleInputsTest<RefSplitterWorkload, RefActivationWorkload,
658  armnn::DataType::Float32>();
659 }
+ + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [56/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSingleOutputMultipleInputsUint8 )
+
+ +

Definition at line 661 of file RefCreateWorkloadTests.cpp.

+
662 {
663  RefCreateSingleOutputMultipleInputsTest<RefSplitterWorkload, RefActivationWorkload,
664  armnn::DataType::QAsymmU8>();
665 }
+ + +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [57/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateResizeBilinearFloat32 )
+
+ +

Definition at line 695 of file RefCreateWorkloadTests.cpp.

+
696 {
697  RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
698 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [58/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateResizeBilinearFloat16 )
+
+ +

Definition at line 700 of file RefCreateWorkloadTests.cpp.

+
701 {
702  RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::Float16>(DataLayout::NCHW);
703 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [59/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateResizeBilinearUint8 )
+
+ +

Definition at line 705 of file RefCreateWorkloadTests.cpp.

+
706 {
707  RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
708 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [60/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateResizeBilinearQuantisedAsymm16 )
+
+ +

Definition at line 710 of file RefCreateWorkloadTests.cpp.

+
711 {
712  RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::QSymmS16>(DataLayout::NCHW);
713 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [61/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateResizeBilinearFloat32Nhwc )
+
+ +

Definition at line 715 of file RefCreateWorkloadTests.cpp.

+
716 {
717  RefCreateResizeBilinearTest<RefResizeWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
718 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [62/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchToSpaceNdFloat32 )
+
+ +

Definition at line 733 of file RefCreateWorkloadTests.cpp.

+
734 {
735  RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::Float32>();
736 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [63/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchToSpaceNdFloat16 )
+
+ +

Definition at line 738 of file RefCreateWorkloadTests.cpp.

+
739 {
740  RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::Float16>();
741 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [64/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchToSpaceNdUint8 )
+
+ +

Definition at line 743 of file RefCreateWorkloadTests.cpp.

+
744 {
745  RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::QAsymmU8>();
746 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [65/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateBatchToSpaceNdQSymm16 )
+
+ +

Definition at line 748 of file RefCreateWorkloadTests.cpp.

+
749 {
750  RefCreateBatchToSpaceNdTest<RefBatchToSpaceNdWorkload, armnn::DataType::QSymmS16>();
751 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [66/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateL2NormalizationFloat32 )
+
+ +

Definition at line 781 of file RefCreateWorkloadTests.cpp.

+
782 {
783  RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::Float32>(DataLayout::NCHW);
784 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [67/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateL2NormalizationFloat32Nhwc )
+
+ +

Definition at line 786 of file RefCreateWorkloadTests.cpp.

+
787 {
788  RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::Float32>(DataLayout::NHWC);
789 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [68/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateL2NormalizationInt16 )
+
+ +

Definition at line 791 of file RefCreateWorkloadTests.cpp.

+
792 {
793  RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::QSymmS16>(DataLayout::NCHW);
794 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [69/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateL2NormalizationInt16Nhwc )
+
+ +

Definition at line 796 of file RefCreateWorkloadTests.cpp.

+
797 {
798  RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::QSymmS16>(DataLayout::NHWC);
799 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [70/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateL2NormalizationUint8 )
+
+ +

Definition at line 801 of file RefCreateWorkloadTests.cpp.

+
802 {
803  RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::QAsymmU8>(DataLayout::NCHW);
804 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [71/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateL2NormalizationUint8Nhwc )
+
+ +

Definition at line 806 of file RefCreateWorkloadTests.cpp.

+
807 {
808  RefCreateL2NormalizationTest<RefL2NormalizationWorkload, armnn::DataType::QAsymmU8>(DataLayout::NHWC);
809 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [72/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateReshapeWorkloadFloat32 )
+
+ +

Definition at line 825 of file RefCreateWorkloadTests.cpp.

+
826 {
827  RefCreateReshapeWorkloadTest<RefReshapeWorkload, armnn::DataType::Float32>();
828 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [73/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateReshapeWorkloadQuantisedAsymm8 )
+
+ +

Definition at line 830 of file RefCreateWorkloadTests.cpp.

+
831 {
832  RefCreateReshapeWorkloadTest<RefReshapeWorkload, armnn::DataType::QAsymmU8>();
833 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [74/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateReshapeWorkloadQuantisedSymm16 )
+
+ +

Definition at line 835 of file RefCreateWorkloadTests.cpp.

+
836 {
837  RefCreateReshapeWorkloadTest<RefReshapeWorkload, armnn::DataType::QSymmS16>();
838 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [75/103]

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

Definition at line 854 of file RefCreateWorkloadTests.cpp.

+
855 {
856  RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 4, 3, 2, 5 }, 0);
857 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [76/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConcatDim0Float16Workload )
+
+ +

Definition at line 859 of file RefCreateWorkloadTests.cpp.

+
860 {
861  RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float16>({ 4, 3, 2, 5 }, 0);
862 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [77/103]

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

Definition at line 864 of file RefCreateWorkloadTests.cpp.

+
865 {
866  RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QAsymmU8>({ 4, 3, 2, 5 }, 0);
867 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [78/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConcatDim0Uint16Workload )
+
+ +

Definition at line 869 of file RefCreateWorkloadTests.cpp.

+
870 {
871  RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QSymmS16>({ 4, 3, 2, 5 }, 0);
872 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [79/103]

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

Definition at line 874 of file RefCreateWorkloadTests.cpp.

+
875 {
876  RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 2, 6, 2, 5 }, 1);
877 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [80/103]

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

Definition at line 879 of file RefCreateWorkloadTests.cpp.

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

◆ BOOST_AUTO_TEST_CASE() [81/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConcatDim2Float32Workload )
+
+ +

Definition at line 884 of file RefCreateWorkloadTests.cpp.

+
885 {
886  RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 2, 3, 4, 5 }, 2);
887 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [82/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConcatDim2Uint8Workload )
+
+ +

Definition at line 889 of file RefCreateWorkloadTests.cpp.

+
890 {
891  RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 4, 5 }, 2);
892 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [83/103]

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

Definition at line 894 of file RefCreateWorkloadTests.cpp.

+
895 {
896  RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 }, 3);
897 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [84/103]

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

Definition at line 899 of file RefCreateWorkloadTests.cpp.

+
900 {
901  RefCreateConcatWorkloadTest<RefConcatWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 }, 3);
902 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [85/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConstantUint8Workload )
+
+ +

Definition at line 917 of file RefCreateWorkloadTests.cpp.

+
918 {
919  RefCreateConstantWorkloadTest<RefConstantWorkload, armnn::DataType::QAsymmU8>({ 2, 3, 2, 10 });
920 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [86/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConstantInt16Workload )
+
+ +

Definition at line 922 of file RefCreateWorkloadTests.cpp.

+
923 {
924  RefCreateConstantWorkloadTest<RefConstantWorkload, armnn::DataType::QSymmS16>({ 2, 3, 2, 10 });
925 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [87/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConstantFloat32Workload )
+
+ +

Definition at line 927 of file RefCreateWorkloadTests.cpp.

+
928 {
929  RefCreateConstantWorkloadTest<RefConstantWorkload, armnn::DataType::Float32>({ 2, 3, 2, 10 });
930 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [88/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateConstantSigned32Workload )
+
+ +

Definition at line 932 of file RefCreateWorkloadTests.cpp.

+
933 {
934  RefCreateConstantWorkloadTest<RefConstantWorkload, armnn::DataType::Signed32>({ 2, 3, 2, 10 });
935 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [89/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePreluFloat32Workload )
+
+ +

Definition at line 957 of file RefCreateWorkloadTests.cpp.

+
958 {
959  RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, armnn::DataType::Float32);
960 }
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [90/103]

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

Definition at line 962 of file RefCreateWorkloadTests.cpp.

+
963 {
964  RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, armnn::DataType::Float16);
965 }
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [91/103]

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

Definition at line 967 of file RefCreateWorkloadTests.cpp.

+
968 {
969  RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, armnn::DataType::QAsymmU8);
970 }
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [92/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePreluInt16Workload )
+
+ +

Definition at line 972 of file RefCreateWorkloadTests.cpp.

+
973 {
974  RefCreatePreluWorkloadTest({ 1, 4, 1, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 }, armnn::DataType::QSymmS16);
975 }
+
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [93/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePreluFloat32NoBroadcastWorkload )
+
+ +

Definition at line 977 of file RefCreateWorkloadTests.cpp.

+
978 {
979  BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
980  armnn::DataType::Float32),
981  armnn::InvalidArgumentException);
982 }
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [94/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePreluFloat16NoBroadcastWorkload )
+
+ +

Definition at line 984 of file RefCreateWorkloadTests.cpp.

+
985 {
986  BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
987  armnn::DataType::Float16),
988  armnn::InvalidArgumentException);
989 }
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [95/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePreluUint8NoBroadcastWorkload )
+
+ +

Definition at line 991 of file RefCreateWorkloadTests.cpp.

+
992 {
993  BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
994  armnn::DataType::QAsymmU8),
995  armnn::InvalidArgumentException);
996 }
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [96/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreatePreluInt16NoBroadcastWorkload )
+
+ +

Definition at line 998 of file RefCreateWorkloadTests.cpp.

+
999 {
1000  BOOST_CHECK_THROW(RefCreatePreluWorkloadTest({ 1, 4, 7, 2 }, { 5, 4, 3, 1 }, { 5, 4, 3, 2 },
1001  armnn::DataType::QSymmS16),
1002  armnn::InvalidArgumentException);
1003 }
+ +
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [97/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSpaceToDepthWorkloadFloat32 )
+
+ +

Definition at line 1018 of file RefCreateWorkloadTests.cpp.

+
1019 {
1020  RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::Float32>();
1021 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [98/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSpaceToDepthWorkloadFloat16 )
+
+ +

Definition at line 1023 of file RefCreateWorkloadTests.cpp.

+
1024 {
1025  RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::Float16>();
1026 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [99/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSpaceToDepthWorkloadQASymm8 )
+
+ +

Definition at line 1028 of file RefCreateWorkloadTests.cpp.

+
1029 {
1030  RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::QAsymmU8>();
1031 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [100/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateSpaceToDepthWorkloadQSymm16 )
+
+ +

Definition at line 1033 of file RefCreateWorkloadTests.cpp.

+
1034 {
1035  RefCreateSpaceToDepthWorkloadTest<RefSpaceToDepthWorkload, armnn::DataType::QSymmS16>();
1036 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [101/103]

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

Definition at line 1064 of file RefCreateWorkloadTests.cpp.

+
1065 {
1066  RefCreateStackWorkloadTest<armnn::DataType::Float32>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1067 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [102/103]

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

Definition at line 1069 of file RefCreateWorkloadTests.cpp.

+
1070 {
1071  RefCreateStackWorkloadTest<armnn::DataType::QAsymmU8>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1072 }
+
+
+ +

◆ BOOST_AUTO_TEST_CASE() [103/103]

+ +
+
+ + + + + + + + +
BOOST_AUTO_TEST_CASE (CreateStackUint16Workload )
+
+ +

Definition at line 1074 of file RefCreateWorkloadTests.cpp.

+ +

References BOOST_AUTO_TEST_SUITE_END().

+
1075 {
1076  RefCreateStackWorkloadTest<armnn::DataType::QSymmS16>({ 3, 4, 5 }, { 3, 4, 2, 5 }, 2, 2);
1077 }
+
+
+
+
+ + + + -- cgit v1.2.1