1 /*
2 * Copyright (c) 2017-2020 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/runtime/NEON/functions/NEDepthConvertLayer.h"
26 #include "arm_compute/runtime/Tensor.h"
27 #include "arm_compute/runtime/TensorAllocator.h"
28 #include "tests/NEON/Accessor.h"
29 #include "tests/PaddingCalculator.h"
30 #include "tests/datasets/ConvertPolicyDataset.h"
31 #include "tests/datasets/ShapeDatasets.h"
32 #include "tests/framework/Asserts.h"
33 #include "tests/framework/Macros.h"
34 #include "tests/framework/datasets/Datasets.h"
35 #include "tests/validation/Validation.h"
36 #include "tests/validation/fixtures/DepthConvertLayerFixture.h"
37
38 namespace arm_compute
39 {
40 namespace test
41 {
42 namespace validation
43 {
44 namespace
45 {
46 /** Input data sets **/
47 const auto DepthConvertLayerQASYMM8toF16Dataset = combine(framework::dataset::make("DataType", DataType::QASYMM8), framework::dataset::make("DataType", DataType::F16));
48 const auto DepthConvertLayerQASYMM8toF32Dataset = combine(framework::dataset::make("DataType", DataType::QASYMM8), framework::dataset::make("DataType", DataType::F32));
49 const auto DepthConvertLayerQASYMM8toS32Dataset = combine(framework::dataset::make("DataType", DataType::QASYMM8), framework::dataset::make("DataType", DataType::S32));
50 const auto DepthConvertLayerU8toU16Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::U16));
51 const auto DepthConvertLayerU8toS16Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::S16));
52 const auto DepthConvertLayerU8toS32Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::S32));
53 const auto DepthConvertLayerU8toF16Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::F16));
54 const auto DepthConvertLayerU8toF32Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::F32));
55 const auto DepthConvertLayerU16toU8Dataset = combine(framework::dataset::make("DataType", DataType::U16), framework::dataset::make("DataType", DataType::U8));
56 const auto DepthConvertLayerU16toU32Dataset = combine(framework::dataset::make("DataType", DataType::U16), framework::dataset::make("DataType", DataType::U32));
57 const auto DepthConvertLayerS16toU8Dataset = combine(framework::dataset::make("DataType", DataType::S16), framework::dataset::make("DataType", DataType::U8));
58 const auto DepthConvertLayerS16toS32Dataset = combine(framework::dataset::make("DataType", DataType::S16), framework::dataset::make("DataType", DataType::S32));
59 const auto DepthConvertLayerBF16toF32Dataset = combine(framework::dataset::make("DataType", DataType::BFLOAT16), framework::dataset::make("DataType", DataType::F32));
60 const auto DepthConvertLayerF16toU8Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::U8));
61 const auto DepthConvertLayerF16toF32Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::F32));
62 const auto DepthConvertLayerF16toS32Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::S32));
63 const auto DepthConvertLayerF32toF16Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::F16));
64 const auto DepthConvertLayerF32toS32Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::S32));
65 const auto DepthConvertLayerF32toU8Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::U8));
66 const auto DepthConvertLayerF32toBF16Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::BFLOAT16));
67
68 const auto DepthConvertLayerS32toF32Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::F32));
69 const auto DepthConvertLayerS32toQASYMM8Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::QASYMM8));
70 const auto DepthConvertLayerS32toF16Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::F16));
71 const auto DepthConvertLayerS32toU8Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::U8));
72
73 const auto DepthConvertLayerF16toQASYMM8Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::QASYMM8));
74 const auto DepthConvertLayerF32toQASYMM8Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::QASYMM8));
75 const auto DepthConvertLayerShiftDatasetNightly = framework::dataset::make("Shift", 0, 7);
76 const auto DepthConvertLayerShiftDatasetPrecommit = framework::dataset::make("Shift", { 0, 3, 6 });
77 const auto DepthConvertLayerZeroShiftDataset = framework::dataset::make("Shift", 0);
78
79 constexpr AbsoluteTolerance<uint8_t> tolerance_qasymm8(1);
80 constexpr AbsoluteTolerance<int32_t> tolerance_one_int32(1);
81 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
82 constexpr AbsoluteTolerance<uint8_t> tolerance_one_uint8(1);
83 #endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */
84 } // namespace
85
86 TEST_SUITE(NEON)
TEST_SUITE(DepthConvertLayer)87 TEST_SUITE(DepthConvertLayer)
88
89 // *INDENT-OFF*
90 // clang-format off
91 DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(
92 framework::dataset::make("InputInfo", { TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U16), // Invalid data type combination
93 TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::S16), // Invalid data type combination
94 TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), // Mismatching shapes
95 TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8), // Invalid shift
96 TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8), // Valid
97 }),
98 framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32),
99 TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32),
100 TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),
101 TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8),
102 })),
103 framework::dataset::make("Policy",{ ConvertPolicy::WRAP,
104 ConvertPolicy::WRAP,
105 ConvertPolicy::WRAP,
106 ConvertPolicy::WRAP,
107 ConvertPolicy::WRAP,
108 ConvertPolicy::WRAP,
109 ConvertPolicy::WRAP,
110 })),
111 framework::dataset::make("Shift",{ 1, 1, 1, 1, 1, 1, 8, 1,
112 })),
113 framework::dataset::make("Expected", { false, false, false, false, true})),
114 input_info, output_info, policy, shift, expected)
115 {
116 ARM_COMPUTE_EXPECT(bool(NEDepthConvertLayer::validate(&input_info.clone()->set_is_resizable(false), &output_info.clone()->set_is_resizable(false), policy, shift)) == expected, framework::LogLevel::ERRORS);
117 }
118 // clang-format on
119 // *INDENT-ON*
120
121 template <typename T>
122 using NEDepthConvertLayerToU16Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, uint16_t>;
123 template <typename T>
124 using NEDepthConvertLayerToS16Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, int16_t>;
125 template <typename T>
126 using NEDepthConvertLayerToS32Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, int32_t>;
127 template <typename T>
128 using NEDepthConvertLayerToU8Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, uint8_t>;
129 template <typename T>
130 using NEDepthConvertLayerToU32Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, uint32_t>;
131 template <typename T>
132 using NEDepthConvertLayerToBF16Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, bfloat16>;
133 template <typename T>
134 using NEDepthConvertLayerToF16Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, half>;
135 template <typename T>
136 using NEDepthConvertLayerToF32Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, float>;
137 template <typename T>
138 using NEDepthConvertLayerToQASYMM8Fixture = DepthConvertLayerValidationQuantizedFixture<Tensor, Accessor, NEDepthConvertLayer, T, uint8_t>;
139 template <typename T>
140 using NEDepthConvertLayerQuantizedToF16Fixture = DepthConvertLayerValidationQuantizedFixture<Tensor, Accessor, NEDepthConvertLayer, T, half>;
141 template <typename T>
142 using NEDepthConvertLayerQuantizedToF32Fixture = DepthConvertLayerValidationQuantizedFixture<Tensor, Accessor, NEDepthConvertLayer, T, float>;
143 template <typename T>
144 using NEDepthConvertLayerQuantizedToS32Fixture = DepthConvertLayerValidationQuantizedFixture<Tensor, Accessor, NEDepthConvertLayer, T, int32_t>;
145
146 TEST_SUITE(QASYMM8_to_F32)
147 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerQuantizedToF32Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),
148 DepthConvertLayerQASYMM8toF32Dataset),
149 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
150 DepthConvertLayerZeroShiftDataset),
151 framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))
152 {
153 // Validate output
154 validate(Accessor(_target), _reference);
155 }
156 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerQuantizedToF32Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),
157 DepthConvertLayerQASYMM8toF32Dataset),
158 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
159 DepthConvertLayerZeroShiftDataset),
160 framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))
161 {
162 // Validate output
163 validate(Accessor(_target), _reference);
164 }
165 TEST_SUITE_END() // QASYMM8_to_F32
166
TEST_SUITE(QASYMM8_to_S32)167 TEST_SUITE(QASYMM8_to_S32)
168 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerQuantizedToS32Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),
169 DepthConvertLayerQASYMM8toS32Dataset),
170 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
171 DepthConvertLayerZeroShiftDataset),
172 framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))
173 {
174 // Validate output
175 validate(Accessor(_target), _reference);
176 }
177 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerQuantizedToS32Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),
178 DepthConvertLayerQASYMM8toS32Dataset),
179 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
180 DepthConvertLayerZeroShiftDataset),
181 framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))
182 {
183 // Validate output
184 validate(Accessor(_target), _reference);
185 }
186 TEST_SUITE_END() // QASYMM8_to_S32
187
TEST_SUITE(U8_to_U16)188 TEST_SUITE(U8_to_U16)
189 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU16Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toU16Dataset),
190 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
191 DepthConvertLayerShiftDatasetPrecommit))
192 {
193 // Validate output
194 validate(Accessor(_target), _reference);
195 }
196
197 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU16Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toU16Dataset),
198 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
199 DepthConvertLayerShiftDatasetNightly))
200 {
201 // Validate output
202 validate(Accessor(_target), _reference);
203 }
204 TEST_SUITE_END() // U8_to_U16
205
TEST_SUITE(U8_to_S16)206 TEST_SUITE(U8_to_S16)
207 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToS16Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toS16Dataset),
208 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
209 DepthConvertLayerShiftDatasetPrecommit))
210 {
211 // Validate output
212 validate(Accessor(_target), _reference);
213 }
214
215 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToS16Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toS16Dataset),
216 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
217 DepthConvertLayerShiftDatasetNightly))
218 {
219 // Validate output
220 validate(Accessor(_target), _reference);
221 }
222 TEST_SUITE_END() // U8_to_S16
TEST_SUITE(U8_to_S32)223 TEST_SUITE(U8_to_S32)
224 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToS32Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toS32Dataset),
225 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
226 DepthConvertLayerShiftDatasetPrecommit))
227 {
228 // Validate output
229 validate(Accessor(_target), _reference);
230 }
231
232 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToS32Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toS32Dataset),
233 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
234 DepthConvertLayerShiftDatasetNightly))
235 {
236 // Validate output
237 validate(Accessor(_target), _reference);
238 }
239 TEST_SUITE_END() // U8_to_S32
240
TEST_SUITE(U8_to_F32)241 TEST_SUITE(U8_to_F32)
242 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToF32Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toF32Dataset),
243 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
244 DepthConvertLayerShiftDatasetPrecommit))
245 {
246 // Validate output
247 validate(Accessor(_target), _reference);
248 }
249
250 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToF32Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toF32Dataset),
251 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
252 DepthConvertLayerShiftDatasetNightly))
253 {
254 // Validate output
255 validate(Accessor(_target), _reference);
256 }
257 TEST_SUITE_END() // U8_to_F32
258
259 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
TEST_SUITE(U8_to_F16)260 TEST_SUITE(U8_to_F16)
261 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToF16Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toF16Dataset),
262 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
263 DepthConvertLayerShiftDatasetPrecommit))
264 {
265 // Validate output
266 validate(Accessor(_target), _reference);
267 }
268
269 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToF16Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toF16Dataset),
270 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
271 DepthConvertLayerShiftDatasetNightly))
272 {
273 // Validate output
274 validate(Accessor(_target), _reference);
275 }
276 TEST_SUITE_END() // U8_to_F36
277 #endif // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
278
TEST_SUITE(U16_to_U8)279 TEST_SUITE(U16_to_U8)
280 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU8Fixture<uint16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU16toU8Dataset),
281 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
282 DepthConvertLayerShiftDatasetPrecommit))
283 {
284 // Validate output
285 validate(Accessor(_target), _reference);
286 }
287 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU8Fixture<uint16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU16toU8Dataset),
288 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
289 DepthConvertLayerShiftDatasetNightly))
290 {
291 // Validate output
292 validate(Accessor(_target), _reference);
293 }
294 TEST_SUITE_END() // U16_to_U8
295
TEST_SUITE(U16_to_U32)296 TEST_SUITE(U16_to_U32)
297 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU32Fixture<uint16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU16toU32Dataset),
298 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
299 DepthConvertLayerShiftDatasetPrecommit))
300 {
301 // Validate output
302 validate(Accessor(_target), _reference);
303 }
304 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU32Fixture<uint16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU16toU32Dataset),
305 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
306 DepthConvertLayerShiftDatasetNightly))
307 {
308 // Validate output
309 validate(Accessor(_target), _reference);
310 }
311 TEST_SUITE_END() // U16_to_U32
312
TEST_SUITE(S16_to_U8)313 TEST_SUITE(S16_to_U8)
314 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU8Fixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerS16toU8Dataset),
315 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
316 DepthConvertLayerShiftDatasetPrecommit))
317 {
318 // Validate output
319 validate(Accessor(_target), _reference);
320 }
321 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU8Fixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerS16toU8Dataset),
322 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
323 DepthConvertLayerShiftDatasetNightly))
324 {
325 // Validate output
326 validate(Accessor(_target), _reference);
327 }
328 TEST_SUITE_END() // S16_to_U8
329
TEST_SUITE(S16_to_S32)330 TEST_SUITE(S16_to_S32)
331 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToS32Fixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerS16toS32Dataset),
332 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
333 DepthConvertLayerShiftDatasetPrecommit))
334 {
335 // Validate output
336 validate(Accessor(_target), _reference);
337 }
338 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToS32Fixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerS16toS32Dataset),
339 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
340 DepthConvertLayerShiftDatasetNightly))
341 {
342 // Validate output
343 validate(Accessor(_target), _reference);
344 }
345 TEST_SUITE_END() // S16_to_S32
346
347 #if defined(__ARM_FEATURE_BF16_VECTOR_ARITHMETIC) || defined(ARM_COMPUTE_FORCE_BF16)
TEST_SUITE(BFLOAT16_to_F32)348 TEST_SUITE(BFLOAT16_to_F32)
349 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToF32Fixture<bfloat16>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerBF16toF32Dataset),
350 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
351 DepthConvertLayerZeroShiftDataset))
352 {
353 // Validate output
354 validate(Accessor(_target), _reference);
355 }
356 TEST_SUITE_END() // BFLOAT16_to_F32
357
TEST_SUITE(F32_to_BFLOAT16)358 TEST_SUITE(F32_to_BFLOAT16)
359 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToBF16Fixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF32toBF16Dataset),
360 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
361 DepthConvertLayerZeroShiftDataset))
362 {
363 // Validate output
364 validate(Accessor(_target), _reference);
365 }
366 TEST_SUITE_END() // F32_to_BFLOAT16
367 #endif /* defined(__ARM_FEATURE_BF16_VECTOR_ARITHMETIC) || defined(ARM_COMPUTE_FORCE_BF16) */
368
369 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
TEST_SUITE(F16_to_QASYMM8)370 TEST_SUITE(F16_to_QASYMM8)
371 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToQASYMM8Fixture<half>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),
372 DepthConvertLayerF16toQASYMM8Dataset),
373 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
374 DepthConvertLayerZeroShiftDataset),
375 framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))
376 {
377 // Validate output
378 validate(Accessor(_target), _reference, tolerance_qasymm8);
379 }
380 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToQASYMM8Fixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),
381 DepthConvertLayerF16toQASYMM8Dataset),
382 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
383 DepthConvertLayerZeroShiftDataset),
384 framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))
385 {
386 // Validate output
387 validate(Accessor(_target), _reference, tolerance_qasymm8);
388 }
389 TEST_SUITE_END() // F16_to_QASYMM8
390
TEST_SUITE(F16_to_U8)391 TEST_SUITE(F16_to_U8)
392 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU8Fixture<half>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF16toU8Dataset),
393 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
394 DepthConvertLayerZeroShiftDataset))
395 {
396 // Validate output
397 validate(Accessor(_target), _reference, tolerance_one_uint8);
398 }
399 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU8Fixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF16toU8Dataset),
400 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
401 DepthConvertLayerZeroShiftDataset))
402 {
403 // Validate output
404 validate(Accessor(_target), _reference, tolerance_one_uint8);
405 }
406 TEST_SUITE_END() // F16_to_U8
407
TEST_SUITE(F16_to_F32)408 TEST_SUITE(F16_to_F32)
409 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToF32Fixture<half>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF16toF32Dataset),
410 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
411 DepthConvertLayerZeroShiftDataset))
412 {
413 // Validate output
414 validate(Accessor(_target), _reference);
415 }
416 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToF32Fixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF16toF32Dataset),
417 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
418 DepthConvertLayerZeroShiftDataset))
419 {
420 // Validate output
421 validate(Accessor(_target), _reference);
422 }
423 TEST_SUITE_END() // F16_to_F32
424
TEST_SUITE(F16_to_S32)425 TEST_SUITE(F16_to_S32)
426 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToS32Fixture<half>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF16toS32Dataset),
427 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
428 DepthConvertLayerZeroShiftDataset))
429 {
430 // Validate output
431 validate(Accessor(_target), _reference, tolerance_one_int32);
432 }
433 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToS32Fixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF16toS32Dataset),
434 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
435 DepthConvertLayerZeroShiftDataset))
436 {
437 // Validate output
438 validate(Accessor(_target), _reference, tolerance_one_int32);
439 }
440
441 TEST_SUITE_END() // F16_to_S32
442
TEST_SUITE(QASYMM8_to_F16)443 TEST_SUITE(QASYMM8_to_F16)
444 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerQuantizedToF16Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),
445 DepthConvertLayerQASYMM8toF16Dataset),
446 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
447 DepthConvertLayerZeroShiftDataset),
448 framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))
449 {
450 // Validate output
451 validate(Accessor(_target), _reference);
452 }
453 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerQuantizedToF16Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),
454 DepthConvertLayerQASYMM8toF16Dataset),
455 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
456 DepthConvertLayerZeroShiftDataset),
457 framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))
458 {
459 // Validate output
460 validate(Accessor(_target), _reference);
461 }
462 TEST_SUITE_END() // QASYMM8_to_F16
463
TEST_SUITE(F32_to_F16)464 TEST_SUITE(F32_to_F16)
465 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToF16Fixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF32toF16Dataset),
466 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
467 DepthConvertLayerZeroShiftDataset))
468 {
469 // Validate output
470 validate(Accessor(_target), _reference);
471 }
472 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToF16Fixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF32toF16Dataset),
473 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
474 DepthConvertLayerZeroShiftDataset))
475 {
476 // Validate output
477 validate(Accessor(_target), _reference);
478 }
479 TEST_SUITE_END() // F32_to_F16
480
TEST_SUITE(S32_to_F16)481 TEST_SUITE(S32_to_F16)
482 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToF16Fixture<int32_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerS32toF16Dataset),
483 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
484 DepthConvertLayerZeroShiftDataset))
485 {
486 // Validate output
487 validate(Accessor(_target), _reference);
488 }
489 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToF16Fixture<int32_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerS32toF16Dataset),
490 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
491 DepthConvertLayerZeroShiftDataset))
492 {
493 // Validate output
494 validate(Accessor(_target), _reference);
495 }
496 TEST_SUITE_END() // S32_to_F16
497
498 #endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */
499
TEST_SUITE(F32_to_S32)500 TEST_SUITE(F32_to_S32)
501 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToS32Fixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF32toS32Dataset),
502 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
503 DepthConvertLayerZeroShiftDataset))
504 {
505 // Validate output
506 validate(Accessor(_target), _reference, tolerance_one_int32);
507 }
508 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToS32Fixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF32toS32Dataset),
509 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
510 DepthConvertLayerZeroShiftDataset))
511 {
512 // Validate output
513 validate(Accessor(_target), _reference, tolerance_one_int32);
514 }
515 TEST_SUITE_END() // F32_to_S32
516
TEST_SUITE(F32_to_U8)517 TEST_SUITE(F32_to_U8)
518 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU8Fixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF32toU8Dataset),
519 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
520 DepthConvertLayerZeroShiftDataset))
521 {
522 // Validate output
523 validate(Accessor(_target), _reference, tolerance_one_int32);
524 }
525 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU8Fixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF32toU8Dataset),
526 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
527 DepthConvertLayerZeroShiftDataset))
528 {
529 // Validate output
530 validate(Accessor(_target), _reference, tolerance_one_int32);
531 }
532 TEST_SUITE_END() // F32_to_U8
533
TEST_SUITE(F32_to_QASYMM8)534 TEST_SUITE(F32_to_QASYMM8)
535 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToQASYMM8Fixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),
536 DepthConvertLayerF32toQASYMM8Dataset),
537 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
538 DepthConvertLayerZeroShiftDataset),
539 framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))
540 {
541 // Validate output
542 validate(Accessor(_target), _reference, tolerance_qasymm8);
543 }
544 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToQASYMM8Fixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),
545 DepthConvertLayerF32toQASYMM8Dataset),
546 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
547 DepthConvertLayerZeroShiftDataset),
548 framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))
549 {
550 // Validate output
551 validate(Accessor(_target), _reference, tolerance_qasymm8);
552 }
553 TEST_SUITE_END() // F32_to_QASYMM8
554
TEST_SUITE(S32_to_F32)555 TEST_SUITE(S32_to_F32)
556 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToF32Fixture<int32_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerS32toF32Dataset),
557 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
558 DepthConvertLayerZeroShiftDataset))
559 {
560 // Validate output
561 validate(Accessor(_target), _reference);
562 }
563 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToF32Fixture<int32_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerS32toF32Dataset),
564 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
565 DepthConvertLayerZeroShiftDataset))
566 {
567 // Validate output
568 validate(Accessor(_target), _reference);
569 }
570 TEST_SUITE_END() // S32_to_F32
571
TEST_SUITE(S32_to_QASYMM8)572 TEST_SUITE(S32_to_QASYMM8)
573 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToQASYMM8Fixture<int32_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),
574 DepthConvertLayerS32toQASYMM8Dataset),
575 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
576 DepthConvertLayerZeroShiftDataset),
577 framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))
578 {
579 // Validate output
580 validate(Accessor(_target), _reference, tolerance_qasymm8);
581 }
582 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToQASYMM8Fixture<int32_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),
583 DepthConvertLayerS32toQASYMM8Dataset),
584 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),
585 DepthConvertLayerZeroShiftDataset),
586 framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))
587 {
588 // Validate output
589 validate(Accessor(_target), _reference, tolerance_qasymm8);
590 }
591 TEST_SUITE_END() // S32_to_QASYMM8
592
TEST_SUITE(S32_to_U8)593 TEST_SUITE(S32_to_U8)
594 FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU8Fixture<int32_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerS32toU8Dataset),
595 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
596 DepthConvertLayerZeroShiftDataset))
597 {
598 // Validate output
599 validate(Accessor(_target), _reference);
600 }
601 FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU8Fixture<int32_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerS32toU8Dataset),
602 framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),
603 DepthConvertLayerZeroShiftDataset))
604 {
605 // Validate output
606 validate(Accessor(_target), _reference);
607 }
608 TEST_SUITE_END() // S32_to_U8
609
610 TEST_SUITE_END() // DepthConvertLayer
611 TEST_SUITE_END() // NEON
612 } // namespace validation
613 } // namespace test
614 } // namespace arm_compute
615