Compute Library
 23.08
ArithmeticAddition.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017-2023 Arm Limited.
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to
8  * deal in the Software without restriction, including without limitation the
9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10  * sell copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in all
14  * copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22  * SOFTWARE.
23  */
24 #include "arm_compute/core/Types.h"
25 #include "arm_compute/core/utils/StringUtils.h"
26 #include "arm_compute/runtime/NEON/functions/NEArithmeticAddition.h"
27 #include "arm_compute/runtime/Tensor.h"
28 #include "arm_compute/runtime/TensorAllocator.h"
29 #include "src/common/cpuinfo/CpuIsaInfo.h"
30 #include "src/cpu/kernels/CpuAddKernel.h"
31 #include "tests/NEON/Accessor.h"
32 #include "tests/PaddingCalculator.h"
33 #include "tests/datasets/ConvertPolicyDataset.h"
34 #include "tests/datasets/ShapeDatasets.h"
35 #include "tests/framework/Asserts.h"
36 #include "tests/framework/Macros.h"
37 #include "tests/framework/datasets/Datasets.h"
38 #include "tests/validation/Validation.h"
39 #include "tests/validation/fixtures/ArithmeticOperationsFixture.h"
40 
41 namespace arm_compute
42 {
43 namespace test
44 {
45 namespace validation
46 {
47 namespace
48 {
49 #if !defined(__aarch64__) || defined(ENABLE_SVE)
50 constexpr AbsoluteTolerance<float> tolerance_quant(1); /**< Tolerance value for comparing reference's output against implementation's output for quantized data types */
51 #else // !defined(__aarch64__) || defined(ENABLE_SVE)
52 constexpr AbsoluteTolerance<float> tolerance_quant(0);
53 #endif // !defined(__aarch64__) || defined(ENABLE_SVE)
54 const auto InPlaceDataSet = framework::dataset::make("InPlace", { false, true });
55 const auto OutOfPlaceDataSet = framework::dataset::make("InPlace", { false });
56 } // namespace
57 
58 TEST_SUITE(NEON)
59 TEST_SUITE(ArithmeticAddition)
60 
61 template <typename T>
62 using NEArithmeticAdditionFixture = ArithmeticAdditionValidationFixture<Tensor, Accessor, NEArithmeticAddition, T>;
63 
64 // *INDENT-OFF*
65 // clang-format off
66 DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip(
67  framework::dataset::make("Input1Info", { TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32),
68  TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8), // Unsupported broadcast
69  TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), // Invalid data type combination
70  TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32),// Mismatching shapes
71  }),
72  framework::dataset::make("Input2Info",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32),
73  TensorInfo(TensorShape(1U, 13U, 2U), 1, DataType::S16),
74  TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::S16),
75  TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32),
76  })),
77  framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32),
78  TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::S16),
79  TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),
80  TensorInfo(TensorShape(48U, 11U, 2U), 1, DataType::F32),
81  })),
82  framework::dataset::make("Expected", { true, false, false, false})),
83  input1_info, input2_info, output_info, expected)
84 {
85  Status s = NEArithmeticAddition::validate(&input1_info.clone()->set_is_resizable(false),
86  &input2_info.clone()->set_is_resizable(false),
87  &output_info.clone()->set_is_resizable(false),
88  ConvertPolicy::WRAP);
89  ARM_COMPUTE_EXPECT(bool(s) == expected, framework::LogLevel::ERRORS);
90 }
91 
92 DATA_TEST_CASE(KernelSelection, framework::DatasetMode::ALL, concat(concat(
93  combine(combine(framework::dataset::make("CpuExt", std::string("NEON")),
94  framework::dataset::make("DataType", { DataType::F32,
95  DataType::F16,
96  DataType::U8,
97  DataType::S16,
98  DataType::S32,
99  DataType::QASYMM8,
100  DataType::QASYMM8_SIGNED,
101  DataType::QSYMM16
102  })),
103  framework::dataset::make("CanUseFixedpoint", {true, false})),
104  combine(combine(framework::dataset::make("CpuExt", std::string("SVE")),
105  framework::dataset::make("DataType", { DataType::F32,
106  DataType::F16,
107  DataType::U8,
108  DataType::S16,
109  DataType::S32
110  })),
111  framework::dataset::make("CanUseFixedpoint", {true, false}))),
112  combine(combine(framework::dataset::make("CpuExt", std::string("SVE2")),
113  framework::dataset::make("DataType", { DataType::QASYMM8,
114  DataType::QASYMM8_SIGNED,
115  DataType::QSYMM16
116  })),
117  framework::dataset::make("CanUseFixedpoint", {true, false}))),
118  cpu_ext, data_type, can_use_fixedpoint)
119 {
120  using namespace cpu::kernels;
121 
122  cpuinfo::CpuIsaInfo cpu_isa{};
123  cpu_isa.neon = (cpu_ext == "NEON");
124  cpu_isa.sve = (cpu_ext == "SVE");
125  cpu_isa.sve2 = (cpu_ext == "SVE2");
126  cpu_isa.fp16 = (data_type == DataType::F16);
127 
128  const auto *selected_impl = CpuAddKernel::get_implementation(CpuAddKernelDataTypeISASelectorData{data_type, cpu_isa, can_use_fixedpoint}, cpu::KernelSelectionType::Preferred);
129 
130  ARM_COMPUTE_ERROR_ON_NULLPTR(selected_impl);
131 
132  bool qasymm8_any = (data_type == DataType::QASYMM8 || data_type == DataType::QASYMM8_SIGNED);
133 
134  std::string expected;
135  if(qasymm8_any && can_use_fixedpoint)
136  {
137  expected = "neon_" + cpu_impl_dt(data_type) + "_add_fixedpoint";
138  }
139  else
140  {
141  expected = lower_string(cpu_ext) + "_" + cpu_impl_dt(data_type) + "_add";
142  }
143 
144  std::string actual = selected_impl->name;
145 
146  ARM_COMPUTE_EXPECT_EQUAL(expected, actual, framework::LogLevel::ERRORS);
147 }
148 // clang-format on
149 // *INDENT-ON*
150 
151 TEST_CASE(NoPaddingAdded, framework::DatasetMode::PRECOMMIT)
152 {
153  // NEArithmeticAddition doesn't use padding, so make sure this is the case.
154  Tensor input1 = create_tensor<Tensor>(TensorShape(15U, 15U), DataType::F32);
155  Tensor input2 = create_tensor<Tensor>(TensorShape(15U, 1U), DataType::F32);
156  Tensor output = create_tensor<Tensor>(TensorShape(15U, 15U), DataType::F32);
157 
158  NEArithmeticAddition add;
159  add.configure(&input1, &input2, &output, ConvertPolicy::WRAP);
160 
161  // Validate padding is zero
162  validate(input1.info()->padding(), PaddingSize());
163  validate(input2.info()->padding(), PaddingSize());
164  validate(output.info()->padding(), PaddingSize());
165 }
166 
167 TEST_SUITE(Integer)
168 TEST_SUITE(U8)
169 FIXTURE_DATA_TEST_CASE(RunSmall, NEArithmeticAdditionFixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
170  DataType::U8)),
171  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
172  OutOfPlaceDataSet))
173 {
174  // Validate output
175  validate(Accessor(_target), _reference);
176 }
177 TEST_SUITE_END() // U8
178 
179 TEST_SUITE(S16)
180 FIXTURE_DATA_TEST_CASE(RunSmall, NEArithmeticAdditionFixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
181  DataType::S16)),
182  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
183  OutOfPlaceDataSet))
184 {
185  // Validate output
186  validate(Accessor(_target), _reference);
187 }
188 
189 FIXTURE_DATA_TEST_CASE(RunLarge, NEArithmeticAdditionFixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
190  DataType::S16)),
191  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
192  OutOfPlaceDataSet))
193 {
194  // Validate output
195  validate(Accessor(_target), _reference);
196 }
197 TEST_SUITE_END() // S16
198 
199 TEST_SUITE(S32)
200 FIXTURE_DATA_TEST_CASE(RunSmall, NEArithmeticAdditionFixture<int32_t>, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
201  DataType::S32)),
202  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
203  OutOfPlaceDataSet))
204 {
205  // Validate output
206  validate(Accessor(_target), _reference);
207 }
208 TEST_SUITE_END() // S32
209 TEST_SUITE_END() // Integer
210 
211 TEST_SUITE(Float)
212 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
213 TEST_SUITE(F16)
214 FIXTURE_DATA_TEST_CASE(RunSmall, NEArithmeticAdditionFixture<half>, framework::DatasetMode::ALL, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F16)),
215  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
216  OutOfPlaceDataSet))
217 {
218  // Validate output
219  validate(Accessor(_target), _reference);
220 }
221 TEST_SUITE_END() // F16
222 #endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */
223 
224 TEST_SUITE(F32)
225 FIXTURE_DATA_TEST_CASE(RunSmall, NEArithmeticAdditionFixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType",
226  DataType::F32)),
227  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
228  OutOfPlaceDataSet))
229 {
230  // Validate output
231  validate(Accessor(_target), _reference);
232 }
233 
234 FIXTURE_DATA_TEST_CASE(RunLarge, NEArithmeticAdditionFixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), framework::dataset::make("DataType",
235  DataType::F32)),
236  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
237  OutOfPlaceDataSet))
238 {
239  // Validate output
240  validate(Accessor(_target), _reference);
241 }
242 
243 template <typename T>
244 using NEArithmeticAdditionBroadcastFixture = ArithmeticAdditionBroadcastValidationFixture<Tensor, Accessor, NEArithmeticAddition, T>;
245 
246 FIXTURE_DATA_TEST_CASE(RunSmallBroadcast, NEArithmeticAdditionBroadcastFixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapesBroadcast(),
247  framework::dataset::make("DataType", DataType::F32)),
248  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
249  OutOfPlaceDataSet))
250 {
251  // Validate output
252  validate(Accessor(_target), _reference);
253 }
254 
255 FIXTURE_DATA_TEST_CASE(RunLargeBroadcast, NEArithmeticAdditionBroadcastFixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapesBroadcast(),
256  framework::dataset::make("DataType", DataType::F32)),
257  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
258  OutOfPlaceDataSet))
259 {
260  // Validate output
261  validate(Accessor(_target), _reference);
262 }
263 TEST_SUITE_END() // F32
264 TEST_SUITE_END() // Float
265 
266 template <typename T>
267 using NEArithmeticAdditionQuantizedFixture = ArithmeticAdditionValidationQuantizedFixture<Tensor, Accessor, NEArithmeticAddition, T>;
268 
269 template <typename T>
270 using NEArithmeticAdditionQuantizedBroadcastFixture = ArithmeticAdditionValidationQuantizedBroadcastFixture<Tensor, Accessor, NEArithmeticAddition, T>;
271 
272 TEST_SUITE(Quantized)
273 TEST_SUITE(QASYMM8)
274 FIXTURE_DATA_TEST_CASE(RunSmall,
275  NEArithmeticAdditionQuantizedFixture<uint8_t>,
276  framework::DatasetMode::PRECOMMIT,
277  combine(combine(combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::QASYMM8)),
278  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
279  framework::dataset::make("Src0QInfo", { QuantizationInfo(5.f / 255.f, 20) })),
280  framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f / 255.f, 10) })),
281  framework::dataset::make("OutQInfo", { QuantizationInfo(1.f / 255.f, 5) })),
282  OutOfPlaceDataSet))
283 {
284  // Validate output
285  validate(Accessor(_target), _reference, tolerance_quant);
286 }
287 TEST_SUITE_END() // QASYMM8
288 
289 TEST_SUITE(QASYMM8_SIGNED)
290 FIXTURE_DATA_TEST_CASE(RunSmall,
291  NEArithmeticAdditionQuantizedFixture<int8_t>,
292  framework::DatasetMode::ALL,
293  combine(combine(combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)),
294  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
295  framework::dataset::make("Src0QInfo", { QuantizationInfo(0.5f, 20) })),
296  framework::dataset::make("Src1QInfo", { QuantizationInfo(0.5f, 10) })),
297  framework::dataset::make("OutQInfo", { QuantizationInfo(0.5f, 5) })),
298  OutOfPlaceDataSet))
299 {
300  // Validate output
301  validate(Accessor(_target), _reference, tolerance_quant);
302 }
303 
304 FIXTURE_DATA_TEST_CASE(RunSmallBroadcast, NEArithmeticAdditionQuantizedBroadcastFixture<int8_t>, framework::DatasetMode::ALL, combine(combine(combine(combine(combine(combine(
305  datasets::SmallShapesBroadcast(), framework::dataset::make("DataType", DataType::QASYMM8_SIGNED)),
306  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
307  framework::dataset::make("Src0QInfo", { QuantizationInfo(0.5f, 20) })),
308  framework::dataset::make("Src1QInfo", { QuantizationInfo(0.5f, 10) })),
309  framework::dataset::make("OutQInfo", { QuantizationInfo(0.5f, 5) })),
310  OutOfPlaceDataSet))
311 {
312  // Validate output
313  validate(Accessor(_target), _reference, tolerance_quant);
314 }
315 TEST_SUITE_END() // QASYMM8_SIGNED
316 
317 TEST_SUITE(QSYMM16)
318 FIXTURE_DATA_TEST_CASE(RunSmall,
319  NEArithmeticAdditionQuantizedFixture<int16_t>,
320  framework::DatasetMode::PRECOMMIT,
321  combine(combine(combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::QSYMM16)),
322  framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
323  framework::dataset::make("Src0QInfo", { QuantizationInfo(1.f / 32768.f, 0), QuantizationInfo(5.f / 32768.f, 0) })),
324  framework::dataset::make("Src1QInfo", { QuantizationInfo(2.f / 32768.f, 0), QuantizationInfo(5.f / 32768.f, 0) })),
325  framework::dataset::make("OutQInfo", { QuantizationInfo(5.f / 32768.f, 0) })),
326  OutOfPlaceDataSet))
327 {
328  // Validate output
329  validate(Accessor(_target), _reference, tolerance_quant);
330 }
331 TEST_SUITE_END() // QSYMM16
332 TEST_SUITE_END() // Quantized
333 
334 TEST_SUITE_END() // ArithmeticAddition
335 TEST_SUITE_END() // Neon
336 } // namespace validation
337 } // namespace test
338 } // namespace arm_compute
arm_compute::NEArithmeticAddition::configure
void configure(const ITensor *input1, const ITensor *input2, ITensor *output, ConvertPolicy policy, const ActivationLayerInfo &act_info=ActivationLayerInfo())
Initialise the kernel's inputs, output and conversion policy.
Definition: NEArithmeticAddition.cpp:54
Datasets.h
arm_compute::test::validation::TEST_SUITE_END
TEST_SUITE_END() FIXTURE_DATA_TEST_CASE(RunSmall
[CLActivationLayer Test snippet]
Definition: DequantizationLayer.cpp:111
PaddingCalculator.h
arm_compute::test::validation::TEST_CASE
TEST_CASE(FusedActivation, framework::DatasetMode::ALL)
Validate fused activation expecting the following behaviours:
Definition: ArithmeticAddition.cpp:93
NEArithmeticAddition.h
arm_compute::test::validation::actual
std::string actual
Definition: Cast.cpp:247
arm_compute::test::validation::FIXTURE_DATA_TEST_CASE
FIXTURE_DATA_TEST_CASE(RunSmall, CLAbsLayerFixture< half >, framework::DatasetMode::PRECOMMIT, combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F16)))
Definition: AbsLayer.cpp:50
arm_compute::test::validation::DATA_TEST_CASE
DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip(framework::dataset::make("InputInfo", { TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::QASYMM8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QSYMM16), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QSYMM16), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QSYMM16), }), framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F16), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QASYMM8), TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::QASYMM8), TensorInfo(TensorShape(30U, 11U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QSYMM16, QuantizationInfo(1.f/32768.f, 0)), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QSYMM16, QuantizationInfo(1.f/32768.f, 0)), TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::QSYMM16, QuantizationInfo(1.f/32768.f, 0)), })), framework::dataset::make("ActivationInfo", { ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::TANH), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::RELU), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::TANH), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LOGISTIC), ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::SQRT), })), framework::dataset::make("Expected", { false, true, true, true, false, false, true, true, false })), input_info, output_info, act_info, expected)
Definition: ActivationLayer.cpp:100
arm_compute::NEArithmeticAddition
Basic function to run cpu::kernels::CpuAddKernel.
Definition: NEArithmeticAddition.h:38
arm_compute::QuantizationInfo
Quantization information.
Definition: QuantizationInfo.h:68
arm_compute::cpuinfo::CpuIsaInfo::neon
bool neon
Definition: CpuIsaInfo.h:40
arm_compute::test::validation::combine
combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F32)))
Definition: AbsLayer.cpp:65
arm_compute::BorderSize
Container for 2D border size.
Definition: Types.h:242
arm_compute::DataType::QASYMM8
@ QASYMM8
quantized, asymmetric fixed-point 8-bit number unsigned
arm_compute::TensorShape
Shape of a tensor.
Definition: TensorShape.h:39
arm_compute::lower_string
std::string lower_string(const std::string &val)
Lower a given string.
Definition: StringUtils.cpp:38
Types.h
arm_compute::cpuinfo::CpuIsaInfo::fp16
bool fp16
Definition: CpuIsaInfo.h:47
arm_compute::test::validation::NEArithmeticAdditionBroadcastFixture
ArithmeticAdditionBroadcastValidationFixture< Tensor, Accessor, NEArithmeticAddition, T > NEArithmeticAdditionBroadcastFixture
Definition: ArithmeticAddition.cpp:244
CpuAddKernel.h
arm_compute::cpu::KernelSelectionType::Preferred
@ Preferred
Retrieve the best implementation available for the given Cpu ISA, ignoring the build flags.
arm_compute::test::Accessor
Accessor implementation for Tensor objects.
Definition: Accessor.h:35
arm_compute::test::validation::cpu_isa
cpuinfo::CpuIsaInfo cpu_isa
Definition: Cast.cpp:227
arm_compute::DataType::QSYMM16
@ QSYMM16
quantized, symmetric fixed-point 16-bit number
StringUtils.h
arm_compute::test::validation::cpu_ext
cpu_ext
Definition: Cast.cpp:222
arm_compute::test::validation::validate
validate(CLAccessor(output_state), expected_output)
CpuIsaInfo.h
arm_compute::utils::cast::U
U
Definition: SaturateCast.h:64
TensorAllocator.h
arm_compute::ConvertPolicy::WRAP
@ WRAP
Wrap around.
arm_compute::test::validation::output_info
output_info
Definition: DirectConvolutionLayer.cpp:547
arm_compute::cpuinfo::CpuIsaInfo::sve2
bool sve2
Definition: CpuIsaInfo.h:42
arm_compute::test::framework::DatasetMode::ALL
@ ALL
arm_compute::test::validation::NEArithmeticAdditionFixture
ArithmeticAdditionValidationFixture< Tensor, Accessor, NEArithmeticAddition, T > NEArithmeticAdditionFixture
Definition: ArithmeticAddition.cpp:62
arm_compute::test::validation::ARM_COMPUTE_EXPECT
ARM_COMPUTE_EXPECT(has_error==expected, framework::LogLevel::ERRORS)
arm_compute::test::framework::dataset::concat
JoinDataset< T, U > concat(T &&dataset1, U &&dataset2)
Helper function to create a JoinDataset.
Definition: JoinDataset.h:160
arm_compute::test::validation::NEArithmeticAdditionQuantizedBroadcastFixture
ArithmeticAdditionValidationQuantizedBroadcastFixture< Tensor, Accessor, NEArithmeticAddition, T > NEArithmeticAdditionQuantizedBroadcastFixture
Definition: ArithmeticAddition.cpp:270
arm_compute::test::framework::DatasetMode::NIGHTLY
@ NIGHTLY
arm_compute::DataType::U8
@ U8
unsigned 8-bit number
Asserts.h
Accessor.h
arm_compute::cpu_impl_dt
std::string cpu_impl_dt(const DataType &data_type)
Returns the suffix string of CPU kernel implementation names based on the given data type.
Definition: DataTypeUtils.h:481
arm_compute::DataType::S16
@ S16
signed 16-bit number
arm_compute::DataType::QASYMM8_SIGNED
@ QASYMM8_SIGNED
quantized, asymmetric fixed-point 8-bit number signed
arm_compute::test::validation::input1_info
input1_info
Definition: GEMMMatrixMultiplyReshaped.cpp:862
arm_compute::ConvertPolicy::SATURATE
@ SATURATE
Saturate.
Macros.h
arm_compute::test::framework::DatasetMode::PRECOMMIT
@ PRECOMMIT
arm_compute::test::validation::input2_info
input2_info
Definition: GEMMMatrixMultiplyReshaped.cpp:862
arm_compute::Tensor::info
ITensorInfo * info() const override
Interface to be implemented by the child class to return the tensor's metadata.
Definition: Tensor.cpp:33
arm_compute::NEArithmeticAddition::validate
static Status validate(const ITensorInfo *input1, const ITensorInfo *input2, const ITensorInfo *output, ConvertPolicy policy, const ActivationLayerInfo &act_info=ActivationLayerInfo())
Static function to check if given info will lead to a valid configuration of NEArithmeticAddition.
Definition: NEArithmeticAddition.cpp:49
Tensor.h
arm_compute::test::framework::dataset::make
std::enable_if< is_container< T >::value, ContainerDataset< T > >::type make(std::string name, T &&values)
Helper function to create a ContainerDataset.
Definition: ContainerDataset.h:160
arm_compute::test::validation::data_type
data_type
Definition: Cast.cpp:223
Validation.h
arm_compute::test::validation::selected_impl
const CpuCastKernel::CastKernel * selected_impl
Definition: Cast.cpp:225
arm_compute::cpuinfo::CpuIsaInfo::sve
bool sve
Definition: CpuIsaInfo.h:41
arm_compute::TensorInfo
Store the tensor's metadata.
Definition: TensorInfo.h:42
arm_compute::test::validation::zip
zip(zip(framework::dataset::make("Weights", { TensorInfo(TensorShape(32U, 13U, 2U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U, 2U), 1, DataType::F32), TensorInfo(TensorShape(32U, 13U, 2U, 1U), 1, DataType::F32), }), framework::dataset::make("MVBGInfo",{ TensorInfo(TensorShape(2U), 1, DataType::F32), TensorInfo(TensorShape(2U), 1, DataType::F16), TensorInfo(TensorShape(5U), 1, DataType::F32), })), framework::dataset::make("Expected", { true, false, false}))
arm_compute::test::validation::ARM_COMPUTE_EXPECT_EQUAL
ARM_COMPUTE_EXPECT_EQUAL(expected, actual, framework::LogLevel::ERRORS)
arm_compute::test::validation::tolerance_quant
constexpr AbsoluteTolerance< float > tolerance_quant(1)
arm_compute
Copyright (c) 2017-2023 Arm Limited.
Definition: introduction.dox:24
arm_compute::ConvertPolicy
ConvertPolicy
Policy to handle integer overflow.
Definition: Types.h:364
arm_compute::test::validation::TEST_SUITE
TEST_SUITE(QASYMM8_to_F32) FIXTURE_DATA_TEST_CASE(RunSmall
arm_compute::DataType::F16
@ F16
16-bit floating-point number
arm_compute::DataType::S32
@ S32
signed 32-bit number
arm_compute::test::validation::expected
expected
Definition: BatchNormalizationLayer.cpp:166
arm_compute::DataType::F32
@ F32
32-bit floating-point number
arm_compute::Tensor
Basic implementation of the tensor interface.
Definition: Tensor.h:37
arm_compute::test::validation::ARM_COMPUTE_ERROR_ON_NULLPTR
ARM_COMPUTE_ERROR_ON_NULLPTR(selected_impl)
arm_compute::test::framework::DatasetMode
DatasetMode
Possible dataset modes.
Definition: DatasetModes.h:40
arm_compute::DataType
DataType
Available data types.
Definition: CoreTypes.h:82
arm_compute::test::framework::LogLevel::ERRORS
@ ERRORS
arm_compute::ITensorInfo::padding
virtual PaddingSize padding() const =0
Padding of tensor.